am 15e74b9d: Merge change 1939 into donut

Merge commit '15e74b9da8b4cda11ee54da1e77a02d1a86c944a'

* commit '15e74b9da8b4cda11ee54da1e77a02d1a86c944a':
  Temporarily suppress flaky test LocationManagerProximityTest until test harness support can be rolled out.
  Fix build breakage
  Revise the ImageButton class description to include information
  Record statistics about whether HTTP connections are reused.

1 files changed, 86 insertions, 30 deletions

diff --git a/core/java/com/google/android/net/GoogleHttpClient.java b/core/java/com/google/android/net/GoogleHttpClient.java
index 871c925..25d0122 100644
--- a/core/java/com/google/android/net/GoogleHttpClient.java
+++ b/core/java/com/google/android/net/GoogleHttpClient.java
@@ -37,6 +37,10 @@ import org.apache.http.client.HttpClient;
 import org.apache.http.client.ResponseHandler;
 import org.apache.http.client.methods.HttpUriRequest;
 import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.scheme.LayeredSocketFactory;
+import org.apache.http.conn.scheme.Scheme;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.conn.scheme.SocketFactory;
 import org.apache.http.impl.client.EntityEnclosingRequestWrapper;
 import org.apache.http.impl.client.RequestWrapper;
 import org.apache.http.params.HttpParams;
@@ -44,6 +48,8 @@ import org.apache.http.protocol.HttpContext;
 import org.apache.harmony.xnet.provider.jsse.SSLClientSessionCache;
 
 import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
 import java.net.URI;
 import java.net.URISyntaxException;
 
@@ -66,25 +72,22 @@ public class GoogleHttpClient implements HttpClient {
 
     private final AndroidHttpClient mClient;
     private final ContentResolver mResolver;
-    private final String mUserAgent;
+    private final String mAppName, mUserAgent;
+    private final ThreadLocal mConnectionAllocated = new ThreadLocal<Boolean>();
 
     /**
-     * Create an HTTP client.  Normally one client is shared throughout an app.
-     * @param resolver to use for accessing URL rewriting rules.
-     * @param userAgent to report in your HTTP requests.
-     * @deprecated Use {@link #GoogleHttpClient(android.content.ContentResolver, String, boolean)}
+     * Create an HTTP client without SSL session persistence.
+     * @deprecated Use {@link #GoogleHttpClient(android.content.Context, String, boolean)}
      */
     public GoogleHttpClient(ContentResolver resolver, String userAgent) {
         mClient = AndroidHttpClient.newInstance(userAgent);
         mResolver = resolver;
-        mUserAgent = userAgent;
+        mUserAgent = mAppName = userAgent;
     }
 
     /**
-     * GoogleHttpClient(Context, String, boolean) - without SSL session
-     * persistence.
-     *
-     * @deprecated use Context instead of ContentResolver.
+     * Create an HTTP client without SSL session persistence.
+     * @deprecated Use {@link #GoogleHttpClient(android.content.Context, String, boolean)}
      */
     public GoogleHttpClient(ContentResolver resolver, String appAndVersion,
             boolean gzipCapable) {
@@ -111,21 +114,70 @@ public class GoogleHttpClient implements HttpClient {
      * headers.  Needed because Google servers require gzip in the User-Agent
      * in order to return gzip'd content.
      */
-    public GoogleHttpClient(Context context, String appAndVersion,
-        boolean gzipCapable) {
-        this(context.getContentResolver(), SSLClientSessionCacheFactory.getCache(context),
+    public GoogleHttpClient(Context context, String appAndVersion, boolean gzipCapable) {
+        this(context.getContentResolver(),
+                SSLClientSessionCacheFactory.getCache(context),
                 appAndVersion, gzipCapable);
     }
 
-    private GoogleHttpClient(ContentResolver resolver, SSLClientSessionCache cache,
+    private GoogleHttpClient(ContentResolver resolver,
+            SSLClientSessionCache cache,
             String appAndVersion, boolean gzipCapable) {
         String userAgent = appAndVersion + " (" + Build.DEVICE + " " + Build.ID + ")";
         if (gzipCapable) {
             userAgent = userAgent + "; gzip";
         }
+
         mClient = AndroidHttpClient.newInstance(userAgent, cache);
         mResolver = resolver;
+        mAppName = appAndVersion;
         mUserAgent = userAgent;
+
+        // Wrap all the socket factories with the appropriate wrapper.  (Apache
+        // HTTP, curse its black and stupid heart, inspects the SocketFactory to
+        // see if it's a LayeredSocketFactory, so we need two wrapper classes.)
+        SchemeRegistry registry = getConnectionManager().getSchemeRegistry();
+        for (String name : registry.getSchemeNames()) {
+            Scheme scheme = registry.unregister(name);
+            SocketFactory sf = scheme.getSocketFactory();
+            if (sf instanceof LayeredSocketFactory) {
+                sf = new WrappedLayeredSocketFactory((LayeredSocketFactory) sf);
+            } else {
+                sf = new WrappedSocketFactory(sf);
+            }
+            registry.register(new Scheme(name, sf, scheme.getDefaultPort()));
+        }
+    }
+
+    /**
+     * Delegating wrapper for SocketFactory records when sockets are connected.
+     * We use this to know whether a connection was created vs reused, to
+     * gather per-app statistics about connection reuse rates.
+     */
+    private class WrappedSocketFactory implements SocketFactory {
+        private SocketFactory mDelegate;
+        private WrappedSocketFactory(SocketFactory delegate) { mDelegate = delegate; }
+        public final Socket createSocket() throws IOException { return mDelegate.createSocket(); }
+        public final boolean isSecure(Socket s) { return mDelegate.isSecure(s); }
+
+        public final Socket connectSocket(
+                Socket s, String h, int p,
+                InetAddress la, int lp, HttpParams params) throws IOException {
+            mConnectionAllocated.set(Boolean.TRUE);
+            return mDelegate.connectSocket(s, h, p, la, lp, params);
+        }
+    }
+
+    /** Like WrappedSocketFactory, but for the LayeredSocketFactory subclass. */
+    private class WrappedLayeredSocketFactory
+            extends WrappedSocketFactory implements LayeredSocketFactory {
+        private LayeredSocketFactory mDelegate;
+        private WrappedLayeredSocketFactory(LayeredSocketFactory sf) { super(sf); mDelegate = sf; }
+
+        public final Socket createSocket(Socket s, String host, int port, boolean autoClose)
+                throws IOException {
+            return mDelegate.createSocket(s, host, port, autoClose);
+        }
     }
 
     /**
@@ -140,24 +192,21 @@ public class GoogleHttpClient implements HttpClient {
     public HttpResponse executeWithoutRewriting(
             HttpUriRequest request, HttpContext context)
             throws IOException {
-        String code = "Error";
+        int code = -1;
         long start = SystemClock.elapsedRealtime();
         try {
             HttpResponse response;
-            // TODO: if we're logging network stats, and if the apache library is configured
-            // to follow redirects, count each redirect as an additional round trip.
+            mConnectionAllocated.set(null);
 
-            // see if we're logging network stats.
-            boolean logNetworkStats = NetworkStatsEntity.shouldLogNetworkStats();
+            if (NetworkStatsEntity.shouldLogNetworkStats()) {
+                // TODO: if we're logging network stats, and if the apache library is configured
+                // to follow redirects, count each redirect as an additional round trip.
 
-            if (logNetworkStats) {
                 int uid = android.os.Process.myUid();
                 long startTx = NetStat.getUidTxBytes(uid);
                 long startRx = NetStat.getUidRxBytes(uid);
 
                 response = mClient.execute(request, context);
-                code = Integer.toString(response.getStatusLine().getStatusCode());
-
                 HttpEntity origEntity = response == null ? null : response.getEntity();
                 if (origEntity != null) {
                     // yeah, we compute the same thing below.  we do need to compute this here
@@ -165,30 +214,37 @@ public class GoogleHttpClient implements HttpClient {
                     long now = SystemClock.elapsedRealtime();
                     long elapsed = now - start;
                     NetworkStatsEntity entity = new NetworkStatsEntity(origEntity,
-                            mUserAgent, uid, startTx, startRx,
+                            mAppName, uid, startTx, startRx,
                             elapsed /* response latency */, now /* processing start time */);
                     response.setEntity(entity);
                 }
             } else {
                 response = mClient.execute(request, context);
-                code = Integer.toString(response.getStatusLine().getStatusCode());
             }
 
+            code = response.getStatusLine().getStatusCode();
             return response;
-        } catch (IOException e) {
-            code = "IOException";
-            throw e;
         } finally {
             // Record some statistics to the checkin service about the outcome.
             // Note that this is only describing execute(), not body download.
             try {
                 long elapsed = SystemClock.elapsedRealtime() - start;
                 ContentValues values = new ContentValues();
-                values.put(Checkin.Stats.TAG,
-                         Checkin.Stats.Tag.HTTP_STATUS + ":" +
-                         mUserAgent + ":" + code);
                 values.put(Checkin.Stats.COUNT, 1);
                 values.put(Checkin.Stats.SUM, elapsed / 1000.0);
+
+                values.put(Checkin.Stats.TAG, Checkin.Stats.Tag.HTTP_REQUEST + ":" + mAppName);
+                mResolver.insert(Checkin.Stats.CONTENT_URI, values);
+
+                // No sockets and no exceptions means we successfully reused a connection
+                if (mConnectionAllocated.get() == null && code >= 0) {
+                    values.put(Checkin.Stats.TAG, Checkin.Stats.Tag.HTTP_REUSED + ":" + mAppName);
+                    mResolver.insert(Checkin.Stats.CONTENT_URI, values);
+                }
+
+                String status = code < 0 ? "IOException" : Integer.toString(code);
+                values.put(Checkin.Stats.TAG,
+                         Checkin.Stats.Tag.HTTP_STATUS + ":" + mAppName + ":" + status);
                 mResolver.insert(Checkin.Stats.CONTENT_URI, values);
             } catch (Exception e) {
                 Log.e(TAG, "Error recording stats", e);