Implement Android WebView BlockNetworkImages

android_webview/javatests/src/org/chromium/android_webview/test/TestWebServer.java

 // 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.
 
 package org.chromium.android_webview.test;
 
 import android.util.Base64;
 import android.util.Log;
 import android.util.Pair;
 
 import org.apache.http.HttpException;
 import org.apache.http.HttpRequest;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpStatus;
 import org.apache.http.HttpVersion;
 import org.apache.http.RequestLine;
 import org.apache.http.StatusLine;
-import org.apache.http.entity.StringEntity;
+import org.apache.http.entity.ByteArrayEntity;
 import org.apache.http.impl.DefaultHttpServerConnection;
 import org.apache.http.impl.cookie.DateUtils;
 import org.apache.http.message.BasicHttpResponse;
 import org.apache.http.params.BasicHttpParams;
 import org.apache.http.params.CoreProtocolPNames;
 import org.apache.http.params.HttpParams;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.UnsupportedEncodingException;
 import java.net.MalformedURLException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.URI;
 import java.net.URL;
 import java.net.URLConnection;
 import java.security.KeyManagementException;
 import java.security.KeyStore;
 import java.security.NoSuchAlgorithmException;
 import java.security.cert.X509Certificate;
@@ skipping 25 matching lines @@
     public static final String SHUTDOWN_PREFIX = "/shutdown";
 
     private static TestWebServer sInstance;
     private static Hashtable<Integer, String> sReasons;
 
     private ServerThread mServerThread;
     private String mServerUri;
     private boolean mSsl;
 
     private static class Response {
-        final String mResponseStr;
+        final byte[] mResponseData;
         final List<Pair<String, String>> mResponseHeaders;
 
-        Response(String responseStr, List<Pair<String, String>> responseHeaders) {
-            mResponseStr = responseStr;
+        Response(byte[] resposneData, List<Pair<String, String>> responseHeaders) {
+            mResponseData = resposneData;
             mResponseHeaders = responseHeaders == null ?
                     new ArrayList<Pair<String, String>>() : responseHeaders;
         }
     }
 
     private Map<String, Response> mResponseMap = new HashMap<String, Response>();
 
     /**
      * Create and start a local HTTP server instance.
      * @param ssl True if the server should be using secure sockets.
@@ skipping 49 matching lines @@
         }
 
         sInstance = null;
     }
 
     /**
      * Sets a response to be returned when a particular request path is passed
      * in (with the option to specify additional headers).
      *
      * @param requestPath The path to respond to.
-     * @param resposneString The response body that will be returned.
+     * @param responseString The response body that will be returned.
      * @param responseHeaders Any additional headers that should be returned along with the
      *                        response (null is acceptable).
      * @return The full URL including the path that should be requested to get the expected
      *         response.
      */
     public String setResponse(
-            String requestPath, String resposneString,
+            String requestPath, String responseString,
             List<Pair<String, String>> responseHeaders) {
-        mResponseMap.put(requestPath, new Response(resposneString, responseHeaders));
+        mResponseMap.put(requestPath, new Response(responseString.getBytes(), responseHeaders));
         return mServerUri + requestPath;
     }
 
+    /**
+     * Sets a base64 encoded response to be returned when a particular request path is passed
+     * in (with the option to specify additional headers).
+     *
+     * @param requestPath The path to respond to.
+     * @param base64EncodedResponse The response body that is base64 encoded. The actual server
+     *                              response will the decoded binary form.
+     * @param responseHeaders Any additional headers that should be returned along with the
+     *                        response (null is acceptable).
+     * @return The full URL including the path that should be requested to get the expected
+     *         response.
+     */
+    public String setResponseBase64(
+            String requestPath, String base64EncodedResponse,
+            List<Pair<String, String>> responseHeaders) {
+        mResponseMap.put(requestPath,
+                new Response(Base64.decode(base64EncodedResponse, Base64.DEFAULT),
+                responseHeaders));
+        return mServerUri + requestPath;
+    }
+
     private URLConnection openConnection(URL url)
             throws IOException, NoSuchAlgorithmException, KeyManagementException {
         if (mSsl) {
             // Install hostname verifiers and trust managers that don't do
             // anything in order to get around the client not trusting
             // the test server due to a lack of certificates.
 
             HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
             connection.setHostnameVerifier(new TestHostnameVerifier());
 
@@ skipping 55 matching lines @@
         URI uri = URI.create(uriString);
         String path = uri.getPath();
 
         Response response = mResponseMap.get(path);
         if (path.equals(SHUTDOWN_PREFIX)) {
             httpResponse = createResponse(HttpStatus.SC_OK);
         } else if (response == null) {
             httpResponse = createResponse(HttpStatus.SC_NOT_FOUND);
         } else {
             httpResponse = createResponse(HttpStatus.SC_OK);
-            httpResponse.setEntity(createEntity(response.mResponseStr));
+            httpResponse.setEntity(createEntity(response.mResponseData));
             for (Pair<String, String> header : response.mResponseHeaders) {
                 httpResponse.addHeader(header.first, header.second);
             }
         }
         StatusLine sl = httpResponse.getStatusLine();
         Log.i(TAG, sl.getStatusCode() + "(" + sl.getReasonPhrase() + ")");
         setDateHeaders(httpResponse);
         return httpResponse;
     }
 
@@ skipping 17 matching lines @@
         }
         // Fill in error reason. Avoid use of the ReasonPhraseCatalog, which is Locale-dependent.
         String reason = sReasons.get(status);
 
         if (reason != null) {
             StringBuffer buf = new StringBuffer("<html><head><title>");
             buf.append(reason);
             buf.append("</title></head><body>");
             buf.append(reason);
             buf.append("</body></html>");
-            response.setEntity(createEntity(buf.toString()));
+            response.setEntity(createEntity(buf.toString().getBytes()));
         }
         return response;
     }
 
     /**
      * Create a string entity for the given content.
      */
-    private StringEntity createEntity(String content) {
-        try {
-            StringEntity entity = new StringEntity(content);
-            entity.setContentType("text/html");
-            return entity;
-        } catch (UnsupportedEncodingException e) {
-            Log.w(TAG, e);
-        }
-        return null;
+    private ByteArrayEntity createEntity(byte[] data) {
+        ByteArrayEntity entity = new ByteArrayEntity(data);
+        entity.setContentType("text/html");
+        return entity;
     }
 
     private static class ServerThread extends Thread {
         private TestWebServer mServer;
         private ServerSocket mSocket;
         private boolean mIsSsl;
         private boolean mIsCancelled;
         private SSLContext mSslContext;
 
         /**
@@ skipping 120 matching lines @@
 
         private boolean isShutdownRequest(HttpRequest request) {
             RequestLine requestLine = request.getRequestLine();
             String uriString = requestLine.getUri();
             URI uri = URI.create(uriString);
             String path = uri.getPath();
             return path.equals(SHUTDOWN_PREFIX);
         }
     }
 }