[Cronet] Integrate CrNet functionality into Cronet on iOS.

components/cronet/ios/cronet_environment.cc

 // Copyright 2016 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 "components/cronet/ios/cronet_environment.h"
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_writer.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/worker_pool.h"
+#include "components/cronet/histogram_manager.h"
 #include "components/cronet/ios/version.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_filter.h"
+#include "ios/web/public/user_agent.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/ct_known_logs.h"
 #include "net/cert/ct_log_verifier.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/ct_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/mapped_host_resolver.h"
@@ skipping 17 matching lines @@
 #include "url/scheme_host_port.h"
 #include "url/url_util.h"
 
 namespace {
 
 base::AtExitManager* g_at_exit_ = nullptr;
 net::NetworkChangeNotifier* g_network_change_notifier = nullptr;
 // MessageLoop on the main thread.
 base::MessageLoop* g_main_message_loop = nullptr;
 
+// Request context getter for Cronet.
+class CronetURLRequestContextGetter : public net::URLRequestContextGetter {
+ public:
+  CronetURLRequestContextGetter(
+      cronet::CronetEnvironment* environment,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+      : environment_(environment), task_runner_(task_runner) {}
+
+  net::URLRequestContext* GetURLRequestContext() override {
+    DCHECK(environment_);
+    return environment_->GetURLRequestContext();
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
+      const override {
+    return task_runner_;
+  }
+
+ private:
+  // Must be called on the IO thread.
+  ~CronetURLRequestContextGetter() override {}
+
+  cronet::CronetEnvironment* environment_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  DISALLOW_COPY_AND_ASSIGN(CronetURLRequestContextGetter);
+};
+
 }  // namespace
 
 namespace cronet {
 
 bool CronetEnvironment::IsOnNetworkThread() {
   return network_io_thread_->task_runner()->BelongsToCurrentThread();
 }
 
 void CronetEnvironment::PostToNetworkThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   network_io_thread_->task_runner()->PostTask(from_here, task);
 }
 
 void CronetEnvironment::PostToFileUserBlockingThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   file_user_blocking_thread_->task_runner()->PostTask(from_here, task);
 }
 
 net::URLRequestContext* CronetEnvironment::GetURLRequestContext() const {
   return main_context_.get();
 }
 
+net::URLRequestContextGetter* CronetEnvironment::GetURLRequestContextGetter()
+    const {
+  return main_context_getter_.get();
+}
+
 // static
 void CronetEnvironment::Initialize() {
   // DCHECK_EQ([NSThread currentThread], [NSThread mainThread]);
   // This method must be called once from the main thread.
   if (!g_at_exit_)
     g_at_exit_ = new base::AtExitManager;
 
   url::Initialize();
   base::CommandLine::Init(0, nullptr);
 
@@ skipping 80 matching lines @@
   return context->http_transaction_factory()->GetSession();
 }
 
 void CronetEnvironment::AddQuicHint(const std::string& host,
                                     int port,
                                     int alternate_port) {
   DCHECK(port == alternate_port);
   quic_hints_.push_back(net::HostPortPair(host, port));
 }
 
-CronetEnvironment::CronetEnvironment(const std::string& user_agent_product_name)
+CronetEnvironment::CronetEnvironment(const std::string& user_agent,
+                                     bool user_agent_partial)
     : http2_enabled_(false),
       quic_enabled_(false),
-      user_agent_product_name_(user_agent_product_name),
+      user_agent_(user_agent),
+      user_agent_partial_(user_agent_partial),
       net_log_(new net::NetLog) {}
 
 void CronetEnvironment::Start() {
   // Threads setup.
   network_cache_thread_.reset(new base::Thread("Chrome Network Cache Thread"));
   network_cache_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   network_io_thread_.reset(new base::Thread("Chrome Network IO Thread"));
   network_io_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
@@ skipping 11 matching lines @@
     base::FilePath ssl_key_log_file;
     if (!PathService::Get(base::DIR_HOME, &ssl_key_log_file))
       return;
     net::SSLClientSocket::SetSSLKeyLogFile(
         ssl_key_log_file.Append(ssl_key_log_file_name_),
         file_thread_->task_runner());
   }
 
   proxy_config_service_ = net::ProxyService::CreateSystemProxyConfigService(
       network_io_thread_->task_runner(), nullptr);
-
-#if defined(USE_NSS_CERTS)
-  net::SetURLRequestContextForNSSHttpIO(main_context_.get());
-#endif
+  main_context_getter_ = new CronetURLRequestContextGetter(
+      this, network_io_thread_->task_runner());
   base::subtle::MemoryBarrier();
   PostToNetworkThread(FROM_HERE,
                       base::Bind(&CronetEnvironment::InitializeOnNetworkThread,
                                  base::Unretained(this)));
 }
 
 CronetEnvironment::~CronetEnvironment() {
 // net::HTTPProtocolHandlerDelegate::SetInstance(nullptr);
-#if defined(USE_NSS_CERTS)
-  net::SetURLRequestContextForNSSHttpIO(nullptr);
-#endif
 }
 
 void CronetEnvironment::InitializeOnNetworkThread() {
   DCHECK(network_io_thread_->task_runner()->BelongsToCurrentThread());
   base::FeatureList::InitializeInstance(std::string(), std::string());
   // TODO(mef): Use net:UrlRequestContextBuilder instead of manual build.
   main_context_.reset(new net::URLRequestContext);
   main_context_->set_net_log(net_log_.get());
-  std::string user_agent(user_agent_product_name_ +
-                         " (iOS); Cronet/" CRONET_VERSION);
+
+  if (user_agent_partial_)
+    user_agent_ = web::BuildUserAgentFromProduct(user_agent_);
+
   main_context_->set_http_user_agent_settings(
-      new net::StaticHttpUserAgentSettings("en", user_agent));
+      new net::StaticHttpUserAgentSettings(accept_language_, user_agent_));
 
   main_context_->set_ssl_config_service(new net::SSLConfigServiceDefaults);
   main_context_->set_transport_security_state(
       new net::TransportSecurityState());
   http_server_properties_.reset(new net::HttpServerPropertiesImpl());
   main_context_->set_http_server_properties(http_server_properties_.get());
 
   // TODO(rdsmith): Note that the ".release()" calls below are leaking
   // the objects in question; this should be fixed by having an object
   // corresponding to URLRequestContextStorage that actually owns those
@@ skipping 90 matching lines @@
 std::string CronetEnvironment::user_agent() {
   const net::HttpUserAgentSettings* user_agent_settings =
       main_context_->http_user_agent_settings();
   if (!user_agent_settings) {
     return nullptr;
   }
 
   return user_agent_settings->GetUserAgent();
 }
 
+std::vector<uint8_t> CronetEnvironment::GetHistogramDeltas() {
+  base::StatisticsRecorder::Initialize();
+  std::vector<uint8_t> data;
+  if (!HistogramManager::GetInstance()->GetDeltas(&data))
+    return std::vector<uint8_t>();
+  return data;
+}
+
 }  // namespace cronet