Initial upload of cronet for Android.

net/cronet/android/url_request_context_peer.cc

+// 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 "net/cronet/android/url_request_context_peer.h"
+
+#include "net/cert/cert_verifier.h"
+#include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_server_properties_impl.h"
+#include "net/proxy/proxy_config_service_fixed.h"
+#include "net/proxy/proxy_service.h"
+#include "net/ssl/ssl_config_service_defaults.h"
+#include "net/url_request/static_http_user_agent_settings.h"
+#include "net/url_request/url_request_context_storage.h"
+#include "net/url_request/url_request_job_factory_impl.h"

[mmenke, 2014/02/27 23:06:02]

net/base/net_errors.h.

[mef, 2014/03/03 19:15:13]

Done.

+
+class BasicNetworkDelegate : public net::NetworkDelegate {

[mmenke, 2014/02/27 23:06:02]

Move into anonymous namespace?

[mef, 2014/03/03 19:15:13]

Done.

+ public:
+  BasicNetworkDelegate() {}
+  virtual ~BasicNetworkDelegate() {}
+
+ private:
+  virtual int OnBeforeURLRequest(net::URLRequest* request,

[mmenke, 2014/02/27 23:06:02]

Comment that all these are the net::NetworkDelegate implementation.

[mef, 2014/03/03 19:15:13]

Done.

+                                 const net::CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE {
+    return net::OK;
+  }
+
+  virtual int OnBeforeSendHeaders(net::URLRequest* request,
+                                  const net::CompletionCallback& callback,
+                                  net::HttpRequestHeaders* headers) OVERRIDE {
+    return net::OK;
+  }
+
+  virtual void OnSendHeaders(net::URLRequest* request,
+                             const net::HttpRequestHeaders& headers) OVERRIDE {}
+
+  virtual int OnHeadersReceived(
+      net::URLRequest* request,
+      const net::CompletionCallback& callback,
+      const net::HttpResponseHeaders* original_response_headers,
+      scoped_refptr<net::HttpResponseHeaders>* _response_headers) OVERRIDE {
+    return net::OK;
+  }
+
+  virtual void OnBeforeRedirect(net::URLRequest* request,
+                                const GURL& new_location) OVERRIDE {}
+
+  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {}
+
+  virtual void OnRawBytesRead(const net::URLRequest& request,
+                              int bytes_read) OVERRIDE {}
+
+  virtual void OnCompleted(net::URLRequest* request, bool started) OVERRIDE {}
+
+  virtual void OnURLRequestDestroyed(net::URLRequest* request) OVERRIDE {}
+
+  virtual void OnPACScriptError(int line_number,
+                                const base::string16& error) OVERRIDE {}
+
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      net::URLRequest* request,
+      const net::AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      net::AuthCredentials* credentials) OVERRIDE {
+    return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }

[mmenke, 2014/02/27 23:06:02]

Hmm...All of the functions above this are the same as NetworkDelegate's, so we
may not want them.  Suggest leaving them for now, but may want to just do the
ones we care about (The tree OnCan ones).

[mef, 2014/03/03 19:15:13]

Sounds good.

+
+  virtual bool OnCanGetCookies(const net::URLRequest& request,
+                               const net::CookieList& cookie_list) OVERRIDE {
+    return false;
+  }
+
+  virtual bool OnCanSetCookie(const net::URLRequest& request,
+                              const std::string& cookie_line,
+                              net::CookieOptions* options) OVERRIDE {
+    return false;
+  }
+
+  virtual bool OnCanAccessFile(const net::URLRequest& request,
+                               const base::FilePath& path) const OVERRIDE {
+    return false;
+  }
+
+  virtual bool OnCanThrottleRequest(
+      const net::URLRequest& request) const OVERRIDE{
+    return false;
+  }
+
+  virtual int OnBeforeSocketStreamConnect(
+      net::SocketStream* stream,
+      const net::CompletionCallback& callback) OVERRIDE {
+    return net::OK;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
+};
+
+class BasicURLRequestContext : public net::URLRequestContext {

[mmenke, 2014/02/27 23:06:02]

Move into anonymous namespace?

[mef, 2014/03/03 19:15:13]

Done.

+ public:
+  BasicURLRequestContext() : storage_(this) {}
+
+  net::URLRequestContextStorage* storage() { return &storage_; }
+
+ protected:
+  virtual ~BasicURLRequestContext() {}
+
+ private:
+  net::URLRequestContextStorage storage_;

[mmenke, 2014/02/27 23:06:02]

nit:  Add blank line.

[mef, 2014/03/03 19:15:13]

Done.

+  DISALLOW_COPY_AND_ASSIGN(BasicURLRequestContext);
+};
+
+URLRequestContextPeer::URLRequestContextPeer(
+    URLRequestContextPeerDelegate* delegate, std::string user_agent,
+    int logging_level, const char* version) {
+  delegate_ = delegate;
+  user_agent_ = user_agent;
+  logging_level_ = logging_level;
+  version_ = version;
+}
+
+void URLRequestContextPeer::Initialize() {
+  network_thread_ = new base::Thread("network");
+  base::Thread::Options options;
+  options.message_loop_type = base::MessageLoop::TYPE_IO;
+  network_thread_->StartWithOptions(options);
+
+  GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&URLRequestContextPeer::InitializeURLRequestContext, this));
+}
+
+void URLRequestContextPeer::InitializeURLRequestContext() {
+  BasicURLRequestContext* context = new BasicURLRequestContext;
+  net::URLRequestContextStorage* storage = context->storage();
+
+  net::NetworkDelegate* network_delegate = new BasicNetworkDelegate;
+  storage->set_network_delegate(network_delegate);
+
+  storage->set_host_resolver(net::HostResolver::CreateDefaultResolver(NULL));
+
+  net::ProxyConfigService* proxy_config_service =
+      new net::ProxyConfigServiceFixed(net::ProxyConfig());
+  storage->set_proxy_service(net::ProxyService::CreateUsingSystemProxyResolver(
+      proxy_config_service,
+      4,  // TODO(willchan): Find a better constant somewhere.
+      context->net_log()));
+  storage->set_ssl_config_service(new net::SSLConfigServiceDefaults);
+  storage->set_http_auth_handler_factory(
+      net::HttpAuthHandlerRegistryFactory::CreateDefault(
+          context->host_resolver()));
+  storage->set_transport_security_state(new net::TransportSecurityState());
+  storage->set_http_server_properties(
+      scoped_ptr<net::HttpServerProperties>(
+          new net::HttpServerPropertiesImpl()));
+  storage->set_cert_verifier(net::CertVerifier::CreateDefault());
+
+  net::HttpNetworkSession::Params network_session_params;
+  network_session_params.host_resolver = context->host_resolver();
+  network_session_params.cert_verifier = context->cert_verifier();
+  network_session_params.transport_security_state =
+      context->transport_security_state();
+  network_session_params.proxy_service = context->proxy_service();
+  network_session_params.ssl_config_service = context->ssl_config_service();
+  network_session_params.http_auth_handler_factory =
+      context->http_auth_handler_factory();
+  network_session_params.network_delegate = network_delegate;
+  network_session_params.http_server_properties =
+      context->http_server_properties();
+  network_session_params.net_log = context->net_log();
+
+  scoped_refptr<net::HttpNetworkSession> network_session(
+      new net::HttpNetworkSession(network_session_params));
+
+  net::HttpTransactionFactory* http_transaction_factory =
+      new net::HttpNetworkLayer(network_session.get());
+  storage->set_http_transaction_factory(http_transaction_factory);
+
+  net::URLRequestJobFactoryImpl* job_factory =
+      new net::URLRequestJobFactoryImpl;
+  storage->set_job_factory(job_factory);
+
+  context_.reset(context);
+
+  if (VLOG_IS_ON(2)) {
+    context_->set_net_log(new net::NetLog);
+    netlog_observer_.reset(new NetLogObserver(logging_level_));
+    context_->net_log()->AddThreadSafeObserver(netlog_observer_.get(),
+                                               net::NetLog::LOG_ALL_BUT_BYTES);
+  }
+
+  net::HttpStreamFactory::EnableNpnSpdy31();
+
+  delegate_->OnContextInitialized(this);
+}
+
+URLRequestContextPeer::~URLRequestContextPeer() {
+}
+
+const std::string &URLRequestContextPeer::GetUserAgent(const GURL &url) const {
+  return user_agent_;
+}
+
+int URLRequestContextPeer::logging_level() const {
+  return logging_level_;
+}
+
+const char* URLRequestContextPeer::version() const {
+  return version_;
+}
+
+net::URLRequestContext *URLRequestContextPeer::GetURLRequestContext() {

[mmenke, 2014/02/27 23:06:02]

nit:  net::URLRequestContext* URLRequestContextPeer

[mef, 2014/03/03 19:15:13]

Done.

+  if (!context_) {
+    LOG(ERROR) << "URLRequestContext is not set up";
+  }
+  return context_.get();
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+URLRequestContextPeer::GetNetworkTaskRunner() const {
+  return network_thread_->message_loop_proxy();
+}
+
+void NetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
+  if (VLOG_IS_ON(2)) {
+    VLOG(2) << "Net log entry: type=" << entry.type()
+            << ", source=" << entry.source().type
+            << ", phase=" << entry.phase();
+  }
+}