Move ProxyConfigService construction onto the IO thread.

net/proxy/proxy_config_service_android.cc

 // Copyright (c) 2012 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/proxy/proxy_config_service_android.h"
 
 #include <sys/system_properties.h>
 
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
@@ skipping 143 matching lines @@
   return result.is_null() ?
       std::string() : ConvertJavaStringToUTF8(env, result.obj());
 }
 
 }  // namespace
 
 class ProxyConfigServiceAndroid::Delegate
     : public base::RefCountedThreadSafe<Delegate> {
  public:
   Delegate(base::SequencedTaskRunner* network_task_runner,
-           base::SequencedTaskRunner* jni_task_runner,
+           base::SequencedTaskRunner* main_task_runner,
            const GetPropertyCallback& get_property_callback)
       : ALLOW_THIS_IN_INITIALIZER_LIST(jni_delegate_(this)),
         network_task_runner_(network_task_runner),
-        jni_task_runner_(jni_task_runner),
+        main_task_runner_(main_task_runner),
         get_property_callback_(get_property_callback) {
   }
 
   void SetupJNI() {
-    DCHECK(OnJNIThread());
+    DCHECK(OnNetworkThread());
     JNIEnv* env = AttachCurrentThread();
     if (java_proxy_change_listener_.is_null()) {
       java_proxy_change_listener_.Reset(
           Java_ProxyChangeListener_create(
               env, base::android::GetApplicationContext()));
       CHECK(!java_proxy_change_listener_.is_null());
     }
     Java_ProxyChangeListener_start(
         env,
         java_proxy_change_listener_.obj(),
         reinterpret_cast<jint>(&jni_delegate_));
   }
 
   void FetchInitialConfig() {
-    DCHECK(OnJNIThread());
-    ProxyConfig proxy_config;
-    GetLatestProxyConfigInternal(get_property_callback_, &proxy_config);
-    network_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&Delegate::SetNewConfigOnNetworkThread, this, proxy_config));
+    DCHECK(OnNetworkThread());
+    SetNewConfigOnNetworkThread();
   }
 
-  void Shutdown() {
-    if (OnJNIThread()) {
-      ShutdownOnJNIThread();
-    } else {
-      jni_task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(&Delegate::ShutdownOnJNIThread, this));
-    }
+  void StartTearDown() {
+    DCHECK(OnMainThread());
+    if (java_proxy_change_listener_.is_null())
+      return;
+    JNIEnv* env = AttachCurrentThread();
+    Java_ProxyChangeListener_stop(env, java_proxy_change_listener_.obj());
   }
 
   // Called only on the network thread.
   void AddObserver(Observer* observer) {
     DCHECK(OnNetworkThread());
     observers_.AddObserver(observer);
   }
 
   void RemoveObserver(Observer* observer) {
     DCHECK(OnNetworkThread());
     observers_.RemoveObserver(observer);
   }
 
   ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) {
     DCHECK(OnNetworkThread());
     if (!config)
       return ProxyConfigService::CONFIG_UNSET;
     *config = proxy_config_;
     return ProxyConfigService::CONFIG_VALID;
   }
 
-  // Called on the JNI thread.
+  // Called on the main thread.
   void ProxySettingsChanged() {
-    DCHECK(OnJNIThread());
-    ProxyConfig proxy_config;
-    GetLatestProxyConfigInternal(get_property_callback_, &proxy_config);
+    DCHECK(OnMainThread());
     network_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(
-            &Delegate::SetNewConfigOnNetworkThread, this, proxy_config));
+        base::Bind(&Delegate::SetNewConfigOnNetworkThread, this));
   }
 
  private:
   friend class base::RefCountedThreadSafe<Delegate>;
 
   class JNIDelegateImpl : public ProxyConfigServiceAndroid::JNIDelegate {
    public:
     explicit JNIDelegateImpl(Delegate* delegate) : delegate_(delegate) {}
 
     // ProxyConfigServiceAndroid::JNIDelegate overrides.
     virtual void ProxySettingsChanged(JNIEnv*, jobject) OVERRIDE {
       delegate_->ProxySettingsChanged();
     }
 
    private:
     Delegate* const delegate_;
   };
 
   virtual ~Delegate() {}
 
-  void ShutdownOnJNIThread() {
-    if (java_proxy_change_listener_.is_null())
-      return;
-    JNIEnv* env = AttachCurrentThread();
-    Java_ProxyChangeListener_stop(env, java_proxy_change_listener_.obj());
-  }
-
   // Called on the network thread.
-  void SetNewConfigOnNetworkThread(const ProxyConfig& proxy_config) {
+  void SetNewConfigOnNetworkThread() {
     DCHECK(OnNetworkThread());
-    proxy_config_ = proxy_config;
+    GetLatestProxyConfigInternal(get_property_callback_, &proxy_config_);
     FOR_EACH_OBSERVER(Observer, observers_,
-                      OnProxyConfigChanged(proxy_config,
+                      OnProxyConfigChanged(proxy_config_,
                                            ProxyConfigService::CONFIG_VALID));
   }
 
-  bool OnJNIThread() const {
-    return jni_task_runner_->RunsTasksOnCurrentThread();
+  bool OnMainThread() const {
+    return main_task_runner_->RunsTasksOnCurrentThread();
   }
 
   bool OnNetworkThread() const {
     return network_task_runner_->RunsTasksOnCurrentThread();
   }
 
   ScopedJavaGlobalRef<jobject> java_proxy_change_listener_;
 
   JNIDelegateImpl jni_delegate_;
   ObserverList<Observer> observers_;
   scoped_refptr<base::SequencedTaskRunner> network_task_runner_;
-  scoped_refptr<base::SequencedTaskRunner> jni_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> main_task_runner_;
   GetPropertyCallback get_property_callback_;
   ProxyConfig proxy_config_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 ProxyConfigServiceAndroid::ProxyConfigServiceAndroid(
-    base::SequencedTaskRunner* network_task_runner,
-    base::SequencedTaskRunner* jni_task_runner)
+    base::SequencedTaskRunner* main_task_runner,
+    base::SequencedTaskRunner* network_task_runner)
     : delegate_(new Delegate(
-        network_task_runner, jni_task_runner, base::Bind(&GetJavaProperty))) {
+        network_task_runner, main_task_runner, base::Bind(&GetJavaProperty))) {
   delegate_->SetupJNI();
   delegate_->FetchInitialConfig();
 }
 
-ProxyConfigServiceAndroid::~ProxyConfigServiceAndroid() {
-  delegate_->Shutdown();
+ProxyConfigServiceAndroid::~ProxyConfigServiceAndroid() {}
+
+void ProxyConfigServiceAndroid::StartTearDown() {
+  delegate_->StartTearDown();
 }
 
 // static
 bool ProxyConfigServiceAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void ProxyConfigServiceAndroid::AddObserver(Observer* observer) {
   delegate_->AddObserver(observer);
 }
 
 void ProxyConfigServiceAndroid::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
 ProxyConfigServiceAndroid::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 ProxyConfigServiceAndroid::ProxyConfigServiceAndroid(
     base::SequencedTaskRunner* network_task_runner,
-    base::SequencedTaskRunner* jni_task_runner,
+    base::SequencedTaskRunner* main_task_runner,
     GetPropertyCallback get_property_callback)
     : delegate_(new Delegate(
-        network_task_runner, jni_task_runner, get_property_callback)) {
+        network_task_runner, main_task_runner, get_property_callback)) {
   delegate_->FetchInitialConfig();
 }
 
 void ProxyConfigServiceAndroid::ProxySettingsChanged() {
   delegate_->ProxySettingsChanged();
 }
 
 } // namespace net