Add WebSocket cookie tests.

net/websockets/websocket_stream_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_stream.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 106 matching lines @@
       const std::string& extra_request_headers,
       const std::string& response_body,
       scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) {
     url_request_context_host_.SetExpectations(
         WebSocketStandardRequest(socket_path, socket_host, origin,
                                  extra_request_headers),
         response_body);
     CreateAndConnectStream(socket_url, sub_protocols, origin, timer.Pass());
   }
 
+  void CreateAndConnectCustomResponseWithCookies(
+      const std::string& socket_url,
+      const std::string& socket_host,
+      const std::string& socket_path,
+      const std::vector<std::string>& sub_protocols,
+      const std::string& origin,
+      const std::string& cookies,
+      const std::string& extra_request_headers,
+      const std::string& response_body,
+      scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) {
+    url_request_context_host_.SetExpectations(
+        WebSocketStandardRequestWithCookies(socket_path, socket_host, origin,
+                                            cookies, extra_request_headers),
+        response_body);
+    CreateAndConnectStream(socket_url, sub_protocols, origin, timer.Pass());
+  }
+
   // |extra_request_headers| and |extra_response_headers| must end in "\r\n" or
   // errors like "Unable to perform synchronous IO while stopped" will occur.
   void CreateAndConnectStandard(
       const std::string& socket_url,
       const std::string& socket_host,
       const std::string& socket_path,
       const std::vector<std::string>& sub_protocols,
       const std::string& origin,
       const std::string& extra_request_headers,
       const std::string& extra_response_headers,
       scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) {
     CreateAndConnectCustomResponse(
         socket_url, socket_host, socket_path, sub_protocols, origin,
         extra_request_headers,
         WebSocketStandardResponse(extra_response_headers), timer.Pass());
   }
 
+  // |cookies| must be empty or end with "\r\n".
+  // |extra_request_headers| and |extra_response_headers| must end in "\r\n" or
+  // errors like "Unable to perform synchronous IO while stopped" will occur.
+  void CreateAndConnectStandardWithCookies(
+      const std::string& socket_url,
+      const std::string& socket_host,
+      const std::string& socket_path,
+      const std::vector<std::string>& sub_protocols,
+      const std::string& origin,
+      const std::string& cookies,
+      const std::string& extra_request_headers,
+      const std::string& extra_response_headers,
+      scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) {
+    CreateAndConnectCustomResponseWithCookies(
+        socket_url, socket_host, socket_path, sub_protocols, origin, cookies,
+        extra_request_headers,
+        WebSocketStandardResponse(extra_response_headers), timer.Pass());
+  }
+
   void CreateAndConnectRawExpectations(
       const std::string& socket_url,
       const std::vector<std::string>& sub_protocols,
       const std::string& origin,
       scoped_ptr<DeterministicSocketData> socket_data,
       scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) {
     AddRawExpectations(socket_data.Pass());
     CreateAndConnectStream(socket_url, sub_protocols, origin, timer.Pass());
   }
 
@@ skipping 31 matching lines @@
             new base::Timer(false, false)));
   }
 
   static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
 
   // A simple function to make the tests more readable. Creates an empty vector.
   static std::vector<std::string> NoSubProtocols() {
     return std::vector<std::string>();
   }
 
+  struct WaitTask {

[Adam Rice, 2015/01/23 07:31:27]

You don't need this class. You can do the same thing directly with
base::RunLoop(). Use run_loop_.Run() instead of RunUntilIdle() and then use
run_loop_.Quit() when the callback is called to indicate the cookies are
available.

[yhirano, 2015/01/23 10:16:32]

Done.

+    WaitTask() : done_(false) {}
+    void Run() const {
+      if (!done_) {
+        base::MessageLoop::current()->PostTask(
+            FROM_HERE, base::Bind(&WaitTask::Run, base::Unretained(this)));
+      }
+    }
+
+    // Accept any arguments and ignore them.
+    template <typename... T>
+    void Stop(T... args) {
+      done_ = true;
+    }
+
+   private:
+    bool done_;
+  };
+
+  void SetCookie(CookieStore* store,
+                 const GURL& url,
+                 const std::string& cookie_line) {
+    WaitTask task;
+
+    task.Run();
+    store->SetCookieWithOptionsAsync(
+        url, cookie_line, CookieOptions(),
+        base::Bind(&WaitTask::Stop<bool>, base::Unretained(&task)));
+    WebSocketStreamCreateTest::RunUntilIdle();
+  }
+
+  std::string GetCookies(CookieStore* store, const GURL& url) {
+    struct GetCookies {
+      void RunTask() { task_.Run(); }
+      void Run(const std::string& cookies) {
+        cookies_ = cookies;
+        task_.Stop();
+      }
+
+      const std::string& cookies() const { return cookies_; }
+
+     private:
+      WaitTask task_;
+      std::string cookies_;
+    };
+    GetCookies callback;
+    callback.RunTask();
+
+    store->GetCookiesWithOptionsAsync(
+        url, CookieOptions(),
+        base::Bind(&GetCookies::Run, base::Unretained(&callback)));
+    WebSocketStreamCreateTest::RunUntilIdle();
+    return callback.cookies();
+  }
+
   const std::string& failure_message() const { return failure_message_; }
   bool has_failed() const { return has_failed_; }
 
   class TestConnectDelegate : public WebSocketStream::ConnectDelegate {
    public:
     explicit TestConnectDelegate(WebSocketStreamCreateTest* owner)
         : owner_(owner) {}
 
     void OnSuccess(scoped_ptr<WebSocketStream> stream) override {
       stream.swap(owner_->stream_);
@@ skipping 1027 matching lines @@
                                   raw_socket_data.Pass());
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   ASSERT_TRUE(ssl_error_callbacks_);
   ssl_error_callbacks_->CancelSSLRequest(ERR_CERT_AUTHORITY_INVALID,
                                          &ssl_info_);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
 }
 
+TEST_F(WebSocketStreamCreateTest, UseCookie) {

[Adam Rice, 2015/01/23 07:31:27]

You should try to only test one thing per test case. As far as I can see, this
test case tests six things:

1. That http cookies are sent on ws: connections
2. That non-secure https cookies are sent on ws: connections
3. That secure https cookies are not sent sent on ws: connections
4. That ws cookies are sent on ws: connections
5. That non-secure wss cookies are sent on ws: connections
6. That secure wss cookies are not sent on wss: connections

So it really should be six test cases. Since they would all be nearly identical,
a data-driven test using TEST_P and INSTANTIATE_TEST_CASE_P might be the
cleanest solution.

[yhirano, 2015/01/23 10:16:32]

Done.

+  CookieStore* store =
+      url_request_context_host_.GetURLRequestContext()->cookie_store();
+
+  SetCookie(store, GURL("http://www.example.com/"), "test-http-cookie=1");
+  SetCookie(store, GURL("https://www.example.com/"), "test-https-cookie=1");
+  SetCookie(store, GURL("https://www.example.com/"),
+            "test-https-secure-cookie=1; secure");
+  SetCookie(store, GURL("ws://www.example.com/"), "test-ws-cookie=1");
+  SetCookie(store, GURL("wss://www.example.com/"), "test-wss-cookie=1");
+  SetCookie(store, GURL("wss://www.example.com/"),
+            "test-wss-secure-cookie=1; secure");
+
+  // We use "www.example.com" to verify if the cookie domain is correctly
+  // handled.
+  std::string cookies =
+      "Cookie: test-http-cookie=1; test-https-cookie=1; test-ws-cookie=1; "
+      "test-wss-cookie=1\r\n";
+  CreateAndConnectStandardWithCookies(
+      "ws://www.example.com/testing_path", "www.example.com", "/testing_path",
+      NoSubProtocols(), "http://www.example.com", cookies, "", "");
+
+  RunUntilIdle();
+  EXPECT_FALSE(has_failed());
+}
+
+TEST_F(WebSocketStreamCreateTest, UseCookieSecure) {
+  ssl_data_.push_back(new SSLSocketDataProvider(ASYNC, OK));
+
+  CookieStore* store =
+      url_request_context_host_.GetURLRequestContext()->cookie_store();
+
+  SetCookie(store, GURL("http://www.example.com/"), "test-http-cookie=1");
+  SetCookie(store, GURL("https://www.example.com/"), "test-https-cookie=1");
+  SetCookie(store, GURL("https://www.example.com/"),
+            "test-https-secure-cookie=1; secure");
+  SetCookie(store, GURL("ws://www.example.com/"), "test-ws-cookie=1");
+  SetCookie(store, GURL("wss://www.example.com/"), "test-wss-cookie=1");
+  SetCookie(store, GURL("wss://www.example.com/"),
+            "test-wss-secure-cookie=1; secure");
+
+  // We use "www.example.com" to verify if the cookie domain is correctly
+  // handled.
+  std::string cookies =
+      "Cookie: test-http-cookie=1; test-https-cookie=1; "
+      "test-https-secure-cookie=1; test-ws-cookie=1; test-wss-cookie=1; "
+      "test-wss-secure-cookie=1\r\n";
+  CreateAndConnectStandardWithCookies(
+      "wss://www.example.com/testing_path", "www.example.com", "/testing_path",
+      NoSubProtocols(), "http://www.example.com", cookies, "", "");
+
+  RunUntilIdle();
+  EXPECT_FALSE(has_failed());
+}
+
+TEST_F(WebSocketStreamCreateTest, SetCookie) {
+  static const char kResponse[] =
+      "HTTP/1.1 101 Switching Protocols\r\n"
+      "Upgrade: websocket\r\n"
+      "Connection: Upgrade\r\n"
+      "Set-Cookie: test-ws-cookie=1\r\n"
+      "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
+      "\r\n";
+
+  CookieStore* store =
+      url_request_context_host_.GetURLRequestContext()->cookie_store();
+
+  // We use "www.example.com" to verify if the cookie domain is correctly
+  // handled.
+  CreateAndConnectCustomResponse(
+      "ws://www.example.com/testing_path", "www.example.com", "/testing_path",
+      NoSubProtocols(), "http://www.example.com", "", kResponse);
+
+  RunUntilIdle();
+  EXPECT_FALSE(has_failed());
+
+  EXPECT_EQ("test-ws-cookie=1",
+            GetCookies(store, GURL("http://www.example.com/")));
+  EXPECT_EQ("test-ws-cookie=1",
+            GetCookies(store, GURL("https://www.example.com/")));
+  EXPECT_EQ("test-ws-cookie=1",
+            GetCookies(store, GURL("ws://www.example.com/")));
+  EXPECT_EQ("test-ws-cookie=1",
+            GetCookies(store, GURL("wss://www.example.com/")));
+}
+
+TEST_F(WebSocketStreamCreateTest, SetCookieSecure) {
+  static const char kResponse[] =
+      "HTTP/1.1 101 Switching Protocols\r\n"
+      "Upgrade: websocket\r\n"
+      "Connection: Upgrade\r\n"
+      "Set-Cookie: test-wss-cookie=1\r\n"
+      "Set-Cookie: test-wss-secure-cookie=1; secure\r\n"
+      "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
+      "\r\n";
+
+  ssl_data_.push_back(new SSLSocketDataProvider(ASYNC, OK));
+  CookieStore* store =
+      url_request_context_host_.GetURLRequestContext()->cookie_store();
+
+  // We use "www.example.com" to verify if the cookie domain is correctly
+  // handled.
+  CreateAndConnectCustomResponse(
+      "wss://www.example.com/testing_path", "www.example.com", "/testing_path",
+      NoSubProtocols(), "http://www.example.com", "", kResponse);
+
+  RunUntilIdle();
+  EXPECT_FALSE(has_failed());
+
+  EXPECT_EQ("test-wss-cookie=1",
+            GetCookies(store, GURL("http://www.example.com/")));
+  EXPECT_EQ("test-wss-cookie=1; test-wss-secure-cookie=1",
+            GetCookies(store, GURL("https://www.example.com/")));
+  EXPECT_EQ("test-wss-cookie=1",
+            GetCookies(store, GURL("ws://www.example.com/")));
+  EXPECT_EQ("test-wss-cookie=1; test-wss-secure-cookie=1",
+            GetCookies(store, GURL("wss://www.example.com/")));
+}
+
 TEST_F(WebSocketStreamCreateTest, SelfSignedCertificateSuccess) {
   scoped_ptr<SSLSocketDataProvider> ssl_data(
       new SSLSocketDataProvider(ASYNC, ERR_CERT_AUTHORITY_INVALID));
   ssl_data->cert =
       ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
   ASSERT_TRUE(ssl_data->cert.get());
   ssl_data_.push_back(ssl_data.release());
   ssl_data.reset(new SSLSocketDataProvider(ASYNC, OK));
   ssl_data_.push_back(ssl_data.release());
   url_request_context_host_.AddRawExpectations(BuildNullSocketData());
@@ skipping 124 matching lines @@
   if (original) {
     samples->Subtract(*original);  // Cancel the original values.
   }
   EXPECT_EQ(1, samples->GetCount(INCOMPLETE));
   EXPECT_EQ(0, samples->GetCount(CONNECTED));
   EXPECT_EQ(0, samples->GetCount(FAILED));
 }
 
 }  // namespace
 }  // namespace net