Use Android proxy's exclusion list to enable proxy bypass

net/android/java/src/org/chromium/net/ProxyChangeListener.java

 // Copyright 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.
 
 package org.chromium.net;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ skipping 18 matching lines @@
 public class ProxyChangeListener {
     private static final String TAG = "ProxyChangeListener";
     private static boolean sEnabled = true;
 
     private long mNativePtr;
     private Context mContext;
     private ProxyReceiver mProxyReceiver;
     private Delegate mDelegate;
 
     private static class ProxyConfig {
-        public ProxyConfig(String host, int port, String pacUrl) {
+        public ProxyConfig(String host, int port, String pacUrl, String[] exclusionList) {
             mHost = host;
             mPort = port;
             mPacUrl = pacUrl;
+            mExclusionList = exclusionList;
         }
         public final String mHost;
         public final int mPort;
         public final String mPacUrl;
+        public final String[] mExclusionList;
     }
 
+    /**
+     * The delegate for ProxyChangeListener. Use for testing.
+     */
     public interface Delegate {
         public void proxySettingsChanged();
     }
 
     private ProxyChangeListener(Context context) {
         mContext = context;
     }
 
     public static void setEnabled(boolean enabled) {
         sEnabled = enabled;
@@ skipping 38 matching lines @@
         // bundle. The android.net.ProxyProperties class is not exported from
         // the Android SDK, so we have to use reflection to get at it and invoke
         // methods on it. If we fail, return an empty proxy config (meaning
         // 'direct').
         // TODO(sgurun): once android.net.ProxyInfo is public, rewrite this.
         private ProxyConfig extractNewProxy(Intent intent) {
             try {
                 final String getHostName = "getHost";
                 final String getPortName = "getPort";
                 final String getPacFileUrl = "getPacFileUrl";
+                final String getExclusionList = "getExclusionList";
                 String className;
                 String proxyInfo;
                 if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
                     className = "android.net.ProxyProperties";
                     proxyInfo = "proxy";
                 } else {
                     className = "android.net.ProxyInfo";
                     proxyInfo = "android.intent.extra.PROXY_INFO";
                 }
 
                 Object props = intent.getExtras().get(proxyInfo);
                 if (props == null) {
                     return null;
                 }
 
                 Class<?> cls = Class.forName(className);
                 Method getHostMethod = cls.getDeclaredMethod(getHostName);
                 Method getPortMethod = cls.getDeclaredMethod(getPortName);
+                Method getExclusionListMethod = cls.getDeclaredMethod(getExclusionList);
 
                 String host = (String) getHostMethod.invoke(props);
                 int port = (Integer) getPortMethod.invoke(props);
 
+                String[] exclusionList;
+                if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
+                    String s = (String) getExclusionListMethod.invoke(props);
+                    exclusionList = s.split(",");
+                } else {
+                    exclusionList = (String[]) getExclusionListMethod.invoke(props);
+                }
                 // TODO(xunjieli): rewrite this once the API is public.
                 if (Build.VERSION.SDK_INT == Build.VERSION_CODES.KITKAT) {
                     Method getPacFileUrlMethod =
                         cls.getDeclaredMethod(getPacFileUrl);
                     String pacFileUrl = (String) getPacFileUrlMethod.invoke(props);
                     if (!TextUtils.isEmpty(pacFileUrl)) {
-                       return new ProxyConfig(host, port, pacFileUrl);
+                       return new ProxyConfig(host, port, pacFileUrl, exclusionList);
                     }
                 } else if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
                     Method getPacFileUrlMethod =
                         cls.getDeclaredMethod(getPacFileUrl);
                     Uri pacFileUrl = (Uri) getPacFileUrlMethod.invoke(props);
                     if (!Uri.EMPTY.equals(pacFileUrl)) {
-                      return new ProxyConfig(host, port, pacFileUrl.toString());
+                      return new ProxyConfig(host, port, pacFileUrl.toString(), exclusionList);
                     }
                 }
-                return new ProxyConfig(host, port, null);
+                return new ProxyConfig(host, port, null, exclusionList);
             } catch (ClassNotFoundException ex) {
                 Log.e(TAG, "Using no proxy configuration due to exception:" + ex);
                 return null;
             } catch (NoSuchMethodException ex) {
                 Log.e(TAG, "Using no proxy configuration due to exception:" + ex);
                 return null;
             } catch (IllegalAccessException ex) {
                 Log.e(TAG, "Using no proxy configuration due to exception:" + ex);
                 return null;
             } catch (InvocationTargetException ex) {
@@ skipping 12 matching lines @@
         }
         if (mDelegate != null) {
             mDelegate.proxySettingsChanged();
         }
         if (mNativePtr == 0) {
             return;
         }
         // Note that this code currently runs on a MESSAGE_LOOP_UI thread, but
         // the C++ code must run the callbacks on the network thread.
         if (cfg != null) {
-            nativeProxySettingsChangedTo(mNativePtr, cfg.mHost, cfg.mPort, cfg.mPacUrl);
+            nativeProxySettingsChangedTo(mNativePtr, cfg.mHost, cfg.mPort, cfg.mPacUrl,
+                    cfg.mExclusionList);
         } else {
             nativeProxySettingsChanged(mNativePtr);
         }
     }
 
     private void registerReceiver() {
         if (mProxyReceiver != null) {
             return;
         }
         IntentFilter filter = new IntentFilter();
@@ skipping 10 matching lines @@
         mProxyReceiver = null;
     }
 
     /**
      * See net/proxy/proxy_config_service_android.cc
      */
     @NativeClassQualifiedName("ProxyConfigServiceAndroid::JNIDelegate")
     private native void nativeProxySettingsChangedTo(long nativePtr,
                                                      String host,
                                                      int port,
-                                                     String pacUrl);
-
+                                                     String pacUrl,
+                                                     String[] exclusionList);
     @NativeClassQualifiedName("ProxyConfigServiceAndroid::JNIDelegate")
     private native void nativeProxySettingsChanged(long nativePtr);
 }