[Android WebView] Synthesize a fake page loading event on page source modification (Re-land)

net/test/android/javatests/src/org/chromium/net/test/util/TestWebServer.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.test.util;
 
 import android.util.Base64;
 import android.util.Log;
 import android.util.Pair;
 
@@ skipping 62 matching lines @@
     private String mServerUri;
     private final boolean mSsl;
     private final int mPort;
 
     private static class Response {
         final byte[] mResponseData;
         final List<Pair<String, String>> mResponseHeaders;
         final boolean mIsRedirect;
         final Runnable mResponseAction;
         final boolean mIsNotFound;
+        final boolean mIsNoContent;
 
         Response(byte[] responseData, List<Pair<String, String>> responseHeaders,
-                boolean isRedirect, boolean isNotFound, Runnable responseAction) {
+                boolean isRedirect, boolean isNotFound, boolean isNoContent,
+                Runnable responseAction) {
             mIsRedirect = isRedirect;
             mIsNotFound = isNotFound;
+            mIsNoContent = isNoContent;
             mResponseData = responseData;
             mResponseHeaders = responseHeaders == null
                     ? new ArrayList<Pair<String, String>>() : responseHeaders;
             mResponseAction = responseAction;
         }
     }
 
     // The Maps below are modified on both the client thread and the internal server thread, so
     // need to use a lock when accessing them.
     private final Object mLock = new Object();
@@ skipping 103 matching lines @@
         sInstance = instance;
     }
 
     private static void setSecureInstance(TestWebServer instance) {
         sSecureInstance = instance;
     }
 
     private static final int RESPONSE_STATUS_NORMAL = 0;
     private static final int RESPONSE_STATUS_MOVED_TEMPORARILY = 1;
     private static final int RESPONSE_STATUS_NOT_FOUND = 2;
+    private static final int RESPONSE_STATUS_NO_CONTENT = 3;
 
     private String setResponseInternal(
             String requestPath, byte[] responseData,
             List<Pair<String, String>> responseHeaders, Runnable responseAction,
             int status) {
         final boolean isRedirect = (status == RESPONSE_STATUS_MOVED_TEMPORARILY);
         final boolean isNotFound = (status == RESPONSE_STATUS_NOT_FOUND);
+        final boolean isNoContent = (status == RESPONSE_STATUS_NO_CONTENT);
 
         synchronized (mLock) {
             mResponseMap.put(requestPath, new Response(
-                    responseData, responseHeaders, isRedirect, isNotFound, responseAction));
+                    responseData, responseHeaders, isRedirect, isNotFound, isNoContent,
+                    responseAction));
             mResponseCountMap.put(requestPath, Integer.valueOf(0));
             mLastRequestMap.put(requestPath, null);
         }
         return getResponseUrl(requestPath);
     }
 
     /**
      * Gets the URL on the server under which a particular request path will be accessible.
      *
      * This only gets the URL, you still need to set the response if you intend to access it.
@@ skipping 12 matching lines @@
      * @return The full URL including the path that should be requested to get the expected
      *         response.
      */
     public String setResponseWithNotFoundStatus(
             String requestPath) {
         return setResponseInternal(requestPath, "".getBytes(), null, null,
                 RESPONSE_STATUS_NOT_FOUND);
     }
 
     /**
+     * Sets a 204 (no content) response to be returned when a particular request path is passed in.
+     *
+     * @param requestPath The path to respond to.
+     * @return The full URL including the path that should be requested to get the expected
+     *         response.
+     */
+    public String setResponseWithNoContentStatus(String requestPath) {
+        return setResponseInternal(
+                requestPath, "".getBytes(), null, null, RESPONSE_STATUS_NO_CONTENT);
+    }
+
+    /**
      * 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 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.
      */
@@ skipping 180 matching lines @@
         synchronized (mLock) {
             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 if (response.mIsNotFound) {
             httpResponse = createResponse(HttpStatus.SC_NOT_FOUND);
             servedResponseFor(path, request);
+        } else if (response.mIsNoContent) {
+            httpResponse = createResponse(HttpStatus.SC_NO_CONTENT);
+            httpResponse.setHeader("Content-Length", "0");
+            servedResponseFor(path, request);
         } else if (response.mIsRedirect) {
             httpResponse = createResponse(HttpStatus.SC_MOVED_TEMPORARILY);
             for (Pair<String, String> header : response.mResponseHeaders) {
                 httpResponse.addHeader(header.first, header.second);
             }
             servedResponseFor(path, request);
         } else {
             if (response.mResponseAction != null) response.mResponseAction.run();
 
             httpResponse = createResponse(HttpStatus.SC_OK);
@@ skipping 202 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);
         }
     }
 }