| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "url_request_adapter.h" |
| |
| #include <string.h> |
| |
| #include "base/bind.h" |
| #include "base/location.h" |
| #include "base/logging.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "components/cronet/android/url_request_context_adapter.h" |
| #include "components/cronet/android/wrapped_channel_upload_element_reader.h" |
| #include "net/base/elements_upload_data_stream.h" |
| #include "net/base/load_flags.h" |
| #include "net/base/net_errors.h" |
| #include "net/base/upload_bytes_element_reader.h" |
| #include "net/http/http_response_headers.h" |
| #include "net/http/http_status_code.h" |
| |
| namespace cronet { |
| |
| static const size_t kBufferSizeIncrement = 8192; |
| |
| URLRequestAdapter::URLRequestAdapter(URLRequestContextAdapter* context, |
| URLRequestAdapterDelegate* delegate, |
| GURL url, |
| net::RequestPriority priority) |
| : method_("GET"), |
| read_buffer_(new net::GrowableIOBuffer()), |
| bytes_read_(0), |
| total_bytes_read_(0), |
| error_code_(0), |
| http_status_code_(0), |
| canceled_(false), |
| expected_size_(0), |
| chunked_upload_(false), |
| disable_redirect_(false) { |
| context_ = context; |
| delegate_ = delegate; |
| url_ = url; |
| priority_ = priority; |
| } |
| |
| URLRequestAdapter::~URLRequestAdapter() { |
| DCHECK(OnNetworkThread()); |
| CHECK(url_request_ == NULL); |
| } |
| |
| void URLRequestAdapter::SetMethod(const std::string& method) { |
| method_ = method; |
| } |
| |
| void URLRequestAdapter::AddHeader(const std::string& name, |
| const std::string& value) { |
| headers_.SetHeader(name, value); |
| } |
| |
| void URLRequestAdapter::SetUploadContent(const char* bytes, int bytes_len) { |
| std::vector<char> data(bytes, bytes + bytes_len); |
| scoped_ptr<net::UploadElementReader> reader( |
| new net::UploadOwnedBytesElementReader(&data)); |
| upload_data_stream_ = |
| net::ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0); |
| } |
| |
| void URLRequestAdapter::SetUploadChannel(JNIEnv* env, int64 content_length) { |
| scoped_ptr<net::UploadElementReader> reader( |
| new WrappedChannelElementReader(delegate_, content_length)); |
| upload_data_stream_ = |
| net::ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0); |
| } |
| |
| void URLRequestAdapter::DisableRedirects() { |
| disable_redirect_ = true; |
| } |
| |
| void URLRequestAdapter::EnableChunkedUpload() { |
| chunked_upload_ = true; |
| } |
| |
| void URLRequestAdapter::AppendChunk(const char* bytes, int bytes_len, |
| bool is_last_chunk) { |
| VLOG(1) << "AppendChunk, len: " << bytes_len << ", last: " << is_last_chunk; |
| scoped_ptr<char[]> buf(new char[bytes_len]); |
| memcpy(buf.get(), bytes, bytes_len); |
| context_->PostTaskToNetworkThread( |
| FROM_HERE, |
| base::Bind(&URLRequestAdapter::OnAppendChunk, |
| base::Unretained(this), |
| Passed(buf.Pass()), |
| bytes_len, |
| is_last_chunk)); |
| } |
| |
| std::string URLRequestAdapter::GetHeader(const std::string& name) const { |
| std::string value; |
| if (url_request_ != NULL) { |
| url_request_->GetResponseHeaderByName(name, &value); |
| } |
| return value; |
| } |
| |
| net::HttpResponseHeaders* URLRequestAdapter::GetResponseHeaders() const { |
| if (url_request_ == NULL) { |
| return NULL; |
| } |
| return url_request_->response_headers(); |
| } |
| |
| std::string URLRequestAdapter::GetNegotiatedProtocol() const { |
| if (url_request_ == NULL) |
| return std::string(); |
| return url_request_->response_info().npn_negotiated_protocol; |
| } |
| |
| void URLRequestAdapter::Start() { |
| context_->PostTaskToNetworkThread( |
| FROM_HERE, |
| base::Bind(&URLRequestAdapter::OnInitiateConnection, |
| base::Unretained(this))); |
| } |
| |
| void URLRequestAdapter::OnAppendChunk(const scoped_ptr<char[]> bytes, |
| int bytes_len, bool is_last_chunk) { |
| DCHECK(OnNetworkThread()); |
| url_request_->AppendChunkToUpload(bytes.get(), bytes_len, is_last_chunk); |
| } |
| |
| void URLRequestAdapter::OnInitiateConnection() { |
| DCHECK(OnNetworkThread()); |
| if (canceled_) { |
| return; |
| } |
| |
| VLOG(1) << "Starting chromium request: " |
| << url_.possibly_invalid_spec().c_str() |
| << " priority: " << RequestPriorityToString(priority_); |
| url_request_ = context_->GetURLRequestContext()->CreateRequest( |
| url_, net::DEFAULT_PRIORITY, this, NULL); |
| url_request_->SetLoadFlags(net::LOAD_DISABLE_CACHE | |
| net::LOAD_DO_NOT_SAVE_COOKIES | |
| net::LOAD_DO_NOT_SEND_COOKIES); |
| url_request_->set_method(method_); |
| url_request_->SetExtraRequestHeaders(headers_); |
| if (!headers_.HasHeader(net::HttpRequestHeaders::kUserAgent)) { |
| std::string user_agent; |
| user_agent = context_->GetUserAgent(url_); |
| url_request_->SetExtraRequestHeaderByName( |
| net::HttpRequestHeaders::kUserAgent, user_agent, true /* override */); |
| } |
| |
| if (upload_data_stream_) { |
| url_request_->set_upload(upload_data_stream_.Pass()); |
| } else if (chunked_upload_) { |
| url_request_->EnableChunkedUpload(); |
| } |
| |
| url_request_->SetPriority(priority_); |
| |
| url_request_->Start(); |
| } |
| |
| void URLRequestAdapter::Cancel() { |
| if (canceled_) { |
| return; |
| } |
| |
| canceled_ = true; |
| |
| context_->PostTaskToNetworkThread( |
| FROM_HERE, |
| base::Bind(&URLRequestAdapter::OnCancelRequest, base::Unretained(this))); |
| } |
| |
| void URLRequestAdapter::OnCancelRequest() { |
| DCHECK(OnNetworkThread()); |
| VLOG(1) << "Canceling chromium request: " << url_.possibly_invalid_spec(); |
| |
| if (url_request_ != NULL) { |
| url_request_->Cancel(); |
| } |
| |
| OnRequestCanceled(); |
| } |
| |
| void URLRequestAdapter::Destroy() { |
| context_->PostTaskToNetworkThread( |
| FROM_HERE, base::Bind(&URLRequestAdapter::OnDestroyRequest, this)); |
| } |
| |
| // static |
| void URLRequestAdapter::OnDestroyRequest(URLRequestAdapter* self) { |
| DCHECK(self->OnNetworkThread()); |
| VLOG(1) << "Destroying chromium request: " |
| << self->url_.possibly_invalid_spec(); |
| delete self; |
| } |
| |
| // static |
| void URLRequestAdapter::OnResponseStarted(net::URLRequest* request) { |
| DCHECK(OnNetworkThread()); |
| if (request->status().status() != net::URLRequestStatus::SUCCESS) { |
| OnRequestFailed(); |
| return; |
| } |
| |
| http_status_code_ = request->GetResponseCode(); |
| VLOG(1) << "Response started with status: " << http_status_code_; |
| |
| net::HttpResponseHeaders* headers = request->response_headers(); |
| if (headers) |
| http_status_text_ = headers->GetStatusText(); |
| |
| request->GetResponseHeaderByName("Content-Type", &content_type_); |
| expected_size_ = request->GetExpectedContentSize(); |
| delegate_->OnResponseStarted(this); |
| |
| Read(); |
| } |
| |
| // Reads all available data or starts an asynchronous read. |
| void URLRequestAdapter::Read() { |
| DCHECK(OnNetworkThread()); |
| while (true) { |
| if (read_buffer_->RemainingCapacity() == 0) { |
| int new_capacity = read_buffer_->capacity() + kBufferSizeIncrement; |
| read_buffer_->SetCapacity(new_capacity); |
| } |
| |
| int bytes_read; |
| if (url_request_->Read(read_buffer_.get(), |
| read_buffer_->RemainingCapacity(), |
| &bytes_read)) { |
| if (bytes_read == 0) { |
| OnRequestSucceeded(); |
| break; |
| } |
| |
| VLOG(1) << "Synchronously read: " << bytes_read << " bytes"; |
| OnBytesRead(bytes_read); |
| } else if (url_request_->status().status() == |
| net::URLRequestStatus::IO_PENDING) { |
| if (bytes_read_ != 0) { |
| VLOG(1) << "Flushing buffer: " << bytes_read_ << " bytes"; |
| |
| delegate_->OnBytesRead(this); |
| read_buffer_->set_offset(0); |
| bytes_read_ = 0; |
| } |
| VLOG(1) << "Started async read"; |
| break; |
| } else { |
| OnRequestFailed(); |
| break; |
| } |
| } |
| } |
| |
| void URLRequestAdapter::OnReadCompleted(net::URLRequest* request, |
| int bytes_read) { |
| DCHECK(OnNetworkThread()); |
| VLOG(1) << "Asynchronously read: " << bytes_read << " bytes"; |
| if (bytes_read < 0) { |
| OnRequestFailed(); |
| return; |
| } else if (bytes_read == 0) { |
| OnRequestSucceeded(); |
| return; |
| } |
| |
| OnBytesRead(bytes_read); |
| Read(); |
| } |
| |
| void URLRequestAdapter::OnReceivedRedirect(net::URLRequest* request, |
| const net::RedirectInfo& info, |
| bool* defer_redirect) { |
| DCHECK(OnNetworkThread()); |
| if (disable_redirect_) { |
| http_status_code_ = request->GetResponseCode(); |
| request->CancelWithError(net::ERR_TOO_MANY_REDIRECTS); |
| error_code_ = net::ERR_TOO_MANY_REDIRECTS; |
| canceled_ = true; |
| *defer_redirect = false; |
| OnRequestCompleted(); |
| } |
| } |
| |
| void URLRequestAdapter::OnBytesRead(int bytes_read) { |
| DCHECK(OnNetworkThread()); |
| read_buffer_->set_offset(read_buffer_->offset() + bytes_read); |
| bytes_read_ += bytes_read; |
| total_bytes_read_ += bytes_read; |
| } |
| |
| void URLRequestAdapter::OnRequestSucceeded() { |
| DCHECK(OnNetworkThread()); |
| if (canceled_) { |
| return; |
| } |
| |
| VLOG(1) << "Request completed with HTTP status: " << http_status_code_ |
| << ". Total bytes read: " << total_bytes_read_; |
| |
| OnRequestCompleted(); |
| } |
| |
| void URLRequestAdapter::OnRequestFailed() { |
| DCHECK(OnNetworkThread()); |
| if (canceled_) { |
| return; |
| } |
| |
| error_code_ = url_request_->status().error(); |
| VLOG(1) << "Request failed with status: " << url_request_->status().status() |
| << " and error: " << net::ErrorToString(error_code_); |
| OnRequestCompleted(); |
| } |
| |
| void URLRequestAdapter::OnRequestCanceled() { |
| DCHECK(OnNetworkThread()); |
| OnRequestCompleted(); |
| } |
| |
| void URLRequestAdapter::OnRequestCompleted() { |
| DCHECK(OnNetworkThread()); |
| VLOG(1) << "Completed: " << url_.possibly_invalid_spec(); |
| |
| delegate_->OnBytesRead(this); |
| delegate_->OnRequestFinished(this); |
| url_request_.reset(); |
| } |
| |
| unsigned char* URLRequestAdapter::Data() const { |
| DCHECK(OnNetworkThread()); |
| return reinterpret_cast<unsigned char*>(read_buffer_->StartOfBuffer()); |
| } |
| |
| bool URLRequestAdapter::OnNetworkThread() const { |
| return context_->GetNetworkTaskRunner()->BelongsToCurrentThread(); |
| } |
| |
| } // namespace cronet |