Update from https://crrev.com/312600

net/websockets/websocket_handshake_stream_create_helper_test.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_handshake_stream_create_helper.h"
 
 #include <string>
 #include <vector>
 
 #include "net/base/completion_callback.h"
@@ skipping 60 matching lines @@
       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
           ssl_error_callbacks,
       const SSLInfo& ssl_info,
       bool fatal) override {}
 };
 
 class WebSocketHandshakeStreamCreateHelperTest : public ::testing::Test {
  protected:
   scoped_ptr<WebSocketStream> CreateAndInitializeStream(
       const std::string& socket_url,
+      const std::string& socket_host,
       const std::string& socket_path,
       const std::vector<std::string>& sub_protocols,
       const std::string& origin,
       const std::string& extra_request_headers,
       const std::string& extra_response_headers) {
     WebSocketHandshakeStreamCreateHelper create_helper(&connect_delegate_,
                                                        sub_protocols);
     create_helper.set_failure_message(&failure_message_);
 
     scoped_ptr<ClientSocketHandle> socket_handle =
         socket_handle_factory_.CreateClientSocketHandle(
-            WebSocketStandardRequest(
-                socket_path, origin, extra_request_headers),
+            WebSocketStandardRequest(socket_path, socket_host, origin,
+                                     extra_request_headers),
             WebSocketStandardResponse(extra_response_headers));
 
     scoped_ptr<WebSocketHandshakeStreamBase> handshake(
         create_helper.CreateBasicStream(socket_handle.Pass(), false));
 
     // If in future the implementation type returned by CreateBasicStream()
     // changes, this static_cast will be wrong. However, in that case the test
     // will fail and AddressSanitizer should identify the issue.
     static_cast<WebSocketBasicHandshakeStream*>(handshake.get())
         ->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
@@ skipping 33 matching lines @@
     return handshake->Upgrade();
   }
 
   MockClientSocketHandleFactory socket_handle_factory_;
   TestConnectDelegate connect_delegate_;
   std::string failure_message_;
 };
 
 // Confirm that the basic case works as expected.
 TEST_F(WebSocketHandshakeStreamCreateHelperTest, BasicStream) {
-  scoped_ptr<WebSocketStream> stream =
-      CreateAndInitializeStream("ws://localhost/", "/",
-                                std::vector<std::string>(), "http://localhost/",
-                                "", "");
+  scoped_ptr<WebSocketStream> stream = CreateAndInitializeStream(
+      "ws://localhost/", "localhost", "/", std::vector<std::string>(),
+      "http://localhost/", "", "");
   EXPECT_EQ("", stream->GetExtensions());
   EXPECT_EQ("", stream->GetSubProtocol());
 }
 
 // Verify that the sub-protocols are passed through.
 TEST_F(WebSocketHandshakeStreamCreateHelperTest, SubProtocols) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chat");
   sub_protocols.push_back("superchat");
-  scoped_ptr<WebSocketStream> stream =
-      CreateAndInitializeStream("ws://localhost/",
-                                "/",
-                                sub_protocols,
-                                "http://localhost/",
-                                "Sec-WebSocket-Protocol: chat, superchat\r\n",
-                                "Sec-WebSocket-Protocol: superchat\r\n");
+  scoped_ptr<WebSocketStream> stream = CreateAndInitializeStream(
+      "ws://localhost/", "localhost", "/", sub_protocols, "http://localhost/",
+      "Sec-WebSocket-Protocol: chat, superchat\r\n",
+      "Sec-WebSocket-Protocol: superchat\r\n");
   EXPECT_EQ("superchat", stream->GetSubProtocol());
 }
 
 // Verify that extension name is available. Bad extension names are tested in
 // websocket_stream_test.cc.
 TEST_F(WebSocketHandshakeStreamCreateHelperTest, Extensions) {
   scoped_ptr<WebSocketStream> stream = CreateAndInitializeStream(
-      "ws://localhost/",
-      "/",
-      std::vector<std::string>(),
-      "http://localhost/",
-      "",
+      "ws://localhost/", "localhost", "/", std::vector<std::string>(),
+      "http://localhost/", "",
       "Sec-WebSocket-Extensions: permessage-deflate\r\n");
   EXPECT_EQ("permessage-deflate", stream->GetExtensions());
 }
 
 // Verify that extension parameters are available. Bad parameters are tested in
 // websocket_stream_test.cc.
 TEST_F(WebSocketHandshakeStreamCreateHelperTest, ExtensionParameters) {
   scoped_ptr<WebSocketStream> stream = CreateAndInitializeStream(
-      "ws://localhost/",
-      "/",
-      std::vector<std::string>(),
-      "http://localhost/",
-      "",
+      "ws://localhost/", "localhost", "/", std::vector<std::string>(),
+      "http://localhost/", "",
       "Sec-WebSocket-Extensions: permessage-deflate;"
       " client_max_window_bits=14; server_max_window_bits=14;"
       " server_no_context_takeover; client_no_context_takeover\r\n");
 
   EXPECT_EQ(
       "permessage-deflate;"
       " client_max_window_bits=14; server_max_window_bits=14;"
       " server_no_context_takeover; client_no_context_takeover",
       stream->GetExtensions());
 }
 
 }  // namespace
 }  // namespace net