Update from https://crrev.com/316786

net/websockets/websocket_test_util.cc

 // Copyright 2013 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.
 
 #include "net/websockets/websocket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
+#include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
 
 namespace net {
 
 namespace {
 const uint64 kA =
     (static_cast<uint64>(0x5851f42d) << 32) + static_cast<uint64>(0x4c957f2d);
 const uint64 kC = 12345;
 const uint64 kM = static_cast<uint64>(1) << 48;
 
 }  // namespace
 
 LinearCongruentialGenerator::LinearCongruentialGenerator(uint32 seed)
     : current_(seed) {}
 
 uint32 LinearCongruentialGenerator::Generate() {
   uint64 result = current_;
   current_ = (current_ * kA + kC) % kM;
   return static_cast<uint32>(result >> 16);
 }
 
 std::string WebSocketStandardRequest(const std::string& path,
                                      const std::string& host,
                                      const std::string& origin,
                                      const std::string& extra_headers) {
+  return WebSocketStandardRequestWithCookies(path, host, origin, std::string(),
+                                             extra_headers);
+}
+
+std::string WebSocketStandardRequestWithCookies(
+    const std::string& path,
+    const std::string& host,
+    const std::string& origin,
+    const std::string& cookies,
+    const std::string& extra_headers) {
   // Unrelated changes in net/http may change the order and default-values of
   // HTTP headers, causing WebSocket tests to fail. It is safe to update this
   // string in that case.
   return base::StringPrintf(
       "GET %s HTTP/1.1\r\n"
       "Host: %s\r\n"
       "Connection: Upgrade\r\n"
       "Pragma: no-cache\r\n"
       "Cache-Control: no-cache\r\n"
       "Upgrade: websocket\r\n"
       "Origin: %s\r\n"
       "Sec-WebSocket-Version: 13\r\n"
       "User-Agent:\r\n"
       "Accept-Encoding: gzip, deflate\r\n"
       "Accept-Language: en-us,fr\r\n"
+      "%s"
       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
       "Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits\r\n"
       "%s\r\n",
-      path.c_str(), host.c_str(), origin.c_str(), extra_headers.c_str());
+      path.c_str(), host.c_str(), origin.c_str(), cookies.c_str(),
+      extra_headers.c_str());
 }
 
 std::string WebSocketStandardResponse(const std::string& extra_headers) {
   return base::StringPrintf(
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "%s\r\n",
       extra_headers.c_str());
@@ skipping 76 matching lines @@
 void WebSocketTestURLRequestContextHost::AddRawExpectations(
     scoped_ptr<DeterministicSocketData> socket_data) {
   maker_.AddRawExpectations(socket_data.Pass());
 }
 
 void WebSocketTestURLRequestContextHost::AddSSLSocketDataProvider(
     scoped_ptr<SSLSocketDataProvider> ssl_socket_data) {
   maker_.AddSSLSocketDataProvider(ssl_socket_data.Pass());
 }
 
+void WebSocketTestURLRequestContextHost::SetProxyConfig(
+    const std::string& proxy_rules) {
+  DCHECK(!url_request_context_initialized_);
+  proxy_service_.reset(ProxyService::CreateFixed(proxy_rules));
+  url_request_context_.set_proxy_service(proxy_service_.get());
+}
+
 TestURLRequestContext*
 WebSocketTestURLRequestContextHost::GetURLRequestContext() {
   if (!url_request_context_initialized_) {
     url_request_context_.Init();
     // A Network Delegate is required to make the URLRequest::Delegate work.
     url_request_context_.set_network_delegate(&network_delegate_);
     url_request_context_initialized_ = true;
   }
   return &url_request_context_;
 }
 
 }  // namespace net