Fix WebSocket to set first party for cookies

content/browser/renderer_host/websocket_dispatcher_host_unittest.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 "content/browser/renderer_host/websocket_dispatcher_host.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 99 matching lines @@
     gone_hosts_.push_back(routing_id);
   }
 
   base::WeakPtr<WebSocketDispatcherHostTest> GetWeakPtr() {
     return weak_ptr_factory_.GetWeakPtr();
   }
 
  protected:
   // Adds |n| connections. Returns true if succeeded.
   bool AddMultipleChannels(int number_of_channels) {
-    GURL socket_url("ws://example.com/test");
-    std::vector<std::string> requested_protocols;
-    url::Origin origin(GURL("http://example.com"));
-    int render_frame_id = -3;
-
     for (int i = 0; i < number_of_channels; ++i) {
       int routing_id = next_routing_id_++;
-      WebSocketHostMsg_AddChannelRequest message(
-          routing_id,
-          socket_url,
-          requested_protocols,
-          origin,
-          "",
-          render_frame_id);
+
+      WebSocketHostMsg_AddChannelRequest_Params params;
+      params.socket_url = GURL("ws://example.com/test");
+      params.origin = url::Origin(GURL("http://example.com"));
+      params.first_party_for_cookies = GURL("http://example.com");
+      params.user_agent_override = "";
+      params.render_frame_id = -3;
+
+      WebSocketHostMsg_AddChannelRequest message(routing_id, params);
       if (!dispatcher_host_->OnMessageReceived(message))
         return false;
     }
 
     return true;
   }
 
   // Adds and cancels |n| connections. Returns true if succeeded.
   bool AddAndCancelMultipleChannels(int number_of_channels) {
-    GURL socket_url("ws://example.com/test");
-    std::vector<std::string> requested_protocols;
-    url::Origin origin(GURL("http://example.com"));
-    int render_frame_id = -3;
-
     for (int i = 0; i < number_of_channels; ++i) {
       int routing_id = next_routing_id_++;
+
+      WebSocketHostMsg_AddChannelRequest_Params params;
+      params.socket_url = GURL("ws://example.com/test");
+      params.origin = url::Origin(GURL("http://example.com"));
+      params.first_party_for_cookies = GURL("http://example.com");
+      params.user_agent_override = "";
+      params.render_frame_id = -3;
+
       WebSocketHostMsg_AddChannelRequest messageAddChannelRequest(
-          routing_id,
-          socket_url,
-          requested_protocols,
-          origin,
-          "",
-          render_frame_id);
+          routing_id, params);
       if (!dispatcher_host_->OnMessageReceived(messageAddChannelRequest))
         return false;
 
       WebSocketMsg_DropChannel messageDropChannel(
           routing_id, false, net::kWebSocketErrorAbnormalClosure, "");
       if (!dispatcher_host_->OnMessageReceived(messageDropChannel))
         return false;
     }
 
     return true;
@@ skipping 48 matching lines @@
   IPC::Message message;
   EXPECT_FALSE(dispatcher_host_->OnMessageReceived(message));
 }
 
 TEST_F(WebSocketDispatcherHostTest, RenderProcessIdGetter) {
   EXPECT_EQ(kMagicRenderProcessId, dispatcher_host_->render_process_id());
 }
 
 TEST_F(WebSocketDispatcherHostTest, AddChannelRequest) {
   int routing_id = 123;
-  GURL socket_url("ws://example.com/test");
   std::vector<std::string> requested_protocols;
   requested_protocols.push_back("hello");
-  url::Origin origin(GURL("http://example.com"));
-  int render_frame_id = -2;
-  WebSocketHostMsg_AddChannelRequest message(
-      routing_id, socket_url, requested_protocols, origin, "", render_frame_id);
+
+  WebSocketHostMsg_AddChannelRequest_Params params;
+  params.socket_url = GURL("ws://example.com/test");
+  params.requested_protocols = requested_protocols;
+  params.origin = url::Origin(GURL("http://example.com"));
+  params.first_party_for_cookies = GURL("http://example.com");
+  params.user_agent_override = "";
+  params.render_frame_id = -2;
+
+  WebSocketHostMsg_AddChannelRequest message(routing_id, params);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message));
 
   ASSERT_EQ(1U, mock_hosts_.size());
   MockWebSocketHost* host = mock_hosts_[0];
 
   ASSERT_EQ(1U, host->received_messages_.size());
   const IPC::Message& forwarded_message = host->received_messages_[0];
   EXPECT_EQ(WebSocketHostMsg_AddChannelRequest::ID, forwarded_message.type());
   EXPECT_EQ(routing_id, forwarded_message.routing_id());
 }
 
 TEST_F(WebSocketDispatcherHostTest, SendFrameButNoHostYet) {
   int routing_id = 123;
   std::vector<char> data;
   WebSocketMsg_SendFrame message(
       routing_id, true, WEB_SOCKET_MESSAGE_TYPE_TEXT, data);
 
   // Expected to be ignored.
   EXPECT_TRUE(dispatcher_host_->OnMessageReceived(message));
 
   EXPECT_EQ(0U, mock_hosts_.size());
 }
 
 TEST_F(WebSocketDispatcherHostTest, SendFrame) {
   int routing_id = 123;
 
-  GURL socket_url("ws://example.com/test");
   std::vector<std::string> requested_protocols;
   requested_protocols.push_back("hello");
-  url::Origin origin(GURL("http://example.com"));
-  int render_frame_id = -2;
-  WebSocketHostMsg_AddChannelRequest add_channel_message(
-      routing_id, socket_url, requested_protocols, origin, "", render_frame_id);
+
+  WebSocketHostMsg_AddChannelRequest_Params params;
+  params.socket_url = GURL("ws://example.com/test");
+  params.requested_protocols = requested_protocols;
+  params.origin = url::Origin(GURL("http://example.com"));
+  params.first_party_for_cookies = GURL("http://example.com");
+  params.user_agent_override = "";
+  params.render_frame_id = -2;
+
+  WebSocketHostMsg_AddChannelRequest add_channel_message(routing_id, params);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(add_channel_message));
 
   std::vector<char> data;
   WebSocketMsg_SendFrame send_frame_message(
       routing_id, true, WEB_SOCKET_MESSAGE_TYPE_TEXT, data);
 
   EXPECT_TRUE(dispatcher_host_->OnMessageReceived(send_frame_message));
 
   ASSERT_EQ(1U, mock_hosts_.size());
   MockWebSocketHost* host = mock_hosts_[0];
 
   ASSERT_EQ(2U, host->received_messages_.size());
   {
     const IPC::Message& forwarded_message = host->received_messages_[0];
     EXPECT_EQ(WebSocketHostMsg_AddChannelRequest::ID, forwarded_message.type());
     EXPECT_EQ(routing_id, forwarded_message.routing_id());
   }
   {
     const IPC::Message& forwarded_message = host->received_messages_[1];
     EXPECT_EQ(WebSocketMsg_SendFrame::ID, forwarded_message.type());
     EXPECT_EQ(routing_id, forwarded_message.routing_id());
   }
 }
 
 TEST_F(WebSocketDispatcherHostTest, Destruct) {
-  WebSocketHostMsg_AddChannelRequest message1(
-      123, GURL("ws://example.com/test"), std::vector<std::string>(),
-      url::Origin(GURL("http://example.com")), "", -1);
-  WebSocketHostMsg_AddChannelRequest message2(
-      456, GURL("ws://example.com/test2"), std::vector<std::string>(),
-      url::Origin(GURL("http://example.com")), "", -1);
+  WebSocketHostMsg_AddChannelRequest_Params params1;
+  params1.socket_url = GURL("ws://example.com/test");
+  params1.requested_protocols = std::vector<std::string>();
+  params1.origin = url::Origin(GURL("http://example.com"));
+  params1.first_party_for_cookies = GURL("http://example.com");
+  params1.user_agent_override = "";
+  params1.render_frame_id = -1;
+
+  WebSocketHostMsg_AddChannelRequest message1(123, params1);
+
+  WebSocketHostMsg_AddChannelRequest_Params params2;
+  params2.socket_url = GURL("ws://example.com/test2");
+  params2.requested_protocols = std::vector<std::string>();
+  params2.origin = url::Origin(GURL("http://example.com"));
+  params2.first_party_for_cookies = GURL("http://example.com");
+  params2.user_agent_override = "";
+  params2.render_frame_id = -1;
+
+  WebSocketHostMsg_AddChannelRequest message2(456, params2);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message1));
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message2));
 
   ASSERT_EQ(2u, mock_hosts_.size());
 
   mock_hosts_.clear();
   dispatcher_host_ = NULL;
 
   ASSERT_EQ(2u, gone_hosts_.size());
@@ skipping 100 matching lines @@
   ASSERT_TRUE(AddMultipleChannels(1));
 
   EXPECT_EQ(1, dispatcher_host_->num_pending_connections());
   EXPECT_EQ(255, dispatcher_host_->num_failed_connections());
   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 }
 
 // This is a regression test for https://crrev.com/998173003/.
 TEST_F(WebSocketDispatcherHostTest, InvalidScheme) {
   int routing_id = 123;
-  GURL socket_url("http://example.com/test");
+
   std::vector<std::string> requested_protocols;
   requested_protocols.push_back("hello");
-  url::Origin origin(GURL("http://example.com"));
-  int render_frame_id = -2;
-  WebSocketHostMsg_AddChannelRequest message(
-      routing_id, socket_url, requested_protocols, origin, "", render_frame_id);
+
+  WebSocketHostMsg_AddChannelRequest_Params params;
+  params.socket_url = GURL("http://example.com/test");
+  params.requested_protocols = requested_protocols;
+  params.origin = url::Origin(GURL("http://example.com"));
+  params.first_party_for_cookies = GURL("http://example.com");
+  params.user_agent_override = "";
+  params.render_frame_id = -2;
+
+  WebSocketHostMsg_AddChannelRequest message(routing_id, params);
 
   ASSERT_TRUE(dispatcher_host_->OnMessageReceived(message));
 
   ASSERT_EQ(1U, mock_hosts_.size());
   MockWebSocketHost* host = mock_hosts_[0];
 
   // Tests that WebSocketHost::OnMessageReceived() doesn't cause a crash and
   // the connection with an invalid scheme fails here.
   // We call WebSocketHost::OnMessageReceived() here explicitly because
   // MockWebSocketHost does not call WebSocketHost::OnMessageReceived() for
   // WebSocketHostMsg_AddChannelRequest.
   host->WebSocketHost::OnMessageReceived(message);
 
   EXPECT_EQ(0, dispatcher_host_->num_pending_connections());
   EXPECT_EQ(1, dispatcher_host_->num_failed_connections());
   EXPECT_EQ(0, dispatcher_host_->num_succeeded_connections());
 }
 
 }  // namespace
 }  // namespace content