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/cronet/android/android_log.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"
+
+#define LOG_TAG "ChromiumNetwork"
+
+class BasicNetworkDelegate : public net::NetworkDelegate {
+ public:
+  BasicNetworkDelegate() {}
+  virtual ~BasicNetworkDelegate() {}
+
+ private:
+  virtual int OnBeforeURLRequest(net::URLRequest* request,
+                                 const net::CompletionCallback& callback,
+                                 GURL* new_url) {
+    return net::OK;
+  }
+
+  virtual int OnBeforeSendHeaders(net::URLRequest* request,
+                                  const net::CompletionCallback& callback,
+                                  net::HttpRequestHeaders* headers) {
+    return net::OK;
+  }
+
+  virtual void OnSendHeaders(net::URLRequest* request,
+                             const net::HttpRequestHeaders& headers) {}
+
+  virtual int OnHeadersReceived(
+      net::URLRequest* request, const net::CompletionCallback& callback,
+      const net::HttpResponseHeaders* original_response_headers,
+      scoped_refptr<net::HttpResponseHeaders>* _response_headers) {
+    return net::OK;
+  }
+
+  virtual void OnBeforeRedirect(net::URLRequest* request,
+                                const GURL& new_location) {}
+
+  virtual void OnResponseStarted(net::URLRequest* request) {}
+
+  virtual void OnRawBytesRead(const net::URLRequest& request, int bytes_read) {}
+
+  virtual void OnCompleted(net::URLRequest* request, bool started) {}
+
+  virtual void OnURLRequestDestroyed(net::URLRequest* request) {}
+
+  virtual void OnPACScriptError(int line_number, const base::string16& error) {}
+
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      net::URLRequest* request, const net::AuthChallengeInfo& auth_info,
+      const AuthCallback& callback, net::AuthCredentials* credentials) {
+    return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+  }
+
+  virtual bool OnCanGetCookies(const net::URLRequest& request,
+                               const net::CookieList& cookie_list) {
+    return false;
+  }
+
+  virtual bool OnCanSetCookie(const net::URLRequest& request,
+                              const std::string& cookie_line,
+                              net::CookieOptions* options) {
+    return false;
+  }
+
+  virtual bool OnCanAccessFile(const net::URLRequest& request,
+                               const base::FilePath& path) const {
+    return false;
+  }
+
+  virtual bool OnCanThrottleRequest(const net::URLRequest& request) const {
+    return false;
+  }
+
+  virtual int OnBeforeSocketStreamConnect(
+      net::SocketStream* stream, const net::CompletionCallback& callback) {
+    return net::OK;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
+};
+
+class BasicURLRequestContext : public net::URLRequestContext {
+ public:
+  BasicURLRequestContext() : storage_(this) {}
+
+  net::URLRequestContextStorage* storage() { return &storage_; }
+
+ protected:
+  virtual ~BasicURLRequestContext() {}
+
+ private:
+  net::URLRequestContextStorage storage_;
+  DISALLOW_COPY_AND_ASSIGN(BasicURLRequestContext);
+};
+
+URLRequestContextPeer::URLRequestContextPeer(
+    URLRequestContextPeerDelegate* delegate, std::string user_agent,
+    LoggingLevel 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 (logging_level_ == LOG_VERBOSE) {
+    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_;
+}
+
+LoggingLevel URLRequestContextPeer::logging_level() const {
+  return logging_level_;
+}
+
+const char* URLRequestContextPeer::version() const {
+  return version_;
+}
+
+net::URLRequestContext *URLRequestContextPeer::GetURLRequestContext() {
+  if (!context_) {
+    LOGE(LOG_TAG, "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 (log_level_ == LOG_VERBOSE) {
+    const char* const source_type =
+        net::NetLog::SourceTypeToString(entry.source().type);
+    const char* const event_type =
+        net::NetLog::EventTypeToString(entry.type());
+    const char* const event_phase =
+        net::NetLog::EventPhaseToString(entry.phase());
+    __android_log_print(ANDROID_LOG_INFO, LOG_TAG,
+                        "Net log entry: type=%s source=%s phase=%s\n",
+                        event_type, source_type, event_phase);
+    // TODO(dplotnikov): print detailed parameters
+  }
+}
+
+// TODO(dplotnikov): figure out discrepancies between the NDK version bundled
+// with chromium and the standard version. The chromium version references these
+// unknown methods.
+namespace __cxxabiv1 {
+extern "C" {
+void __cxa_bad_typeid() {}
+}
+}  // namespace __cxxabiv1