Fix WebSocket to set first party for cookies

net/websockets/websocket_stream_cookie_test.cc

 // Copyright 2015 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 <string>
 
 #include "base/callback_forward.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 14 matching lines @@
 
 using ::testing::TestWithParam;
 using ::testing::ValuesIn;
 
 const char kNoCookieHeader[] = "";
 
 class TestBase : public WebSocketStreamCreateTestBase {
  public:
   void CreateAndConnect(const GURL& url,
                         const url::Origin& origin,
+                        const GURL& first_party_for_cookies,
                         const std::string& cookie_header,
                         const std::string& response_body) {
     // We assume cookie_header ends with CRLF if not empty, as
     // WebSocketStandardRequestWithCookies requires. Use AddCRLFIfNotEmpty
     // in a call site.
     CHECK(cookie_header.empty() ||
           base::EndsWith(cookie_header, "\r\n", base::CompareCase::SENSITIVE));
 
     url_request_context_host_.SetExpectations(
         WebSocketStandardRequestWithCookies(url.path(), url.host(), origin,
                                             cookie_header, std::string(),
                                             std::string()),
         response_body);
-    CreateAndConnectStream(url.spec(), NoSubProtocols(), origin, "", nullptr);
+    CreateAndConnectStream(url, NoSubProtocols(), origin,
+                           first_party_for_cookies, "", nullptr);
   }
 
   std::string AddCRLFIfNotEmpty(const std::string& s) {
     return s.empty() ? s : s + "\r\n";
   }
 };
 
 struct ClientUseCookieParameter {
   // The URL for the WebSocket connection.
   const char* const url;
@@ skipping 62 matching lines @@
 TEST_P(WebSocketStreamClientUseCookieTest, ClientUseCookie) {
   // For wss tests.
   ssl_data_.push_back(base::WrapUnique(new SSLSocketDataProvider(ASYNC, OK)));
 
   CookieStore* store =
       url_request_context_host_.GetURLRequestContext()->cookie_store();
 
   const GURL url(GetParam().url);
   const GURL cookie_url(GetParam().cookie_url);
   const url::Origin origin(GURL("http://www.example.com"));
+  const GURL first_party_for_cookies("http://www.example.com/");
   const std::string cookie_line(GetParam().cookie_line);
   const std::string cookie_header(AddCRLFIfNotEmpty(GetParam().cookie_header));
 
   bool is_called = false;
   bool set_cookie_result = false;
   base::WeakPtrFactory<bool> weak_is_called(&is_called);
   base::WeakPtrFactory<bool> weak_set_cookie_result(&set_cookie_result);
 
   base::RunLoop run_loop;
   store->SetCookieWithOptionsAsync(
       cookie_url, cookie_line, CookieOptions(),
       base::Bind(&SetCookieHelperFunction, run_loop.QuitClosure(),
                  weak_is_called.GetWeakPtr(),
                  weak_set_cookie_result.GetWeakPtr()));
   run_loop.Run();
   ASSERT_TRUE(is_called);
   ASSERT_TRUE(set_cookie_result);
 
-  CreateAndConnect(url, origin, cookie_header, WebSocketStandardResponse(""));
+  CreateAndConnect(url, origin, first_party_for_cookies, cookie_header,
+                   WebSocketStandardResponse(""));
   WaitUntilConnectDone();
   EXPECT_FALSE(has_failed());
 }
 
 TEST_P(WebSocketStreamServerSetCookieTest, ServerSetCookie) {
   // For wss tests.
   ssl_data_.push_back(base::WrapUnique(new SSLSocketDataProvider(ASYNC, OK)));
 
   const GURL url(GetParam().url);
   const GURL cookie_url(GetParam().cookie_url);
   const url::Origin origin(GURL("http://www.example.com"));
+  const GURL first_party_for_cookies("http://www.example.com/");
   const std::string cookie_line(GetParam().cookie_line);
   const std::string cookie_header(AddCRLFIfNotEmpty(GetParam().cookie_header));
 
   const std::string response = base::StringPrintf(
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "%s"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n",
       cookie_header.c_str());
 
   CookieStore* store =
       url_request_context_host_.GetURLRequestContext()->cookie_store();
 
-  CreateAndConnect(url, origin, "", response);
+  CreateAndConnect(url, origin, first_party_for_cookies, "", response);
   WaitUntilConnectDone();
   EXPECT_FALSE(has_failed());
 
   bool is_called = false;
   std::string get_cookies_result;
   base::WeakPtrFactory<bool> weak_is_called(&is_called);
   base::WeakPtrFactory<std::string> weak_get_cookies_result(
       &get_cookies_result);
   base::RunLoop run_loop;
   store->GetCookiesWithOptionsAsync(
@@ skipping 311 matching lines @@
      "",
      "Set-Cookie: test-cookie"},
 };
 
 INSTANTIATE_TEST_CASE_P(WebSocketStreamServerSetCookieTest,
                         WebSocketStreamServerSetCookieTest,
                         ValuesIn(kServerSetCookieParameters));
 
 }  // namespace
 }  // namespace net