Use Android proxy's exclusion list to enable proxy bypass

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 141 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,
+void CreateStaticProxyConfig(const std::string& host,
+                             int port,
+                             const std::string& exclusion_list,
                              ProxyConfig* config) {
   if (port != 0) {
     std::string rules = base::StringPrintf("%s:%d", host.c_str(), port);
     config->proxy_rules().ParseFromString(rules);
+    config->proxy_rules().bypass_rules.Clear();
+    if (!exclusion_list.empty()) {

[eroman, 2014/07/25 21:11:15]

This block is essentially equivalent to:

config->proxy_rules().bypass_rules.ParseFromString(exclusion_list);

With the caveat that ParseFromString also accepts semicolons as a separator.

Can you point me to any documentation on the android format for rules?
BypassProxyRules is most similar to the Windows proxy rules foramt, and will
interpret things in a very particular way. For instance "<local>" has special
meaning, CIDR style masks can be added, and there is a difference in meaning for
"foo.com" vs ".foo.com"

[sgurun-gerrit only, 2014/07/26 00:57:09]

Thanks. Actually this made me realize that there are some other issues to be
aware of.

Android is dropping the hidden API proxyproperties (which chrome was using
reflection to access) and providing a new Public API (that was publicisized in
l-preview sdk). Do you want me to open a bug about that?

The new API (tentative) is returning a list of hosts
public String[] getExclusionList()

My understanding is the hosts can contain "*" in bypass rules.

However this CL is relevant for support for devices using current sdk and below,
so it is still meaningful. I need to do more investigation to answer your
question about current rules 




On 2014/07/25 21:11:15, eroman wrote:

+      base::StringTokenizer tokenizer(exclusion_list, ",");
+      while (tokenizer.GetNext()) {
+        std::string token = tokenizer.token();
+        std::string pattern;
+        base::TrimWhitespaceASCII(token, base::TRIM_ALL, &pattern);
+        if (pattern.empty())
+          continue;
+        VLOG(0) << "Add bypass rules:" << pattern.c_str();
+        config->proxy_rules().bypass_rules.AddRuleFromString(pattern);
+      }
+    }
   } else {
     *config = ProxyConfig::CreateDirect();
   }
 }
 
 }  // namespace
 
 class ProxyConfigServiceAndroid::Delegate
     : public base::RefCountedThreadSafe<Delegate> {
  public:
@@ skipping 64 matching lines @@
     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) {
+  void ProxySettingsChangedTo(const std::string& host, int port,
+                              const std::string& exclusion_list) {
     DCHECK(OnJNIThread());
     ProxyConfig proxy_config;
-    CreateStaticProxyConfig(host, port, &proxy_config);
+    CreateStaticProxyConfig(host, port, exclusion_list, &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 ProxySettingsChangedTo(JNIEnv* env, jobject jself,
-                                      jstring jhost, jint jport) OVERRIDE {
+                                      jstring jhost, jint jport,
+                                      jstring jexclusion_list) OVERRIDE {
       std::string host = ConvertJavaStringToUTF8(env, jhost);
-      delegate_->ProxySettingsChangedTo(host, jport);
+      std::string exclusion_list =
+          ConvertJavaStringToUTF8(env, jexclusion_list);
+      delegate_->ProxySettingsChangedTo(host, jport, exclusion_list);
     }
 
     virtual void ProxySettingsChanged(JNIEnv* env, jobject self) OVERRIDE {
       delegate_->ProxySettingsChanged();
     }
 
    private:
     Delegate* const delegate_;
   };
 
@@ skipping 74 matching lines @@
         network_task_runner, jni_task_runner, get_property_callback)) {
   delegate_->SetupJNI();
   delegate_->FetchInitialConfig();
 }
 
 void ProxyConfigServiceAndroid::ProxySettingsChanged() {
   delegate_->ProxySettingsChanged();
 }
 
 } // namespace net