Enable using system proxy resolver for android webview.

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_array.h"
 #include "base/android/jni_string.h"
@@ skipping 179 matching lines @@
 
 class ProxyConfigServiceAndroid::Delegate
     : public base::RefCountedThreadSafe<Delegate> {
  public:
   Delegate(const scoped_refptr<base::SequencedTaskRunner>& network_task_runner,
            const scoped_refptr<base::SequencedTaskRunner>& jni_task_runner,
            const GetPropertyCallback& get_property_callback)
       : jni_delegate_(this),
         network_task_runner_(network_task_runner),
         jni_task_runner_(jni_task_runner),
-        get_property_callback_(get_property_callback) {
+        get_property_callback_(get_property_callback),
+        use_local_proxy_(false) {
   }
 
   void SetupJNI() {
     DCHECK(OnJNIThread());
     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());
@@ skipping 53 matching lines @@
             &Delegate::SetNewConfigOnNetworkThread, this, proxy_config));
   }
 
   // Called on the JNI thread.
   void ProxySettingsChangedTo(const std::string& host,
                               int port,
                               const std::string& pac_url,
                               const std::vector<std::string>& exclusion_list) {
     DCHECK(OnJNIThread());
     ProxyConfig proxy_config;
-    CreateStaticProxyConfig(host, port, pac_url, exclusion_list, &proxy_config);
+    if (use_local_proxy_)

[mnaganov (inactive), 2014/11/20 21:58:35]

nit: I think this "if" statement deserves braces for the branches, as one of
them even spans on two lines.

[sgurun-gerrit only, 2014/11/20 23:38:19]

Done.

+      CreateStaticProxyConfig(host, port, "", exclusion_list, &proxy_config);
+    else
+      CreateStaticProxyConfig(host, port, pac_url, exclusion_list,
+          &proxy_config);
     network_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &Delegate::SetNewConfigOnNetworkThread, this, proxy_config));
   }
 
+  void set_use_local_proxy(bool enabled) {
+    use_local_proxy_ = enabled;
+  }
+
  private:
   friend class base::RefCountedThreadSafe<Delegate>;
 
   class JNIDelegateImpl : public ProxyConfigServiceAndroid::JNIDelegate {
    public:
     explicit JNIDelegateImpl(Delegate* delegate) : delegate_(delegate) {}
 
     // ProxyConfigServiceAndroid::JNIDelegate overrides.
     virtual void ProxySettingsChangedTo(JNIEnv* env,
                                         jobject jself,
@@ skipping 46 matching lines @@
   }
 
   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_;
   GetPropertyCallback get_property_callback_;
   ProxyConfig proxy_config_;
+  bool use_local_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 ProxyConfigServiceAndroid::ProxyConfigServiceAndroid(
     const scoped_refptr<base::SequencedTaskRunner>& network_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& jni_task_runner)
     : delegate_(new Delegate(
         network_task_runner, jni_task_runner, base::Bind(&GetJavaProperty))) {
   delegate_->SetupJNI();
   delegate_->FetchInitialConfig();
 }
 
 ProxyConfigServiceAndroid::~ProxyConfigServiceAndroid() {
   delegate_->Shutdown();
 }
 
 // static
 bool ProxyConfigServiceAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
+void ProxyConfigServiceAndroid::set_use_local_proxy(bool enabled) {
+  delegate_->set_use_local_proxy(enabled);
+}
+
 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(
     const scoped_refptr<base::SequencedTaskRunner>& network_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& jni_task_runner,
     GetPropertyCallback get_property_callback)
     : delegate_(new Delegate(
         network_task_runner, jni_task_runner, get_property_callback)) {
   delegate_->SetupJNI();
   delegate_->FetchInitialConfig();
 }
 
 void ProxyConfigServiceAndroid::ProxySettingsChanged() {
   delegate_->ProxySettingsChanged();
 }
 
 } // namespace net