Introduce url::Origin to represent Web Origin.

net/websockets/websocket_channel_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_channel.h"
 
 #include <string.h>
 
 #include <iostream>
 #include <string>
@@ skipping 13 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_handshake_request_info.h"
 #include "net/websockets/websocket_handshake_response_info.h"
 #include "net/websockets/websocket_mux.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 
 // Hacky macros to construct the body of a Close message from a code and a
 // string, while ensuring the result is a compile-time constant string.
 // Use like CLOSE_DATA(NORMAL_CLOSURE, "Explanation String")
 #define CLOSE_DATA(code, string) WEBSOCKET_CLOSE_CODE_AS_STRING_##code string
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_NORMAL_CLOSURE "\x03\xe8"
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_GOING_AWAY "\x03\xe9"
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_PROTOCOL_ERROR "\x03\xea"
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_ABNORMAL_CLOSURE "\x03\xee"
 #define WEBSOCKET_CLOSE_CODE_AS_STRING_SERVER_ERROR "\x03\xf3"
@@ skipping 629 matching lines @@
   MOCK_METHOD0(Close, void());
   MOCK_CONST_METHOD0(GetSubProtocol, std::string());
   MOCK_CONST_METHOD0(GetExtensions, std::string());
   MOCK_METHOD0(AsWebSocketStream, WebSocketStream*());
 };
 
 struct ArgumentCopyingWebSocketStreamCreator {
   scoped_ptr<WebSocketStreamRequest> Create(
       const GURL& socket_url,
       const std::vector<std::string>& requested_subprotocols,
-      const GURL& origin,
+      const url::Origin& origin,
       URLRequestContext* url_request_context,
       const BoundNetLog& net_log,
       scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
     this->socket_url = socket_url;
     this->requested_subprotocols = requested_subprotocols;
     this->origin = origin;
     this->url_request_context = url_request_context;
     this->net_log = net_log;
     this->connect_delegate = connect_delegate.Pass();
     return make_scoped_ptr(new WebSocketStreamRequest);
   }
 
   GURL socket_url;
-  GURL origin;
+  url::Origin origin;
   std::vector<std::string> requested_subprotocols;
   URLRequestContext* url_request_context;
   BoundNetLog net_log;
   scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate;
 };
 
 // Converts a std::string to a std::vector<char>. For test purposes, it is
 // convenient to be able to specify data as a string, but the
 // WebSocketEventInterface requires the vector<char> type.
 std::vector<char> AsVector(const std::string& s) {
@@ skipping 39 matching lines @@
   void set_stream(scoped_ptr<T> stream) {
     // Since the definition of "PassAs" depends on the type T, the C++ standard
     // requires the "template" keyword to indicate that "PassAs" should be
     // parsed as a template method.
     stream_ = stream.template PassAs<WebSocketStream>();
   }
 
   // A struct containing the data that will be used to connect the channel.
   // Grouped for readability.
   struct ConnectData {
-    ConnectData() : socket_url("ws://ws/"), origin("http://ws/") {}
+    ConnectData() : socket_url("ws://ws/"), origin("http://ws") {}
 
     // URLRequestContext object.
     URLRequestContext url_request_context;
 
     // URL to (pretend to) connect to.
     GURL socket_url;
     // Requested protocols for the request.
     std::vector<std::string> requested_subprotocols;
     // Origin of the request
-    GURL origin;
+    url::Origin origin;
 
     // A fake WebSocketStreamCreator that just records its arguments.
     ArgumentCopyingWebSocketStreamCreator creator;
   };
   ConnectData connect_data_;
 
   // The channel we are testing. Not initialised until SetChannel() is called.
   scoped_ptr<WebSocketChannel> channel_;
 
   // A mock or fake stream for tests that need one.
@@ skipping 174 matching lines @@
     // whether these methods are called or not.
     EXPECT_CALL(*mock_stream_, GetSubProtocol()).Times(AnyNumber());
     EXPECT_CALL(*mock_stream_, GetExtensions()).Times(AnyNumber());
   }
 };
 
 // Simple test that everything that should be passed to the creator function is
 // passed to the creator function.
 TEST_F(WebSocketChannelTest, EverythingIsPassedToTheCreatorFunction) {
   connect_data_.socket_url = GURL("ws://example.com/test");
-  connect_data_.origin = GURL("http://example.com/test");
+  connect_data_.origin = url::Origin("http://example.com");
   connect_data_.requested_subprotocols.push_back("Sinbad");
 
   CreateChannelAndConnect();
 
   const ArgumentCopyingWebSocketStreamCreator& actual = connect_data_.creator;
 
   EXPECT_EQ(&connect_data_.url_request_context, actual.url_request_context);
 
   EXPECT_EQ(connect_data_.socket_url, actual.socket_url);
   EXPECT_EQ(connect_data_.requested_subprotocols,
             actual.requested_subprotocols);
-  EXPECT_EQ(connect_data_.origin, actual.origin);
+  EXPECT_EQ(connect_data_.origin.string(), actual.origin.string());
 }
 
 // Verify that calling SendFlowControl before the connection is established does
 // not cause a crash.
 TEST_F(WebSocketChannelTest, SendFlowControlDuringHandshakeOkay) {
   CreateChannelAndConnect();
   ASSERT_TRUE(channel_);
   channel_->SendFlowControl(65536);
 }
 
@@ skipping 2118 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 }  // namespace
 }  // namespace net