[Cronet] Hook up library loader, system proxy and network change notifier to async api.

components/cronet/android/cronet_url_request_context_adapter.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 "components/cronet/android/cronet_url_request_context_adapter.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "components/cronet/url_request_context_config.h"
@@ skipping 89 matching lines @@
     return false;
   }
 
   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 };
 
 }  // namespace
 
 namespace cronet {
 
-CronetURLRequestContextAdapter::CronetURLRequestContextAdapter() {
+CronetURLRequestContextAdapter::CronetURLRequestContextAdapter()
+    : is_context_initialized_(false) {
 }
 
 CronetURLRequestContextAdapter::~CronetURLRequestContextAdapter() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   StopNetLogOnNetworkThread();
 }
 
 void CronetURLRequestContextAdapter::Initialize(
     scoped_ptr<URLRequestContextConfig> config,
     const base::Closure& java_init_network_thread) {
   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(&CronetURLRequestContextAdapter::InitializeOnNetworkThread,
                  base::Unretained(this),
                  Passed(&config),
                  java_init_network_thread));
 }
 
+void CronetURLRequestContextAdapter::InitRequestContextOnMainThread() {
+  proxy_config_service_.reset(net::ProxyService::CreateSystemProxyConfigService(

[xunjieli, 2015/01/05 14:48:03]

I wonder whether it makes a difference for each context to have its own
ProxyConfigService. Should we make it global across contexts. Any thought?

[mef, 2015/01/05 16:59:21]

CreateSystemProxyConfigService takes io_task_runner, so making global
ProxyConfigService would require global io (aka network) thread. This seems like
a reasonable idea as we don't have any embedder callbacks performed on it, so it
shouldn't block. Matt, WDYT?

[mmenke, 2015/01/05 18:20:39]

I'm not really a big fan of globals, unless they're strictly necessary, or
result in major gains.  Not convinced we need them here.

They also result in bugs (See the bug I filed against Cronet cache startup not
being thread safe...because of a global...)

+      GetNetworkTaskRunner(), NULL));

[xunjieli, 2015/01/05 14:48:03]

I think we moved the task of InitializeOnNetworkThread to the end of
InitRequestContextOnMainThread in url_request_context_adapter.cc, as we need to
wait for proxy_config_service_ to be initialized before we init everything else
on network thread. Maybe we need to do sth similar here?

[mef, 2015/01/05 16:59:21]

Definitely, thanks for spotting that. Done.

+}
+
 void CronetURLRequestContextAdapter::InitializeOnNetworkThread(
     scoped_ptr<URLRequestContextConfig> config,
     const base::Closure& java_init_network_thread) {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   // TODO(mmenke):  Add method to have the builder enable SPDY.
   net::URLRequestContextBuilder context_builder;
   context_builder.set_network_delegate(new BasicNetworkDelegate());
   context_builder.set_proxy_config_service(
       new net::ProxyConfigServiceFixed(net::ProxyConfig()));
   config->ConfigureURLRequestContextBuilder(&context_builder);
@@ skipping 38 matching lines @@
                                                  quic_hint.port);
       context_->http_server_properties()->SetAlternateProtocol(
           quic_hint_host_port_pair,
           static_cast<uint16>(quic_hint.alternate_port),
           net::AlternateProtocol::QUIC,
           1.0f);
     }
   }
 
   java_init_network_thread.Run();
+
+  is_context_initialized_ = true;
+  while (!tasks_waiting_for_context_.empty()) {
+    tasks_waiting_for_context_.front().Run();
+    tasks_waiting_for_context_.pop();
+  }
 }
 
 void CronetURLRequestContextAdapter::Destroy() {
   DCHECK(!GetNetworkTaskRunner()->BelongsToCurrentThread());
   // Stick network_thread_ in a local, as |this| may be destroyed from the
   // network thread before delete network_thread is called.
   base::Thread* network_thread = network_thread_;
   GetNetworkTaskRunner()->DeleteSoon(FROM_HERE, this);
   // Deleting thread stops it after all tasks are completed.
   delete network_thread;
 }
 
 net::URLRequestContext* CronetURLRequestContextAdapter::GetURLRequestContext() {
   if (!context_) {
     LOG(ERROR) << "URLRequestContext is not set up";
   }
   return context_.get();
 }
 
+void CronetURLRequestContextAdapter::PostTaskToNetworkThread(
+    const tracked_objects::Location& posted_from,
+    const RunAfterContextInitTask& callback) {
+  GetNetworkTaskRunner()->PostTask(
+      posted_from, base::Bind(&CronetURLRequestContextAdapter::
+                                  RunTaskAfterContextInitOnNetworkThread,
+                              base::Unretained(this), callback));
+}
+
+void CronetURLRequestContextAdapter::RunTaskAfterContextInitOnNetworkThread(
+    const RunAfterContextInitTask& callback) {
+  DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
+  if (is_context_initialized_) {
+    callback.Run();
+    return;
+  }
+  tasks_waiting_for_context_.push(callback);
+}
+
 scoped_refptr<base::SingleThreadTaskRunner>
 CronetURLRequestContextAdapter::GetNetworkTaskRunner() const {
   return network_thread_->task_runner();
 }
 
 void CronetURLRequestContextAdapter::StartNetLogToFile(
     const std::string& file_name) {
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
@@ skipping 28 matching lines @@
 
 void CronetURLRequestContextAdapter::StopNetLogOnNetworkThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   if (net_log_logger_) {
     net_log_logger_->StopObserving();
     net_log_logger_.reset();
   }
 }
 
 }  // namespace cronet