Initial implementation of Cronet Async API.

components/cronet/android/cronet_url_request_adapter.cc

Index: components/cronet/android/cronet_url_request_adapter.cc
diff --git a/components/cronet/android/cronet_url_request_adapter.cc b/components/cronet/android/cronet_url_request_adapter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9d791e5bd42a4ece850c830ac2397f50729e8cf8
--- /dev/null
+++ b/components/cronet/android/cronet_url_request_adapter.cc
@@ -0,0 +1,230 @@
+// 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 "cronet_url_request_adapter.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "components/cronet/android/cronet_url_request_context_adapter.h"
+#include "components/cronet/android/wrapped_channel_upload_element_reader.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_flags.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/redirect_info.h"
+#include "net/url_request/url_request_context.h"
+
+namespace cronet {
+
+static const size_t kBufferSizeIncrement = 32768;
+
+CronetURLRequestAdapter::CronetURLRequestAdapter(
+    CronetURLRequestContextAdapter* context,
+    CronetURLRequestAdapterDelegate* delegate,
+    GURL url,
+    net::RequestPriority priority)
+    : method_("GET"),
+      read_buffer_(new net::IOBufferWithSize(kBufferSizeIncrement)),
+      bytes_read_(0),
+      total_bytes_read_(0),
+      error_code_(0),
+      http_status_code_(0),
+      canceled_(false),
+      expected_size_(0),
+      chunked_upload_(false) {
+  context_ = context;
+  delegate_ = delegate;
+  url_ = url;
+  priority_ = priority;
+}
+
+CronetURLRequestAdapter::~CronetURLRequestAdapter() {
+  CHECK(url_request_ == NULL);

[mmenke, 2014/10/06 18:28:44]

CHECK_NE(nullptr, url_request_);?  Though since we delete the adapter jsut
before the request, can we just delete the request here, too?  See other
comment.

[mef, 2014/10/07 00:45:17]

Done.

+}
+
+void CronetURLRequestAdapter::SetMethod(const std::string& method) {
+  method_ = method;
+}
+
+void CronetURLRequestAdapter::AddHeader(const std::string& name,
+                                        const std::string& value) {
+  headers_.SetHeader(name, value);
+}
+
+std::string CronetURLRequestAdapter::GetHeader(const std::string& name) const {
+  std::string value;
+  if (url_request_ != NULL)
+    url_request_->GetResponseHeaderByName(name, &value);
+  return value;
+}
+
+net::HttpResponseHeaders* CronetURLRequestAdapter::GetResponseHeaders() const {
+  if (url_request_ == NULL)
+    return NULL;
+  return url_request_->response_headers();
+}
+
+std::string CronetURLRequestAdapter::GetNegotiatedProtocol() const {
+  if (url_request_ == NULL)
+    return std::string();
+  return url_request_->response_info().npn_negotiated_protocol;
+}
+
+bool CronetURLRequestAdapter::GetWasCached() const {
+  if (url_request_ == NULL)
+    return false;
+  return url_request_->response_info().was_cached;
+}
+
+int64 CronetURLRequestAdapter::GetTotalReceivedBytes() const {
+  if (url_request_ == NULL)
+    return 0;
+  return url_request_->GetTotalReceivedBytes();
+}
+
+void CronetURLRequestAdapter::Start() {
+  context_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CronetURLRequestAdapter::StartOnNetworkThread,
+                 base::Unretained(this)));
+}
+
+void CronetURLRequestAdapter::FollowDeferredRedirect() {
+  context_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &CronetURLRequestAdapter::FollowDeferredRedirectOnNetworkThread,
+          base::Unretained(this)));
+}
+
+// Receive more data.
+void CronetURLRequestAdapter::ReadData() {
+  context_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CronetURLRequestAdapter::ReadDataOnNetworkThread,
+                 base::Unretained(this)));
+}
+
+void CronetURLRequestAdapter::Cancel() {
+  if (canceled_)
+    return;
+
+  canceled_ = true;

[mmenke, 2014/10/06 18:28:44]

Suggest setting this on the network thread instead, and then not calling into
the delegate at all if it's true.  Would have to check it on the network thread,
too, in that case.

[mef, 2014/10/07 00:45:17]

Done.

+
+  context_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CronetURLRequestAdapter::CancelOnNetworkThread,
+                 base::Unretained(this)));
+}
+
+void CronetURLRequestAdapter::Destroy() {
+  context_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&CronetURLRequestAdapter::DestroyOnNetworkThread, this));

[mmenke, 2014/10/06 18:28:44]

Can we just use DeleteSoon and get rid of DestroyOnNetworkThread?  Doesn't
exactly save us much, but since we have a method to do it already....

[mef, 2014/10/07 00:45:17]

Done.

+}
+
+// net::URLRequest::Delegate overrides (called on network thread).
+void CronetURLRequestAdapter::OnReceivedRedirect(
+    net::URLRequest* request,
+    const net::RedirectInfo& redirect_info,
+    bool* defer_redirect) {
+  if (!CheckStatus(request))

[mmenke, 2014/10/06 18:28:44]

Not needed.  Can actually just have a DCHECK(request->status().is_success());
here

[mef, 2014/10/07 00:45:17]

Done.

+    return;
+  delegate_->OnRedirect(this, redirect_info.new_url);
+  *defer_redirect = true;
+}
+
+void CronetURLRequestAdapter::OnResponseStarted(net::URLRequest* request) {
+  if (!CheckStatus(request))
+    return;
+  http_status_code_ = request->GetResponseCode();
+  delegate_->OnResponseStarted(this);
+}
+
+void CronetURLRequestAdapter::OnReadCompleted(net::URLRequest* request,
+                                              int bytes_read) {
+  if (!CheckStatus(request))
+    return;
+  if (bytes_read != 0) {
+    delegate_->OnBytesRead(this, bytes_read);
+  } else {
+    delegate_->OnRequestFinished(this, false);
+  }
+}
+
+void CronetURLRequestAdapter::StartOnNetworkThread() {

[mmenke, 2014/10/06 18:28:44]

Could we add DCHECKs to all of these that should be called on the network
thread?

And maybe DCHECKs on the ones call solely by the embedder that they're *not*
called on the network thread?  (Since the embedder can't call into us there -
those ones are more about documentation, and making it clear they're not called
on the network thread, than enforcing that they aren't).

[mef, 2014/10/07 00:45:17]

Done.

+  if (canceled_)

[mmenke, 2014/10/06 18:28:44]

Checking this on the network thread isn't threadsafe, unless it's set there as
well.

[mef, 2014/10/07 00:45:17]

Done.

+    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 */);
+  }
+
+  url_request_->SetPriority(priority_);
+  url_request_->Start();
+}
+
+void CronetURLRequestAdapter::FollowDeferredRedirectOnNetworkThread() {
+  url_request_->FollowDeferredRedirect();
+}
+
+// Reads all available data or starts an asynchronous read.
+void CronetURLRequestAdapter::ReadDataOnNetworkThread() {
+  int bytes_read = 0;
+  // If read completes synchronously, pass data to delegate.
+  if (url_request_->Read(read_buffer_, read_buffer_->size(), &bytes_read)) {
+    OnReadCompleted(url_request_.get(), bytes_read);
+  } else if (url_request_->status().status() !=
+             net::URLRequestStatus::IO_PENDING) {
+    OnReadCompleted(url_request_.get(), -1);
+  }
+}
+
+void CronetURLRequestAdapter::CancelOnNetworkThread() {
+  VLOG(1) << "Cancelling chromium request: " << url_.possibly_invalid_spec();
+
+  if (url_request_ != NULL)
+    url_request_->Cancel();
+
+  delegate_->OnRequestFinished(this, true);
+}
+
+bool CronetURLRequestAdapter::CheckStatus(net::URLRequest* request) {
+  DCHECK_NE(net::URLRequestStatus::IO_PENDING, url_request_->status().status());
+  DCHECK_EQ(request, url_request_);
+  if (url_request_->status().is_success())
+    return true;
+  VLOG(1) << "Error " << url_request_->status().error()
+          << " on chromium request: " << url_.possibly_invalid_spec();
+  delegate_->OnError(this, url_request_->status().error());
+  return false;
+}
+
+// static
+void CronetURLRequestAdapter::DestroyOnNetworkThread(
+    CronetURLRequestAdapter* self) {
+  self->url_request_.reset();

[mmenke, 2014/10/06 18:28:44]

Can we just do this in the destructor?

[mef, 2014/10/07 00:45:17]

Done.

+  VLOG(1) << "Destroying chromium request: "
+          << self->url_.possibly_invalid_spec();
+  delete self;
+}
+
+unsigned char* CronetURLRequestAdapter::Data() const {
+  return reinterpret_cast<unsigned char*>(read_buffer_->data());
+}
+
+}  // namespace cronet