Add a SetCanonicalCookie method for CookieMonster.

net/cookies/cookie_monster_unittest.cc

 // Copyright (c) 2012 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/cookies/cookie_monster.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 127 matching lines @@
   bool SetAllCookies(CookieMonster* cm, const CookieList& list) {
     DCHECK(cm);
     ResultSavingCookieCallback<bool> callback;
     cm->SetAllCookiesAsync(list,
                            base::Bind(&ResultSavingCookieCallback<bool>::Run,
                                       base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
+  bool SetCanonicalCookie(CookieMonster* cm,
+                          CanonicalCookie cookie,
+                          bool secure_source,
+                          bool modify_http_only) {
+    DCHECK(cm);
+    ResultSavingCookieCallback<bool> callback;
+    cm->SetCanonicalCookieAsync(
+        cookie, secure_source, modify_http_only,
+        base::Bind(&ResultSavingCookieCallback<bool>::Run,
+                   base::Unretained(&callback)));
+    callback.WaitUntilDone();
+    return callback.result();
+  }
+
   int DeleteAllCreatedBetween(CookieMonster* cm,
                               const base::Time& delete_begin,
                               const base::Time& delete_end) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
         base::Bind(&ResultSavingCookieCallback<int>::Run,
                    base::Unretained(&callback)));
     callback.WaitUntilDone();
@@ skipping 2136 matching lines @@
                  base::Unretained(&get_cookie_list_callback)));
 
   // Only the main load should have been queued.
   ASSERT_EQ(1u, store->commands().size());
   ASSERT_EQ(CookieStoreCommand::LOAD, store->commands()[0].type);
 
   std::vector<std::unique_ptr<CanonicalCookie>> cookies;
   // When passed to the CookieMonster, it takes ownership of the pointed to
   // cookies.
   cookies.push_back(
-      CanonicalCookie::Create(kUrl, "a=b", base::Time(), CookieOptions()));
+      CanonicalCookie::Create(kUrl, "a=b", base::Time::Now(), CookieOptions()));
   ASSERT_TRUE(cookies[0]);
   store->commands()[0].loaded_callback.Run(std::move(cookies));
 
   delete_callback.WaitUntilDone();
   EXPECT_EQ(1, delete_callback.result());
 
   get_cookie_list_callback.WaitUntilDone();
   EXPECT_EQ(0u, get_cookie_list_callback.cookies().size());
 }
 
@@ skipping 534 matching lines @@
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   EXPECT_EQ("foo=bar; hello=world", GetCookies(cm.get(), url));
 }
 
 // Test that cookie source schemes are histogrammed correctly.
 TEST_F(CookieMonsterTest, CookieSourceHistogram) {
   base::HistogramTester histograms;
-  const std::string cookie_source_histogram = "Cookie.CookieSourceScheme";
+  const std::string cookie_source_histogram = "Cookie.CookieSourceScheme2";
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   histograms.ExpectTotalCount(cookie_source_histogram, 0);
 
   // Set a secure cookie on a cryptographic scheme.
   EXPECT_TRUE(
       SetCookie(cm.get(), https_www_google_.url(), "A=B; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 1);
@@ skipping 122 matching lines @@
   // Set a secure cookie from a secure origin that matches the name of an
   // already existing cookie and is not equivalent.
   EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(),
                         "A=E; secure; path=/some/other/path"));
   histograms.ExpectTotalCount(cookie_source_histogram, 11);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                7);
 }
 
+TEST_F(CookieMonsterTest, SetCanonicalCookie) {
+  std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
+  base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
+  base::Time one_hour_ago = base::Time::Now() - base::TimeDelta::FromHours(1);
+  base::Time one_hour_from_now =
+      base::Time::Now() + base::TimeDelta::FromHours(1);
+  std::string google_foo_host(www_google_foo_.url().host());
+  std::string google_bar_domain(www_google_bar_.domain());
+  std::string http_google_host(http_www_google_.url().host());
+  std::string https_google_host(https_www_google_.url().host());
+
+  EXPECT_TRUE(SetCanonicalCookie(
+      cm.get(),
+      CanonicalCookie("A", "B", google_foo_host, "/foo", one_hour_ago,
+                      one_hour_from_now, base::Time(), false, false,
+                      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT),
+      false, true));
+  // Note that for the creation time to be set exactly, without modification,
+  // it must be different from the one set by the line above.
+  EXPECT_TRUE(SetCanonicalCookie(
+      cm.get(),
+      CanonicalCookie("C", "D", "." + google_bar_domain, "/bar", two_hours_ago,
+                      base::Time(), one_hour_ago, false, true,
+                      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT),
+      false, true));
+  // Because of strict secure cookies, a cookie made by an HTTP URL should fail
+  // to create a cookie with a the secure attribute.
+  EXPECT_FALSE(SetCanonicalCookie(
+      cm.get(),
+      CanonicalCookie("E", "F", http_google_host, "/", base::Time(),
+                      base::Time(), base::Time(), true, false,
+                      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT),
+      false, true));
+  EXPECT_TRUE(SetCanonicalCookie(
+      cm.get(),
+      CanonicalCookie("E", "F", https_google_host, "/", base::Time(),
+                      base::Time(), base::Time(), true, false,
+                      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT),
+      true, true));
+
+  // Get all the cookies for a given URL, regardless of properties. This 'get()'
+  // operation shouldn't update the access time, as the test checks that the
+  // access time is set properly upon creation. Updating the access time would
+  // make that difficult.
+  CookieOptions options;
+  options.set_include_httponly();
+  options.set_same_site_cookie_mode(
+      CookieOptions::SameSiteCookieMode::INCLUDE_STRICT_AND_LAX);
+  options.set_do_not_update_access_time();
+
+  CookieList cookies =
+      GetCookieListWithOptions(cm.get(), this->www_google_foo_.url(), options);
+  CookieList::iterator it = cookies.begin();
+
+  ASSERT_TRUE(it != cookies.end());
+  EXPECT_EQ("A", it->Name());
+  EXPECT_EQ("B", it->Value());
+  EXPECT_EQ(this->www_google_foo_.host(), it->Domain());
+  EXPECT_EQ("/foo", it->Path());
+  EXPECT_EQ(one_hour_ago, it->CreationDate());
+  EXPECT_TRUE(it->IsPersistent());
+  // Expect expiration date is in the right range.  Some cookie implementations
+  // may not record it with millisecond accuracy.
+  EXPECT_LE((one_hour_from_now - it->ExpiryDate()).magnitude().InSeconds(), 5);
+  // Some CookieStores don't store last access date.
+  if (!it->LastAccessDate().is_null())
+    EXPECT_EQ(one_hour_ago, it->LastAccessDate());
+  EXPECT_FALSE(it->IsSecure());
+  EXPECT_FALSE(it->IsHttpOnly());
+
+  ASSERT_TRUE(++it == cookies.end());
+
+  // Verify that the cookie was set as 'httponly' by passing in a CookieOptions
+  // that excludes them and getting an empty result.
+  cookies = GetCookieListWithOptions(cm.get(), this->www_google_bar_.url(),
+                                     CookieOptions());
+  it = cookies.begin();
+  ASSERT_TRUE(it == cookies.end());
+
+  // Get the cookie using the wide open |options|:
+  cookies =
+      GetCookieListWithOptions(cm.get(), this->www_google_bar_.url(), options);
+  it = cookies.begin();
+
+  ASSERT_TRUE(it != cookies.end());
+  EXPECT_EQ("C", it->Name());
+  EXPECT_EQ("D", it->Value());
+  EXPECT_EQ(this->www_google_bar_.Format(".%D"), it->Domain());
+  EXPECT_EQ("/bar", it->Path());
+  EXPECT_EQ(two_hours_ago, it->CreationDate());
+  EXPECT_FALSE(it->IsPersistent());
+  // Some CookieStores don't store last access date.
+  if (!it->LastAccessDate().is_null())
+    EXPECT_EQ(one_hour_ago, it->LastAccessDate());
+  EXPECT_FALSE(it->IsSecure());
+  EXPECT_TRUE(it->IsHttpOnly());
+
+  EXPECT_TRUE(++it == cookies.end());
+
+  cookies = GetCookieListWithOptions(cm.get(), this->https_www_google_.url(),
+                                     options);
+  it = cookies.begin();
+
+  ASSERT_TRUE(it != cookies.end());
+  EXPECT_EQ("E", it->Name());
+  EXPECT_EQ("F", it->Value());
+  EXPECT_EQ("/", it->Path());
+  EXPECT_EQ(this->https_www_google_.host(), it->Domain());
+  // Cookie should have its creation time set, and be in a reasonable range.
+  EXPECT_LE((base::Time::Now() - it->CreationDate()).magnitude().InMinutes(),
+            2);
+  EXPECT_FALSE(it->IsPersistent());
+  // Some CookieStores don't store last access date.
+  if (!it->LastAccessDate().is_null())
+    EXPECT_EQ(it->CreationDate(), it->LastAccessDate());
+  EXPECT_TRUE(it->IsSecure());
+  EXPECT_FALSE(it->IsHttpOnly());
+
+  EXPECT_TRUE(++it == cookies.end());
+}
+
 TEST_F(CookieMonsterTest, SetSecureCookies) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   GURL http_url("http://www.google.com");
   GURL http_superdomain_url("http://google.com");
   GURL https_url("https://www.google.com");
 
   // A non-secure cookie can be created from either a URL with a secure or
   // insecure scheme.
   EXPECT_TRUE(SetCookie(cm.get(), http_url, "A=C;"));
   EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=B;"));
@@ skipping 359 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net