Provide child/frame IDs for WebSocket handshake request

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.annotation.SuppressLint;
 import android.util.Base64;
 import android.util.Log;
 import android.util.Pair;
 
+import org.apache.http.Header;
 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.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.net.MalformedURLException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.URI;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.charset.Charset;
 import java.security.KeyManagementException;
 import java.security.KeyStore;
+import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
 
 import javax.net.ssl.HostnameVerifier;
@@ skipping 25 matching lines @@
     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;
+        final boolean mForWebSocket;
 
         Response(byte[] responseData, List<Pair<String, String>> responseHeaders,
-                boolean isRedirect, boolean isNotFound, boolean isNoContent,
+                boolean isRedirect, boolean isNotFound, boolean isNoContent, boolean forWebSocket,
                 Runnable responseAction) {
             mIsRedirect = isRedirect;
             mIsNotFound = isNotFound;
             mIsNoContent = isNoContent;
+            mForWebSocket = forWebSocket;
             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 88 matching lines @@
     }
 
     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 static final int RESPONSE_STATUS_FOR_WEBSOCKET = 4;
 
     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);
+        final boolean forWebSocket = (status == RESPONSE_STATUS_FOR_WEBSOCKET);
 
         synchronized (mLock) {
-            mResponseMap.put(requestPath, new Response(
-                    responseData, responseHeaders, isRedirect, isNotFound, isNoContent,
-                    responseAction));
+            mResponseMap.put(
+                    requestPath, new Response(responseData, responseHeaders, isRedirect, isNotFound,
+                                         isNoContent, forWebSocket, 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 116 matching lines @@
      */
     public String setResponseBase64(
             String requestPath, String base64EncodedResponse,
             List<Pair<String, String>> responseHeaders) {
         return setResponseInternal(
                 requestPath, Base64.decode(base64EncodedResponse, Base64.DEFAULT),
                 responseHeaders, null, RESPONSE_STATUS_NORMAL);
     }
 
     /**
+     * Sets a response to a WebSocket handshake request.
+     *
+     * @param requestPath The path to respond to.
+     * @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 setResponseForWebSocket(
+            String requestPath, List<Pair<String, String>> responseHeaders) {
+        if (responseHeaders == null) {
+            responseHeaders = new ArrayList<Pair<String, String>>();
+        }
+        responseHeaders.add(Pair.create("Connection", "Upgrade"));

[mef, 2016/10/19 17:41:24]

If responseHeaders passed in are not null, then they'll be modified as a side
effect of this method. Would it be better to make a copy and modify just the
copy to avoid affecting caller?

[yhirano, 2016/10/20 04:21:07]

Done.

+        responseHeaders.add(Pair.create("Upgrade", "websocket"));
+        return setResponseInternal(
+                requestPath, "".getBytes(), responseHeaders, null, RESPONSE_STATUS_FOR_WEBSOCKET);
+    }
+
+    /**
      * Get the number of requests was made at this path since it was last set.
      */
     public int getRequestCount(String requestPath) {
         Integer count = null;
         synchronized (mLock) {
             count = mResponseCountMap.get(requestPath);
         }
         if (count == null) throw new IllegalArgumentException("Path not set: " + requestPath);
         return count.intValue();
     }
@@ skipping 117 matching lines @@
         } 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.mForWebSocket) {
+            Header[] keys = request.getHeaders("Sec-WebSocket-Key");
+            try {
+                if (keys.length == 1) {
+                    final String key = keys[0].getValue();
+                    httpResponse = createResponse(HttpStatus.SC_SWITCHING_PROTOCOLS);
+                    for (Pair<String, String> header : response.mResponseHeaders) {
+                        httpResponse.addHeader(header.first, header.second);
+                    }
+                    httpResponse.addHeader("Sec-WebSocket-Accept", computeWebSocketAccept(key));
+                    servedResponseFor(path, request);

[mef, 2016/10/19 17:41:24]

Should  servedResponseFor(path, request); be also called for 'else' and 'catch'
cases?

[yhirano, 2016/10/20 04:21:07]

Done.

+                } else {
+                    httpResponse = createResponse(HttpStatus.SC_NOT_FOUND);
+                }
+            } catch (NoSuchAlgorithmException e) {
+                httpResponse = createResponse(HttpStatus.SC_NOT_FOUND);
+            }
         } else {
             if (response.mResponseAction != null) response.mResponseAction.run();
 
             httpResponse = createResponse(HttpStatus.SC_OK);
             ByteArrayEntity entity = createEntity(response.mResponseData);
             httpResponse.setEntity(entity);
             httpResponse.setHeader("Content-Length", "" + entity.getContentLength());
             for (Pair<String, String> header : response.mResponseHeaders) {
                 httpResponse.addHeader(header.first, header.second);
             }
@@ skipping 51 matching lines @@
 
     /**
      * Create a string entity for the given content.
      */
     private ByteArrayEntity createEntity(byte[] data) {
         ByteArrayEntity entity = new ByteArrayEntity(data);
         entity.setContentType("text/html");
         return entity;
     }
 
+    /**
+     * Return a response for WebSocket handshake challenge.
+     */
+    private static String computeWebSocketAccept(String keyString) throws NoSuchAlgorithmException {
+        byte[] key = keyString.getBytes(Charset.forName("US-ASCII"));
+        byte[] guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11".getBytes(Charset.forName("US-ASCII"));
+
+        MessageDigest md = MessageDigest.getInstance("SHA");
+        md.update(key);
+        md.update(guid);
+        byte[] output = md.digest();
+        return Base64.encodeToString(output, Base64.DEFAULT);
+    }
+
     private static class ServerThread extends Thread {
         private TestWebServer mServer;
         private ServerSocket mSocket;
         private boolean mIsSsl;
         private SSLContext mSslContext;
 
         private final Object mLock = new Object();
         private boolean mIsCancelled;
         private Socket mCurrentRequestSocket;
 
@@ skipping 144 matching lines @@
                             socket.close();
                         } catch (IOException ignored) {
                             // safe to ignore
                         }
                     }
                 }
             }
         }
     }
 }