Fix WebSocket to set first party for cookies

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 <limits.h>
 #include <stddef.h>
 #include <string.h>
 
@@ skipping 682 matching lines @@
   MOCK_CONST_METHOD0(GetSubProtocol, std::string());
   MOCK_CONST_METHOD0(GetExtensions, std::string());
   MOCK_METHOD0(AsWebSocketStream, WebSocketStream*());
 };
 
 struct ArgumentCopyingWebSocketStreamCreator {
   std::unique_ptr<WebSocketStreamRequest> Create(
       const GURL& socket_url,
       const std::vector<std::string>& requested_subprotocols,
       const url::Origin& origin,
+      const GURL& first_party_for_cookies,
       URLRequestContext* url_request_context,
       const BoundNetLog& net_log,
       std::unique_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
     this->socket_url = socket_url;
     this->requested_subprotocols = requested_subprotocols;
     this->origin = origin;
+    this->first_party_for_cookies = first_party_for_cookies;
     this->url_request_context = url_request_context;
     this->net_log = net_log;
     this->connect_delegate = std::move(connect_delegate);
     return base::WrapUnique(new WebSocketStreamRequest);
   }
 
   GURL socket_url;
   url::Origin origin;
+  GURL first_party_for_cookies;
   std::vector<std::string> requested_subprotocols;
   URLRequestContext* url_request_context;
   BoundNetLog net_log;
   std::unique_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 11 matching lines @@
 class WebSocketChannelTest : public ::testing::Test {
  protected:
   WebSocketChannelTest() : stream_(new FakeWebSocketStream) {}
 
   // Creates a new WebSocketChannel and connects it, using the settings stored
   // in |connect_data_|.
   void CreateChannelAndConnect() {
     channel_.reset(new WebSocketChannel(CreateEventInterface(),
                                         &connect_data_.url_request_context));
     channel_->SendAddChannelRequestForTesting(
-        connect_data_.socket_url,
-        connect_data_.requested_subprotocols,
-        connect_data_.origin,
+        connect_data_.socket_url, connect_data_.requested_subprotocols,
+        connect_data_.origin, connect_data_.first_party_for_cookies,
         base::Bind(&ArgumentCopyingWebSocketStreamCreator::Create,
                    base::Unretained(&connect_data_.creator)));
   }
 
   // Same as CreateChannelAndConnect(), but calls the on_success callback as
   // well. This method is virtual so that subclasses can also set the stream.
   virtual void CreateChannelAndConnectSuccessfully() {
     CreateChannelAndConnect();
     // Most tests aren't concerned with flow control from the renderer, so allow
     // MAX_INT quota units.
@@ skipping 12 matching lines @@
   // assigning to stream_. class T must be a subclass of WebSocketStream or you
   // will have unpleasant compile errors.
   template <class T>
   void set_stream(std::unique_ptr<T> stream) {
     stream_ = std::move(stream);
   }
 
   // A struct containing the data that will be used to connect the channel.
   // Grouped for readability.
   struct ConnectData {
-    ConnectData() : socket_url("ws://ws/"), origin(GURL("http://ws")) {}
+    ConnectData()
+        : socket_url("ws://ws/"),
+          origin(GURL("http://ws")),
+          first_party_for_cookies("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
     url::Origin origin;
+    // First party for cookies for the request.
+    GURL first_party_for_cookies;
 
     // A fake WebSocketStreamCreator that just records its arguments.
     ArgumentCopyingWebSocketStreamCreator creator;
   };
   ConnectData connect_data_;
 
   // The channel we are testing. Not initialised until SetChannel() is called.
   std::unique_ptr<WebSocketChannel> channel_;
 
   // A mock or fake stream for tests that need one.
@@ skipping 194 matching lines @@
     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 = url::Origin(GURL("http://example.com"));
+  connect_data_.first_party_for_cookies = GURL("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.Serialize(), actual.origin.Serialize());
+  EXPECT_EQ(connect_data_.first_party_for_cookies,
+            actual.first_party_for_cookies);
 }
 
 // Verify that calling SendFlowControl before the connection is established does
 // not cause a crash.
 TEST_F(WebSocketChannelTest, SendFlowControlDuringHandshakeOkay) {
   CreateChannelAndConnect();
   ASSERT_TRUE(channel_);
   ASSERT_EQ(CHANNEL_ALIVE, channel_->SendFlowControl(65536));
 }
 
@@ skipping 2463 matching lines @@
 
   channel_->SendFrame(
       true, WebSocketFrameHeader::kOpCodeText,
       std::vector<char>(static_cast<size_t>(kMessageSize), 'a'));
   int new_send_quota = channel_->current_send_quota();
   EXPECT_EQ(kMessageSize, initial_send_quota - new_send_quota);
 }
 
 }  // namespace
 }  // namespace net