android: Use new proxy from PROXY_CHANGE intent

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"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "jni/ProxyChangeListener_jni.h"
 #include "net/base/host_port_pair.h"
 #include "net/proxy/proxy_config.h"
 #include "url/url_parse.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::CheckException;
 using base::android::ClearException;
@@ skipping 121 matching lines @@
   // Use Java System.getProperty to get configuration information.
   // TODO(pliard): Conversion to/from UTF8 ok here?
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(env, property);
   ScopedJavaLocalRef<jstring> result =
       Java_ProxyChangeListener_getProperty(env, str.obj());
   return result.is_null() ?
       std::string() : ConvertJavaStringToUTF8(env, result.obj());
 }
 
+void CreateStaticProxyConfig(const std::string& host, int port,
+                             ProxyConfig* config) {
+  if (port != 0) {
+    std::string rules = base::StringPrintf("%s:%d", host.c_str(), port);
+    config->proxy_rules().ParseFromString(rules);
+  } else {
+    *config = ProxyConfig::CreateDirect();
+  }
+}
+
 }  // namespace
 
 class ProxyConfigServiceAndroid::Delegate
     : public base::RefCountedThreadSafe<Delegate> {
  public:
   Delegate(base::SequencedTaskRunner* network_task_runner,
            base::SequencedTaskRunner* jni_task_runner,
            const GetPropertyCallback& get_property_callback)
       : jni_delegate_(this),
         network_task_runner_(network_task_runner),
@@ skipping 58 matching lines @@
   void ProxySettingsChanged() {
     DCHECK(OnJNIThread());
     ProxyConfig proxy_config;
     GetLatestProxyConfigInternal(get_property_callback_, &proxy_config);
     network_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &Delegate::SetNewConfigOnNetworkThread, this, proxy_config));
   }
 
+  // Called on the JNI thread.
+  void ProxySettingsChangedTo(const std::string& host, int port) {
+    DCHECK(OnJNIThread());
+    ProxyConfig proxy_config;
+    CreateStaticProxyConfig(host, port, &proxy_config);
+    network_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &Delegate::SetNewConfigOnNetworkThread, this, proxy_config));
+  }
+
  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 {
+    virtual void ProxySettingsChangedTo(JNIEnv* env, jobject jself,
+                                      jstring jhost, jint jport) OVERRIDE {
+      std::string host = ConvertJavaStringToUTF8(env, jhost);
+      delegate_->ProxySettingsChangedTo(host, jport);
+    }
+
+    virtual void ProxySettingsChanged(JNIEnv* env, jobject self) OVERRIDE {
       delegate_->ProxySettingsChanged();
     }
 
    private:
     Delegate* const delegate_;
   };
 
   virtual ~Delegate() {}
 
   void ShutdownOnJNIThread() {
@@ skipping 71 matching lines @@
         network_task_runner, jni_task_runner, get_property_callback)) {
   delegate_->SetupJNI();
   delegate_->FetchInitialConfig();
 }
 
 void ProxyConfigServiceAndroid::ProxySettingsChanged() {
   delegate_->ProxySettingsChanged();
 }
 
 } // namespace net