blob: ca85b5756721fb45e96fb0565c3b1971b4338533 [file] [log] [blame]
/*
* Copyright 2004 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <memory>
#if defined(WEBRTC_WIN)
#include "rtc_base/win32.h"
#else // !WEBRTC_WIN
#define SEC_E_CERT_EXPIRED (-2146893016)
#endif // !WEBRTC_WIN
#include "rtc_base/checks.h"
#include "rtc_base/httpbase.h"
#include "rtc_base/logging.h"
#include "rtc_base/socket.h"
#include "rtc_base/stringutils.h"
#include "rtc_base/system/fallthrough.h"
#include "rtc_base/thread.h"
namespace rtc {
//////////////////////////////////////////////////////////////////////
// Helpers
//////////////////////////////////////////////////////////////////////
bool MatchHeader(const char* str, size_t len, HttpHeader header) {
const char* const header_str = ToString(header);
const size_t header_len = strlen(header_str);
return (len == header_len) && (_strnicmp(str, header_str, header_len) == 0);
}
enum {
MSG_READ
};
//////////////////////////////////////////////////////////////////////
// HttpParser
//////////////////////////////////////////////////////////////////////
HttpParser::HttpParser() {
reset();
}
HttpParser::~HttpParser() {
}
void
HttpParser::reset() {
state_ = ST_LEADER;
chunked_ = false;
data_size_ = SIZE_UNKNOWN;
}
HttpParser::ProcessResult
HttpParser::Process(const char* buffer, size_t len, size_t* processed,
HttpError* error) {
*processed = 0;
*error = HE_NONE;
if (state_ >= ST_COMPLETE) {
RTC_NOTREACHED();
return PR_COMPLETE;
}
while (true) {
if (state_ < ST_DATA) {
size_t pos = *processed;
while ((pos < len) && (buffer[pos] != '\n')) {
pos += 1;
}
if (pos >= len) {
break; // don't have a full header
}
const char* line = buffer + *processed;
size_t len = (pos - *processed);
*processed = pos + 1;
while ((len > 0) && isspace(static_cast<unsigned char>(line[len-1]))) {
len -= 1;
}
ProcessResult result = ProcessLine(line, len, error);
RTC_LOG(LS_VERBOSE) << "Processed line, result=" << result;
if (PR_CONTINUE != result) {
return result;
}
} else if (data_size_ == 0) {
if (chunked_) {
state_ = ST_CHUNKTERM;
} else {
return PR_COMPLETE;
}
} else {
size_t available = len - *processed;
if (available <= 0) {
break; // no more data
}
if ((data_size_ != SIZE_UNKNOWN) && (available > data_size_)) {
available = data_size_;
}
size_t read = 0;
ProcessResult result = ProcessData(buffer + *processed, available, read,
error);
RTC_LOG(LS_VERBOSE) << "Processed data, result: " << result
<< " read: " << read << " err: " << error;
if (PR_CONTINUE != result) {
return result;
}
*processed += read;
if (data_size_ != SIZE_UNKNOWN) {
data_size_ -= read;
}
}
}
return PR_CONTINUE;
}
HttpParser::ProcessResult
HttpParser::ProcessLine(const char* line, size_t len, HttpError* error) {
RTC_LOG_F(LS_VERBOSE) << " state: " << state_
<< " line: " << std::string(line, len)
<< " len: " << len << " err: " << error;
switch (state_) {
case ST_LEADER:
state_ = ST_HEADERS;
return ProcessLeader(line, len, error);
case ST_HEADERS:
if (len > 0) {
const char* value = strchrn(line, len, ':');
if (!value) {
*error = HE_PROTOCOL;
return PR_COMPLETE;
}
size_t nlen = (value - line);
const char* eol = line + len;
do {
value += 1;
} while ((value < eol) && isspace(static_cast<unsigned char>(*value)));
size_t vlen = eol - value;
if (MatchHeader(line, nlen, HH_CONTENT_LENGTH)) {
// sscanf isn't safe with strings that aren't null-terminated, and there
// is no guarantee that |value| is.
// Create a local copy that is null-terminated.
std::string value_str(value, vlen);
unsigned int temp_size;
if (sscanf(value_str.c_str(), "%u", &temp_size) != 1) {
*error = HE_PROTOCOL;
return PR_COMPLETE;
}
data_size_ = static_cast<size_t>(temp_size);
} else if (MatchHeader(line, nlen, HH_TRANSFER_ENCODING)) {
if ((vlen == 7) && (_strnicmp(value, "chunked", 7) == 0)) {
chunked_ = true;
} else if ((vlen == 8) && (_strnicmp(value, "identity", 8) == 0)) {
chunked_ = false;
} else {
*error = HE_PROTOCOL;
return PR_COMPLETE;
}
}
return ProcessHeader(line, nlen, value, vlen, error);
} else {
state_ = chunked_ ? ST_CHUNKSIZE : ST_DATA;
return ProcessHeaderComplete(chunked_, data_size_, error);
}
break;
case ST_CHUNKSIZE:
if (len > 0) {
char* ptr = nullptr;
data_size_ = strtoul(line, &ptr, 16);
if (ptr != line + len) {
*error = HE_PROTOCOL;
return PR_COMPLETE;
}
state_ = (data_size_ == 0) ? ST_TRAILERS : ST_DATA;
} else {
*error = HE_PROTOCOL;
return PR_COMPLETE;
}
break;
case ST_CHUNKTERM:
if (len > 0) {
*error = HE_PROTOCOL;
return PR_COMPLETE;
} else {
state_ = chunked_ ? ST_CHUNKSIZE : ST_DATA;
}
break;
case ST_TRAILERS:
if (len == 0) {
return PR_COMPLETE;
}
// *error = onHttpRecvTrailer();
break;
default:
RTC_NOTREACHED();
break;
}
return PR_CONTINUE;
}
bool
HttpParser::is_valid_end_of_input() const {
return (state_ == ST_DATA) && (data_size_ == SIZE_UNKNOWN);
}
void
HttpParser::complete(HttpError error) {
if (state_ < ST_COMPLETE) {
state_ = ST_COMPLETE;
OnComplete(error);
}
}
//////////////////////////////////////////////////////////////////////
// HttpBase::DocumentStream
//////////////////////////////////////////////////////////////////////
class BlockingMemoryStream : public ExternalMemoryStream {
public:
BlockingMemoryStream(char* buffer, size_t size)
: ExternalMemoryStream(buffer, size) { }
StreamResult DoReserve(size_t size, int* error) override {
return (buffer_length_ >= size) ? SR_SUCCESS : SR_BLOCK;
}
};
class HttpBase::DocumentStream : public StreamInterface {
public:
DocumentStream(HttpBase* base) : base_(base), error_(HE_DEFAULT) { }
StreamState GetState() const override {
if (nullptr == base_)
return SS_CLOSED;
if (HM_RECV == base_->mode_)
return SS_OPEN;
return SS_OPENING;
}
StreamResult Read(void* buffer,
size_t buffer_len,
size_t* read,
int* error) override {
if (!base_) {
if (error) *error = error_;
return (HE_NONE == error_) ? SR_EOS : SR_ERROR;
}
if (HM_RECV != base_->mode_) {
return SR_BLOCK;
}
// DoReceiveLoop writes http document data to the StreamInterface* document
// member of HttpData. In this case, we want this data to be written
// directly to our buffer. To accomplish this, we wrap our buffer with a
// StreamInterface, and replace the existing document with our wrapper.
// When the method returns, we restore the old document. Ideally, we would
// pass our StreamInterface* to DoReceiveLoop, but due to the callbacks
// of HttpParser, we would still need to store the pointer temporarily.
std::unique_ptr<StreamInterface> stream(
new BlockingMemoryStream(reinterpret_cast<char*>(buffer), buffer_len));
// Replace the existing document with our wrapped buffer.
base_->data_->document.swap(stream);
// Pump the I/O loop. DoReceiveLoop is guaranteed not to attempt to
// complete the I/O process, which means that our wrapper is not in danger
// of being deleted. To ensure this, DoReceiveLoop returns true when it
// wants complete to be called. We make sure to uninstall our wrapper
// before calling complete().
HttpError http_error;
bool complete = base_->DoReceiveLoop(&http_error);
// Reinstall the original output document.
base_->data_->document.swap(stream);
// If we reach the end of the receive stream, we disconnect our stream
// adapter from the HttpBase, and further calls to read will either return
// EOS or ERROR, appropriately. Finally, we call complete().
StreamResult result = SR_BLOCK;
if (complete) {
HttpBase* base = Disconnect(http_error);
if (error) *error = error_;
result = (HE_NONE == error_) ? SR_EOS : SR_ERROR;
base->complete(http_error);
}
// Even if we are complete, if some data was read we must return SUCCESS.
// Future Reads will return EOS or ERROR based on the error_ variable.
size_t position;
stream->GetPosition(&position);
if (position > 0) {
if (read) *read = position;
result = SR_SUCCESS;
}
return result;
}
StreamResult Write(const void* data,
size_t data_len,
size_t* written,
int* error) override {
if (error) *error = -1;
return SR_ERROR;
}
void Close() override {
if (base_) {
HttpBase* base = Disconnect(HE_NONE);
if (HM_RECV == base->mode_ && base->http_stream_) {
// Read I/O could have been stalled on the user of this DocumentStream,
// so restart the I/O process now that we've removed ourselves.
base->http_stream_->PostEvent(SE_READ, 0);
}
}
}
bool GetAvailable(size_t* size) const override {
if (!base_ || HM_RECV != base_->mode_)
return false;
size_t data_size = base_->GetDataRemaining();
if (SIZE_UNKNOWN == data_size)
return false;
if (size)
*size = data_size;
return true;
}
HttpBase* Disconnect(HttpError error) {
RTC_DCHECK(nullptr != base_);
RTC_DCHECK(nullptr != base_->doc_stream_);
HttpBase* base = base_;
base_->doc_stream_ = nullptr;
base_ = nullptr;
error_ = error;
return base;
}
private:
HttpBase* base_;
HttpError error_;
};
//////////////////////////////////////////////////////////////////////
// HttpBase
//////////////////////////////////////////////////////////////////////
HttpBase::HttpBase()
: mode_(HM_NONE),
data_(nullptr),
notify_(nullptr),
http_stream_(nullptr),
doc_stream_(nullptr) {}
HttpBase::~HttpBase() {
RTC_DCHECK(HM_NONE == mode_);
}
bool
HttpBase::isConnected() const {
return (http_stream_ != nullptr) && (http_stream_->GetState() == SS_OPEN);
}
bool
HttpBase::attach(StreamInterface* stream) {
if ((mode_ != HM_NONE) || (http_stream_ != nullptr) || (stream == nullptr)) {
RTC_NOTREACHED();
return false;
}
http_stream_ = stream;
http_stream_->SignalEvent.connect(this, &HttpBase::OnHttpStreamEvent);
mode_ = (http_stream_->GetState() == SS_OPENING) ? HM_CONNECT : HM_NONE;
return true;
}
StreamInterface*
HttpBase::detach() {
RTC_DCHECK(HM_NONE == mode_);
if (mode_ != HM_NONE) {
return nullptr;
}
StreamInterface* stream = http_stream_;
http_stream_ = nullptr;
if (stream) {
stream->SignalEvent.disconnect(this);
}
return stream;
}
void
HttpBase::send(HttpData* data) {
RTC_DCHECK(HM_NONE == mode_);
if (mode_ != HM_NONE) {
return;
} else if (!isConnected()) {
OnHttpStreamEvent(http_stream_, SE_CLOSE, HE_DISCONNECTED);
return;
}
mode_ = HM_SEND;
data_ = data;
len_ = 0;
ignore_data_ = chunk_data_ = false;
if (data_->document) {
data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
}
std::string encoding;
if (data_->hasHeader(HH_TRANSFER_ENCODING, &encoding)
&& (encoding == "chunked")) {
chunk_data_ = true;
}
len_ = data_->formatLeader(buffer_, sizeof(buffer_));
len_ += strcpyn(buffer_ + len_, sizeof(buffer_) - len_, "\r\n");
header_ = data_->begin();
if (header_ == data_->end()) {
// We must call this at least once, in the case where there are no headers.
queue_headers();
}
flush_data();
}
void
HttpBase::recv(HttpData* data) {
RTC_DCHECK(HM_NONE == mode_);
if (mode_ != HM_NONE) {
return;
} else if (!isConnected()) {
OnHttpStreamEvent(http_stream_, SE_CLOSE, HE_DISCONNECTED);
return;
}
mode_ = HM_RECV;
data_ = data;
len_ = 0;
ignore_data_ = chunk_data_ = false;
reset();
if (doc_stream_) {
doc_stream_->SignalEvent(doc_stream_, SE_OPEN | SE_READ, 0);
} else {
read_and_process_data();
}
}
void
HttpBase::abort(HttpError err) {
if (mode_ != HM_NONE) {
if (http_stream_ != nullptr) {
http_stream_->Close();
}
do_complete(err);
}
}
StreamInterface* HttpBase::GetDocumentStream() {
if (doc_stream_)
return nullptr;
doc_stream_ = new DocumentStream(this);
return doc_stream_;
}
HttpError HttpBase::HandleStreamClose(int error) {
if (http_stream_ != nullptr) {
http_stream_->Close();
}
if (error == 0) {
if ((mode_ == HM_RECV) && is_valid_end_of_input()) {
return HE_NONE;
} else {
return HE_DISCONNECTED;
}
} else if (error == SOCKET_EACCES) {
return HE_AUTH;
} else if (error == SEC_E_CERT_EXPIRED) {
return HE_CERTIFICATE_EXPIRED;
}
RTC_LOG_F(LS_ERROR) << "(" << error << ")";
return (HM_CONNECT == mode_) ? HE_CONNECT_FAILED : HE_SOCKET_ERROR;
}
bool HttpBase::DoReceiveLoop(HttpError* error) {
RTC_DCHECK(HM_RECV == mode_);
RTC_DCHECK(nullptr != error);
// Do to the latency between receiving read notifications from
// pseudotcpchannel, we rely on repeated calls to read in order to acheive
// ideal throughput. The number of reads is limited to prevent starving
// the caller.
size_t loop_count = 0;
const size_t kMaxReadCount = 20;
bool process_requires_more_data = false;
do {
// The most frequent use of this function is response to new data available
// on http_stream_. Therefore, we optimize by attempting to read from the
// network first (as opposed to processing existing data first).
if (len_ < sizeof(buffer_)) {
// Attempt to buffer more data.
size_t read;
int read_error;
StreamResult read_result = http_stream_->Read(buffer_ + len_,
sizeof(buffer_) - len_,
&read, &read_error);
switch (read_result) {
case SR_SUCCESS:
RTC_DCHECK(len_ + read <= sizeof(buffer_));
len_ += read;
break;
case SR_BLOCK:
if (process_requires_more_data) {
// We're can't make progress until more data is available.
return false;
}
// Attempt to process the data already in our buffer.
break;
case SR_EOS:
// Clean close, with no error.
read_error = 0;
RTC_FALLTHROUGH(); // Fall through to HandleStreamClose.
case SR_ERROR:
*error = HandleStreamClose(read_error);
return true;
}
} else if (process_requires_more_data) {
// We have too much unprocessed data in our buffer. This should only
// occur when a single HTTP header is longer than the buffer size (32K).
// Anything longer than that is almost certainly an error.
*error = HE_OVERFLOW;
return true;
}
// Process data in our buffer. Process is not guaranteed to process all
// the buffered data. In particular, it will wait until a complete
// protocol element (such as http header, or chunk size) is available,
// before processing it in its entirety. Also, it is valid and sometimes
// necessary to call Process with an empty buffer, since the state machine
// may have interrupted state transitions to complete.
size_t processed;
ProcessResult process_result = Process(buffer_, len_, &processed,
error);
RTC_DCHECK(processed <= len_);
len_ -= processed;
memmove(buffer_, buffer_ + processed, len_);
switch (process_result) {
case PR_CONTINUE:
// We need more data to make progress.
process_requires_more_data = true;
break;
case PR_BLOCK:
// We're stalled on writing the processed data.
return false;
case PR_COMPLETE:
// *error already contains the correct code.
return true;
}
} while (++loop_count <= kMaxReadCount);
RTC_LOG_F(LS_WARNING) << "danger of starvation";
return false;
}
void
HttpBase::read_and_process_data() {
HttpError error;
if (DoReceiveLoop(&error)) {
complete(error);
}
}
void
HttpBase::flush_data() {
RTC_DCHECK(HM_SEND == mode_);
// When send_required is true, no more buffering can occur without a network
// write.
bool send_required = (len_ >= sizeof(buffer_));
while (true) {
RTC_DCHECK(len_ <= sizeof(buffer_));
// HTTP is inherently sensitive to round trip latency, since a frequent use
// case is for small requests and responses to be sent back and forth, and
// the lack of pipelining forces a single request to take a minimum of the
// round trip time. As a result, it is to our benefit to pack as much data
// into each packet as possible. Thus, we defer network writes until we've
// buffered as much data as possible.
if (!send_required && (header_ != data_->end())) {
// First, attempt to queue more header data.
send_required = queue_headers();
}
if (!send_required && data_->document) {
// Next, attempt to queue document data.
const size_t kChunkDigits = 8;
size_t offset, reserve;
if (chunk_data_) {
// Reserve characters at the start for X-byte hex value and \r\n
offset = len_ + kChunkDigits + 2;
// ... and 2 characters at the end for \r\n
reserve = offset + 2;
} else {
offset = len_;
reserve = offset;
}
if (reserve >= sizeof(buffer_)) {
send_required = true;
} else {
size_t read;
int error;
StreamResult result = data_->document->Read(buffer_ + offset,
sizeof(buffer_) - reserve,
&read, &error);
if (result == SR_SUCCESS) {
RTC_DCHECK(reserve + read <= sizeof(buffer_));
if (chunk_data_) {
// Prepend the chunk length in hex.
// Note: sprintfn appends a null terminator, which is why we can't
// combine it with the line terminator.
sprintfn(buffer_ + len_, kChunkDigits + 1, "%.*x",
kChunkDigits, read);
// Add line terminator to the chunk length.
memcpy(buffer_ + len_ + kChunkDigits, "\r\n", 2);
// Add line terminator to the end of the chunk.
memcpy(buffer_ + offset + read, "\r\n", 2);
}
len_ = reserve + read;
} else if (result == SR_BLOCK) {
// Nothing to do but flush data to the network.
send_required = true;
} else if (result == SR_EOS) {
if (chunk_data_) {
// Append the empty chunk and empty trailers, then turn off
// chunking.
RTC_DCHECK(len_ + 5 <= sizeof(buffer_));
memcpy(buffer_ + len_, "0\r\n\r\n", 5);
len_ += 5;
chunk_data_ = false;
} else if (0 == len_) {
// No more data to read, and no more data to write.
do_complete();
return;
}
// Although we are done reading data, there is still data which needs
// to be flushed to the network.
send_required = true;
} else {
RTC_LOG_F(LS_ERROR) << "Read error: " << error;
do_complete(HE_STREAM);
return;
}
}
}
if (0 == len_) {
// No data currently available to send.
if (!data_->document) {
// If there is no source document, that means we're done.
do_complete();
}
return;
}
size_t written;
int error;
StreamResult result = http_stream_->Write(buffer_, len_, &written, &error);
if (result == SR_SUCCESS) {
RTC_DCHECK(written <= len_);
len_ -= written;
memmove(buffer_, buffer_ + written, len_);
send_required = false;
} else if (result == SR_BLOCK) {
if (send_required) {
// Nothing more we can do until network is writeable.
return;
}
} else {
RTC_DCHECK(result == SR_ERROR);
RTC_LOG_F(LS_ERROR) << "error";
OnHttpStreamEvent(http_stream_, SE_CLOSE, error);
return;
}
}
RTC_NOTREACHED();
}
bool
HttpBase::queue_headers() {
RTC_DCHECK(HM_SEND == mode_);
while (header_ != data_->end()) {
size_t len = sprintfn(buffer_ + len_, sizeof(buffer_) - len_,
"%.*s: %.*s\r\n",
header_->first.size(), header_->first.data(),
header_->second.size(), header_->second.data());
if (len_ + len < sizeof(buffer_) - 3) {
len_ += len;
++header_;
} else if (len_ == 0) {
RTC_LOG(WARNING) << "discarding header that is too long: "
<< header_->first;
++header_;
} else {
// Not enough room for the next header, write to network first.
return true;
}
}
// End of headers
len_ += strcpyn(buffer_ + len_, sizeof(buffer_) - len_, "\r\n");
return false;
}
void
HttpBase::do_complete(HttpError err) {
RTC_DCHECK(mode_ != HM_NONE);
HttpMode mode = mode_;
mode_ = HM_NONE;
if (data_ && data_->document) {
data_->document->SignalEvent.disconnect(this);
}
data_ = nullptr;
if ((HM_RECV == mode) && doc_stream_) {
RTC_DCHECK(HE_NONE !=
err); // We should have Disconnected doc_stream_ already.
DocumentStream* ds = doc_stream_;
ds->Disconnect(err);
ds->SignalEvent(ds, SE_CLOSE, err);
}
if (notify_) {
notify_->onHttpComplete(mode, err);
}
}
//
// Stream Signals
//
void
HttpBase::OnHttpStreamEvent(StreamInterface* stream, int events, int error) {
RTC_DCHECK(stream == http_stream_);
if ((events & SE_OPEN) && (mode_ == HM_CONNECT)) {
do_complete();
return;
}
if ((events & SE_WRITE) && (mode_ == HM_SEND)) {
flush_data();
return;
}
if ((events & SE_READ) && (mode_ == HM_RECV)) {
if (doc_stream_) {
doc_stream_->SignalEvent(doc_stream_, SE_READ, 0);
} else {
read_and_process_data();
}
return;
}
if ((events & SE_CLOSE) == 0)
return;
HttpError http_error = HandleStreamClose(error);
if (mode_ == HM_RECV) {
complete(http_error);
} else if (mode_ != HM_NONE) {
do_complete(http_error);
} else if (notify_) {
notify_->onHttpClosed(http_error);
}
}
void
HttpBase::OnDocumentEvent(StreamInterface* stream, int events, int error) {
RTC_DCHECK(stream == data_->document.get());
if ((events & SE_WRITE) && (mode_ == HM_RECV)) {
read_and_process_data();
return;
}
if ((events & SE_READ) && (mode_ == HM_SEND)) {
flush_data();
return;
}
if (events & SE_CLOSE) {
RTC_LOG_F(LS_ERROR) << "Read error: " << error;
do_complete(HE_STREAM);
return;
}
}
//
// HttpParser Implementation
//
HttpParser::ProcessResult
HttpBase::ProcessLeader(const char* line, size_t len, HttpError* error) {
*error = data_->parseLeader(line, len);
return (HE_NONE == *error) ? PR_CONTINUE : PR_COMPLETE;
}
HttpParser::ProcessResult
HttpBase::ProcessHeader(const char* name, size_t nlen, const char* value,
size_t vlen, HttpError* error) {
std::string sname(name, nlen), svalue(value, vlen);
data_->addHeader(sname, svalue);
return PR_CONTINUE;
}
HttpParser::ProcessResult
HttpBase::ProcessHeaderComplete(bool chunked, size_t& data_size,
HttpError* error) {
StreamInterface* old_docstream = doc_stream_;
if (notify_) {
*error = notify_->onHttpHeaderComplete(chunked, data_size);
// The request must not be aborted as a result of this callback.
RTC_DCHECK(nullptr != data_);
}
if ((HE_NONE == *error) && data_->document) {
data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
}
if (HE_NONE != *error) {
return PR_COMPLETE;
}
if (old_docstream != doc_stream_) {
// Break out of Process loop, since our I/O model just changed.
return PR_BLOCK;
}
return PR_CONTINUE;
}
HttpParser::ProcessResult
HttpBase::ProcessData(const char* data, size_t len, size_t& read,
HttpError* error) {
if (ignore_data_ || !data_->document) {
read = len;
return PR_CONTINUE;
}
int write_error = 0;
switch (data_->document->Write(data, len, &read, &write_error)) {
case SR_SUCCESS:
return PR_CONTINUE;
case SR_BLOCK:
return PR_BLOCK;
case SR_EOS:
RTC_LOG_F(LS_ERROR) << "Unexpected EOS";
*error = HE_STREAM;
return PR_COMPLETE;
case SR_ERROR:
default:
RTC_LOG_F(LS_ERROR) << "Write error: " << write_error;
*error = HE_STREAM;
return PR_COMPLETE;
}
}
void
HttpBase::OnComplete(HttpError err) {
RTC_LOG_F(LS_VERBOSE);
do_complete(err);
}
} // namespace rtc