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_array.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"
@@ skipping 136 matching lines @@
   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,
                              const std::string& pac_url,
+                             const std::vector<std::string>& exclusion_list,
                              ProxyConfig* config) {
   if (!pac_url.empty()) {
     config->set_pac_url(GURL(pac_url));
     config->set_pac_mandatory(false);
   } else 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();
+
+    std::vector<std::string>::const_iterator it;
+    for (it = exclusion_list.begin(); it != exclusion_list.end(); ++it) {
+      std::string pattern;
+      base::TrimWhitespaceASCII(*it, base::TRIM_ALL, &pattern);
+      if (pattern.empty())
+          continue;
+      config->proxy_rules().bypass_rules.AddRuleForHostname("", pattern, -1);

[sgurun-gerrit only, 2014/10/10 00:58:55]

himm, I am not fully sure if I am doing it right here. If  example.com is in the
bypass list of Android, I think it means bypass *.example.com. However here it
means only exclude example.com but not www.example.com. I will verify the
behavior here before submitting.

[sgurun-gerrit only, 2014/10/11 00:53:59]

So it seems that the exclusion list that is manually entered is simply
transformed from a comma separated list to a "|" separated list and then it is
written to http.nonProxyHosts System property.
This happens in Android.net.Proxy.setHttpProxySystemProperty().

The Java http.nonProxyHosts property is a list of patterns that may include "*".
It is described in detail here: 
http://docs.oracle.com/javase/6/docs/technotes/guides/net/proxies.html
It looks to me the behaviors are equivalent. Also I verified they behave same by
writing a simple program using HTTPUrlConnection via ProxySelector and comparing
to the chromium after adding this feature.


On 2014/10/10 00:58:55, sgurun_OOO_until_Oct5 wrote:

+    }
   } else {
     *config = ProxyConfig::CreateDirect();
   }
 }
 
 }  // namespace
 
 class ProxyConfigServiceAndroid::Delegate
     : public base::RefCountedThreadSafe<Delegate> {
  public:
@@ skipping 66 matching lines @@
     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,
-                              const std::string& pac_url) {
+                              const std::string& pac_url,
+                              const std::vector<std::string>& exclusion_list) {
     DCHECK(OnJNIThread());
     ProxyConfig proxy_config;
-    CreateStaticProxyConfig(host, port, pac_url, &proxy_config);
+    CreateStaticProxyConfig(host, port, pac_url, 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,
-                                        jstring jpac_url) override {
+                                        jstring jpac_url,
+                                        jobjectArray jexclusion_list) override {
       std::string host = ConvertJavaStringToUTF8(env, jhost);
       std::string pac_url;
       if (jpac_url)
         ConvertJavaStringToUTF8(env, jpac_url, &pac_url);
-      delegate_->ProxySettingsChangedTo(host, jport, pac_url);
+      std::vector<std::string> exclusion_list;
+      base::android::AppendJavaStringArrayToStringVector(
+          env, jexclusion_list, &exclusion_list);
+      delegate_->ProxySettingsChangedTo(host, jport, pac_url, 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