Introduce url::Origin to represent Web Origin.

net/websockets/websocket_stream_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_stream.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_basic_handshake_stream.h"
 #include "net/websockets/websocket_frame.h"
 #include "net/websockets/websocket_handshake_request_info.h"
 #include "net/websockets/websocket_handshake_response_info.h"
 #include "net/websockets/websocket_handshake_stream_create_helper.h"
 #include "net/websockets/websocket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 
 namespace net {
 namespace {
 
 typedef std::pair<std::string, std::string> HeaderKeyValuePair;
 
 std::vector<HeaderKeyValuePair> ToVector(const HttpRequestHeaders& headers) {
   HttpRequestHeaders::Iterator it(headers);
   std::vector<HeaderKeyValuePair> result;
   while (it.GetNext())
@@ skipping 83 matching lines @@
                               const std::vector<std::string>& sub_protocols,
                               const std::string& origin) {
     scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate(
         new TestConnectDelegate(this));
     WebSocketStream::ConnectDelegate* delegate = connect_delegate.get();
     stream_request_ = ::net::CreateAndConnectStreamForTesting(
         GURL(socket_url),
         scoped_ptr<WebSocketHandshakeStreamCreateHelper>(
             new DeterministicKeyWebSocketHandshakeStreamCreateHelper(
                 delegate, sub_protocols)),
-        GURL(origin),
+        url::Origin(origin),
         url_request_context_host_.GetURLRequestContext(),
         BoundNetLog(),
         connect_delegate.Pass());
   }
 
   static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
 
   // A simple function to make the tests more readable. Creates an empty vector.
   static std::vector<std::string> NoSubProtocols() {
     return std::vector<std::string>();
@@ skipping 50 matching lines @@
  public:
   // Performs a standard connect, with the value of the Sec-WebSocket-Extensions
   // header in the response set to |extensions_header_value|. Runs the event
   // loop to allow the connect to complete.
   void CreateAndConnectWithExtensions(
       const std::string& extensions_header_value) {
     CreateAndConnectStandard(
         "ws://localhost/testing_path",
         "/testing_path",
         NoSubProtocols(),
-        "http://localhost/",
+        "http://localhost",
         "",
         "Sec-WebSocket-Extensions: " + extensions_header_value + "\r\n");
     RunUntilIdle();
   }
 };
 
 // Confirm that the basic case works as expected.
 TEST_F(WebSocketStreamCreateTest, SimpleSuccess) {
   CreateAndConnectStandard(
-      "ws://localhost/", "/", NoSubProtocols(), "http://localhost/", "", "");
+      "ws://localhost/", "/", NoSubProtocols(), "http://localhost", "", "");
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_TRUE(stream_);
   EXPECT_TRUE(request_info_);
   EXPECT_TRUE(response_info_);
 }
 
 TEST_F(WebSocketStreamCreateTest, HandshakeInfo) {
   static const char kResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "foo: bar, baz\r\n"
       "hoge: fuga\r\n"
       "hoge: piyo\r\n"
       "\r\n";
 
   CreateAndConnectCustomResponse(
       "ws://localhost/",
       "/",
       NoSubProtocols(),
-      "http://localhost/",
+      "http://localhost",
       "",
       kResponse);
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
   RunUntilIdle();
   EXPECT_TRUE(stream_);
   ASSERT_TRUE(request_info_);
   ASSERT_TRUE(response_info_);
   std::vector<HeaderKeyValuePair> request_headers =
       ToVector(request_info_->headers);
   // We examine the contents of request_info_ and response_info_
   // mainly only in this test case.
   EXPECT_EQ(GURL("ws://localhost/"), request_info_->url);
   EXPECT_EQ(GURL("ws://localhost/"), response_info_->url);
   EXPECT_EQ(101, response_info_->status_code);
   EXPECT_EQ("Switching Protocols", response_info_->status_text);
   ASSERT_EQ(12u, request_headers.size());
   EXPECT_EQ(HeaderKeyValuePair("Host", "localhost"), request_headers[0]);
   EXPECT_EQ(HeaderKeyValuePair("Connection", "Upgrade"), request_headers[1]);
   EXPECT_EQ(HeaderKeyValuePair("Pragma", "no-cache"), request_headers[2]);
   EXPECT_EQ(HeaderKeyValuePair("Cache-Control", "no-cache"),
             request_headers[3]);
   EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), request_headers[4]);
-  EXPECT_EQ(HeaderKeyValuePair("Origin", "http://localhost/"),
+  EXPECT_EQ(HeaderKeyValuePair("Origin", "http://localhost"),
             request_headers[5]);
   EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Version", "13"),
             request_headers[6]);
   EXPECT_EQ(HeaderKeyValuePair("User-Agent", ""), request_headers[7]);
   EXPECT_EQ(HeaderKeyValuePair("Accept-Encoding", "gzip,deflate"),
             request_headers[8]);
   EXPECT_EQ(HeaderKeyValuePair("Accept-Language", "en-us,fr"),
             request_headers[9]);
   EXPECT_EQ("Sec-WebSocket-Key",  request_headers[10].first);
   EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Extensions",
@@ skipping 10 matching lines @@
   EXPECT_EQ("Sec-WebSocket-Accept", response_headers[1].first);
   EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), response_headers[2]);
   EXPECT_EQ(HeaderKeyValuePair("foo", "bar, baz"), response_headers[3]);
   EXPECT_EQ(HeaderKeyValuePair("hoge", "fuga"), response_headers[4]);
   EXPECT_EQ(HeaderKeyValuePair("hoge", "piyo"), response_headers[5]);
 }
 
 // Confirm that the stream isn't established until the message loop runs.
 TEST_F(WebSocketStreamCreateTest, NeedsToRunLoop) {
   CreateAndConnectStandard(
-      "ws://localhost/", "/", NoSubProtocols(), "http://localhost/", "", "");
+      "ws://localhost/", "/", NoSubProtocols(), "http://localhost", "", "");
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
 }
 
 // Check the path is used.
 TEST_F(WebSocketStreamCreateTest, PathIsUsed) {
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            NoSubProtocols(),
-                           "http://localhost/",
+                           "http://localhost",
                            "",
                            "");
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_TRUE(stream_);
 }
 
 // Check that the origin is used.
 TEST_F(WebSocketStreamCreateTest, OriginIsUsed) {
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            NoSubProtocols(),
-                           "http://google.com/",
+                           "http://google.com",
                            "",
                            "");
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_TRUE(stream_);
 }
 
 // Check that sub-protocols are sent and parsed.
 TEST_F(WebSocketStreamCreateTest, SubProtocolIsUsed) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chatv11.chromium.org");
   sub_protocols.push_back("chatv20.chromium.org");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
-                           "http://google.com/",
+                           "http://google.com",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n",
                            "Sec-WebSocket-Protocol: chatv20.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_TRUE(stream_);
   EXPECT_FALSE(has_failed());
   EXPECT_EQ("chatv20.chromium.org", stream_->GetSubProtocol());
 }
 
 // Unsolicited sub-protocols are rejected.
 TEST_F(WebSocketStreamCreateTest, UnsolicitedSubProtocol) {
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            NoSubProtocols(),
-                           "http://google.com/",
+                           "http://google.com",
                            "",
                            "Sec-WebSocket-Protocol: chatv20.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "Response must not include 'Sec-WebSocket-Protocol' header "
             "if not present in request: chatv20.chromium.org",
             failure_message());
 }
 
 // Missing sub-protocol response is rejected.
 TEST_F(WebSocketStreamCreateTest, UnacceptedSubProtocol) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chat.example.com");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
-                           "http://localhost/",
+                           "http://localhost",
                            "Sec-WebSocket-Protocol: chat.example.com\r\n",
                            "");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "Sent non-empty 'Sec-WebSocket-Protocol' header "
             "but no response was received",
             failure_message());
 }
 
 // Only one sub-protocol can be accepted.
 TEST_F(WebSocketStreamCreateTest, MultipleSubProtocolsInResponse) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chatv11.chromium.org");
   sub_protocols.push_back("chatv20.chromium.org");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
-                           "http://google.com/",
+                           "http://google.com",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Sec-WebSocket-Protocol' header must not appear "
             "more than once in a response",
             failure_message());
 }
 
 // Unmatched sub-protocol should be rejected.
 TEST_F(WebSocketStreamCreateTest, UnmatchedSubProtocolInResponse) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chatv11.chromium.org");
   sub_protocols.push_back("chatv20.chromium.org");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
-                           "http://google.com/",
+                           "http://google.com",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n",
                            "Sec-WebSocket-Protocol: chatv21.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Sec-WebSocket-Protocol' header value 'chatv21.chromium.org' "
             "in response does not match any of sent values",
             failure_message());
@@ skipping 16 matching lines @@
   EXPECT_FALSE(has_failed());
 }
 
 // Verify that incoming messages are actually decompressed with
 // permessage-deflate enabled.
 TEST_F(WebSocketStreamCreateExtensionTest, PerMessageDeflateInflates) {
   CreateAndConnectCustomResponse(
       "ws://localhost/testing_path",
       "/testing_path",
       NoSubProtocols(),
-      "http://localhost/",
+      "http://localhost",
       "",
       WebSocketStandardResponse(
           "Sec-WebSocket-Extensions: permessage-deflate\r\n") +
           std::string(
               "\xc1\x07"  // WebSocket header (FIN + RSV1, Text payload 7 bytes)
               "\xf2\x48\xcd\xc9\xc9\x07\x00",  // "Hello" DEFLATE compressed
               9));
   RunUntilIdle();
 
   ASSERT_TRUE(stream_);
@@ skipping 165 matching lines @@
 // TODO(ricea): Check that WebSocketDeflateStream is initialised with the
 // arguments from the server. This is difficult because the data written to the
 // socket is randomly masked.
 
 // Additional Sec-WebSocket-Accept headers should be rejected.
 TEST_F(WebSocketStreamCreateTest, DoubleAccept) {
   CreateAndConnectStandard(
       "ws://localhost/",
       "/",
       NoSubProtocols(),
-      "http://localhost/",
+      "http://localhost",
       "",
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Sec-WebSocket-Accept' header must not appear "
             "more than once in a response",
             failure_message());
 }
 
 // Response code 200 must be rejected.
 TEST_F(WebSocketStreamCreateTest, InvalidStatusCode) {
   static const char kInvalidStatusCodeResponse[] =
       "HTTP/1.1 200 OK\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kInvalidStatusCodeResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 200",
             failure_message());
 }
 
 // Redirects are not followed (according to the WHATWG WebSocket API, which
 // overrides RFC6455 for browser applications).
 TEST_F(WebSocketStreamCreateTest, RedirectsRejected) {
   static const char kRedirectResponse[] =
       "HTTP/1.1 302 Moved Temporarily\r\n"
       "Content-Type: text/html\r\n"
       "Content-Length: 34\r\n"
       "Connection: keep-alive\r\n"
       "Location: ws://localhost/other\r\n"
       "\r\n"
       "<title>Moved</title><h1>Moved</h1>";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kRedirectResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 302",
             failure_message());
 }
 
 // Malformed responses should be rejected. HttpStreamParser will accept just
 // about any garbage in the middle of the headers. To make it give up, the junk
 // has to be at the start of the response. Even then, it just gets treated as an
 // HTTP/0.9 response.
 TEST_F(WebSocketStreamCreateTest, MalformedResponse) {
   static const char kMalformedResponse[] =
       "220 mx.google.com ESMTP\r\n"
       "HTTP/1.1 101 OK\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kMalformedResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: Invalid status line",
             failure_message());
 }
 
 // Upgrade header must be present.
 TEST_F(WebSocketStreamCreateTest, MissingUpgradeHeader) {
   static const char kMissingUpgradeResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kMissingUpgradeResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: 'Upgrade' header is missing",
             failure_message());
 }
 
 // There must only be one upgrade header.
 TEST_F(WebSocketStreamCreateTest, DoubleUpgradeHeader) {
   CreateAndConnectStandard(
       "ws://localhost/",
       "/",
       NoSubProtocols(),
-      "http://localhost/",
+      "http://localhost",
       "", "Upgrade: HTTP/2.0\r\n");
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Upgrade' header must not appear more than once in a response",
             failure_message());
 }
 
 // There must only be one correct upgrade header.
 TEST_F(WebSocketStreamCreateTest, IncorrectUpgradeHeader) {
   static const char kMissingUpgradeResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "Upgrade: hogefuga\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kMissingUpgradeResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Upgrade' header value is not 'WebSocket': hogefuga",
             failure_message());
 }
 
 // Connection header must be present.
 TEST_F(WebSocketStreamCreateTest, MissingConnectionHeader) {
   static const char kMissingConnectionResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kMissingConnectionResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Connection' header is missing",
             failure_message());
 }
 
 // Connection header must contain "Upgrade".
 TEST_F(WebSocketStreamCreateTest, IncorrectConnectionHeader) {
   static const char kMissingConnectionResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "Connection: hogefuga\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kMissingConnectionResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Connection' header value must contain 'Upgrade'",
             failure_message());
 }
 
 // Connection header is permitted to contain other tokens.
 TEST_F(WebSocketStreamCreateTest, AdditionalTokenInConnectionHeader) {
   static const char kAdditionalConnectionTokenResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade, Keep-Alive\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kAdditionalConnectionTokenResponse);
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_TRUE(stream_);
 }
 
 // Sec-WebSocket-Accept header must be present.
 TEST_F(WebSocketStreamCreateTest, MissingSecWebSocketAccept) {
   static const char kMissingAcceptResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kMissingAcceptResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "'Sec-WebSocket-Accept' header is missing",
             failure_message());
 }
 
 // Sec-WebSocket-Accept header must match the key that was sent.
 TEST_F(WebSocketStreamCreateTest, WrongSecWebSocketAccept) {
   static const char kIncorrectAcceptResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: x/byyPZ2tOFvJCGkkugcKvqhhPk=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
-                                 "http://localhost/",
+                                 "http://localhost",
                                  "",
                                  kIncorrectAcceptResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: "
             "Incorrect 'Sec-WebSocket-Accept' header value",
             failure_message());
 }
 
 // Cancellation works.
 TEST_F(WebSocketStreamCreateTest, Cancellation) {
   CreateAndConnectStandard(
-      "ws://localhost/", "/", NoSubProtocols(), "http://localhost/", "", "");
+      "ws://localhost/", "/", NoSubProtocols(), "http://localhost", "", "");
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Connect failure must look just like negotiation failure.
 TEST_F(WebSocketStreamCreateTest, ConnectionFailure) {
   scoped_ptr<DeterministicSocketData> socket_data(
       new DeterministicSocketData(NULL, 0, NULL, 0));
   socket_data->set_connect_data(
       MockConnect(SYNCHRONOUS, ERR_CONNECTION_REFUSED));
   CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(),
-                                  "http://localhost/", socket_data.Pass());
+                                  "http://localhost", socket_data.Pass());
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_REFUSED",
             failure_message());
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Connect timeout must look just like any other failure.
 TEST_F(WebSocketStreamCreateTest, ConnectionTimeout) {
   scoped_ptr<DeterministicSocketData> socket_data(
       new DeterministicSocketData(NULL, 0, NULL, 0));
   socket_data->set_connect_data(
       MockConnect(ASYNC, ERR_CONNECTION_TIMED_OUT));
   CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(),
-                                  "http://localhost/", socket_data.Pass());
+                                  "http://localhost", socket_data.Pass());
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_TIMED_OUT",
             failure_message());
 }
 
 // Cancellation during connect works.
 TEST_F(WebSocketStreamCreateTest, CancellationDuringConnect) {
   scoped_ptr<DeterministicSocketData> socket_data(
       new DeterministicSocketData(NULL, 0, NULL, 0));
   socket_data->set_connect_data(MockConnect(SYNCHRONOUS, ERR_IO_PENDING));
   CreateAndConnectRawExpectations("ws://localhost/",
                                   NoSubProtocols(),
-                                  "http://localhost/",
+                                  "http://localhost",
                                   socket_data.Pass());
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
 }
 
 // Cancellation during write of the request headers works.
 TEST_F(WebSocketStreamCreateTest, CancellationDuringWrite) {
   // We seem to need at least two operations in order to use SetStop().
   MockWrite writes[] = {MockWrite(ASYNC, 0, "GET / HTTP/"),
                         MockWrite(ASYNC, 1, "1.1\r\n")};
   // We keep a copy of the pointer so that we can call RunFor() on it later.
   DeterministicSocketData* socket_data(
       new DeterministicSocketData(NULL, 0, writes, arraysize(writes)));
   socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_data->SetStop(1);
   CreateAndConnectRawExpectations("ws://localhost/",
                                   NoSubProtocols(),
-                                  "http://localhost/",
+                                  "http://localhost",
                                   make_scoped_ptr(socket_data));
   socket_data->Run();
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Cancellation during read of the response headers works.
 TEST_F(WebSocketStreamCreateTest, CancellationDuringRead) {
-  std::string request = WebSocketStandardRequest("/", "http://localhost/", "");
+  std::string request = WebSocketStandardRequest("/", "http://localhost", "");
   MockWrite writes[] = {MockWrite(ASYNC, 0, request.c_str())};
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 101 Switching Protocols\r\nUpgr"),
   };
   DeterministicSocketData* socket_data(new DeterministicSocketData(
       reads, arraysize(reads), writes, arraysize(writes)));
   socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_data->SetStop(1);
   CreateAndConnectRawExpectations("ws://localhost/",
                                   NoSubProtocols(),
-                                  "http://localhost/",
+                                  "http://localhost",
                                   make_scoped_ptr(socket_data));
   socket_data->Run();
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Over-size response headers (> 256KB) should not cause a crash.  This is a
 // regression test for crbug.com/339456. It is based on the layout test
 // "cookie-flood.html".
 TEST_F(WebSocketStreamCreateTest, VeryLargeResponseHeaders) {
   std::string set_cookie_headers;
   set_cookie_headers.reserve(45 * 10000);
   for (int i = 0; i < 10000; ++i) {
     set_cookie_headers +=
         base::StringPrintf("Set-Cookie: WK-websocket-test-flood-%d=1\r\n", i);
   }
   CreateAndConnectStandard("ws://localhost/", "/", NoSubProtocols(),
-                           "http://localhost/", "", set_cookie_headers);
+                           "http://localhost", "", set_cookie_headers);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_FALSE(response_info_);
 }
 
 // If the remote host closes the connection without sending headers, we should
 // log the console message "Connection closed before receiving a handshake
 // response".
 TEST_F(WebSocketStreamCreateTest, NoResponse) {
-  std::string request = WebSocketStandardRequest("/", "http://localhost/", "");
+  std::string request = WebSocketStandardRequest("/", "http://localhost", "");
   MockWrite writes[] = {MockWrite(ASYNC, request.data(), request.size(), 0)};
   MockRead reads[] = {MockRead(ASYNC, 0, 1)};
   DeterministicSocketData* socket_data(new DeterministicSocketData(
       reads, arraysize(reads), writes, arraysize(writes)));
   socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   CreateAndConnectRawExpectations("ws://localhost/",
                                   NoSubProtocols(),
-                                  "http://localhost/",
+                                  "http://localhost",
                                   make_scoped_ptr(socket_data));
   socket_data->RunFor(2);
   EXPECT_TRUE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_FALSE(response_info_);
   EXPECT_EQ("Connection closed before receiving a handshake response",
             failure_message());
 }
 
 }  // namespace
 }  // namespace net