Fix WebSocket to set first party for cookies

net/websockets/websocket_channel.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>  // for INT_MAX
 #include <stddef.h>
 
 #include <algorithm>
@@ skipping 319 matching lines @@
   // destroyed first.
   stream_.reset();
   // The timer may have a callback pointing back to us, so stop it just in case
   // someone decides to run the event loop from their destructor.
   close_timer_.Stop();
 }
 
 void WebSocketChannel::SendAddChannelRequest(
     const GURL& socket_url,
     const std::vector<std::string>& requested_subprotocols,
-    const url::Origin& origin) {
+    const url::Origin& origin,
+    const GURL& first_party_for_cookies) {
   // Delegate to the tested version.
   SendAddChannelRequestWithSuppliedCreator(
-      socket_url,
-      requested_subprotocols,
-      origin,
+      socket_url, requested_subprotocols, origin, first_party_for_cookies,
       base::Bind(&WebSocketStream::CreateAndConnectStream));
 }
 
 void WebSocketChannel::SetState(State new_state) {
   DCHECK_NE(state_, new_state);
 
   if (new_state == CONNECTED)
     established_on_ = base::TimeTicks::Now();
   if (state_ == CONNECTED && !established_on_.is_null()) {
     UMA_HISTOGRAM_LONG_TIMES(
@@ skipping 182 matching lines @@
     return CHANNEL_DELETED;
   DCHECK_EQ(CONNECTED, state_);
   SetState(SEND_CLOSED);
   return CHANNEL_ALIVE;
 }
 
 void WebSocketChannel::SendAddChannelRequestForTesting(
     const GURL& socket_url,
     const std::vector<std::string>& requested_subprotocols,
     const url::Origin& origin,
+    const GURL& first_party_for_cookies,
     const WebSocketStreamCreator& creator) {
-  SendAddChannelRequestWithSuppliedCreator(
-      socket_url, requested_subprotocols, origin, creator);
+  SendAddChannelRequestWithSuppliedCreator(socket_url, requested_subprotocols,
+                                           origin, first_party_for_cookies,
+                                           creator);
 }
 
 void WebSocketChannel::SetClosingHandshakeTimeoutForTesting(
     base::TimeDelta delay) {
   closing_handshake_timeout_ = delay;
 }
 
 void WebSocketChannel::SetUnderlyingConnectionCloseTimeoutForTesting(
     base::TimeDelta delay) {
   underlying_connection_close_timeout_ = delay;
 }
 
 void WebSocketChannel::SendAddChannelRequestWithSuppliedCreator(
     const GURL& socket_url,
     const std::vector<std::string>& requested_subprotocols,
     const url::Origin& origin,
+    const GURL& first_party_for_cookies,
     const WebSocketStreamCreator& creator) {
   DCHECK_EQ(FRESHLY_CONSTRUCTED, state_);
   if (!socket_url.SchemeIsWSOrWSS()) {
     // TODO(ricea): Kill the renderer (this error should have been caught by
     // Javascript).
     ignore_result(event_interface_->OnFailChannel("Invalid scheme"));
     // |this| is deleted here.
     return;
   }
   socket_url_ = socket_url;
   std::unique_ptr<WebSocketStream::ConnectDelegate> connect_delegate(
       new ConnectDelegate(this));
   stream_request_ = creator.Run(socket_url_, requested_subprotocols, origin,
-                                url_request_context_, BoundNetLog(),
-                                std::move(connect_delegate));
+                                first_party_for_cookies, url_request_context_,
+                                BoundNetLog(), std::move(connect_delegate));
   SetState(CONNECTING);
 }
 
 void WebSocketChannel::OnConnectSuccess(
     std::unique_ptr<WebSocketStream> stream) {
   DCHECK(stream);
   DCHECK_EQ(CONNECTING, state_);
 
   stream_ = std::move(stream);
 
@@ skipping 580 matching lines @@
 }
 
 void WebSocketChannel::CloseTimeout() {
   stream_->Close();
   SetState(CLOSED);
   DoDropChannel(false, kWebSocketErrorAbnormalClosure, "");
   // |this| has been deleted.
 }
 
 }  // namespace net