Add a method to override all the cookies in 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_store_unittest.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 148 matching lines @@
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
         first_party_only, priority,
         base::Bind(&ResultSavingCookieCallback<bool>::Run,
                    base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
+  bool SetAllCookies(CookieMonster* cm, const CookieList& list) {
+    DCHECK(cm);
+    ResultSavingCookieCallback<bool> callback;
+    cm->SetAllCookiesAsync(list,
+                           base::Bind(&ResultSavingCookieCallback<bool>::Run,
+                                      base::Unretained(&callback)));
+    RunFor(kTimeout);
+    EXPECT_TRUE(callback.did_run());
+    return callback.result();
+  }
+
   int DeleteAll(CookieMonster* cm) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<int>::Run,
                                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
@@ skipping 356 matching lines @@
 
   // Function for creating a CM with a number of cookies in it,
   // no store (and hence no ability to affect access time).
   CookieMonster* CreateMonsterForGC(int num_cookies) {
     CookieMonster* cm(new CookieMonster(NULL, NULL));
     for (int i = 0; i < num_cookies; i++) {
       SetCookie(cm, GURL(base::StringPrintf("http://h%05d.izzle", i)), "a=1");
     }
     return cm;
   }
+
+  bool IsCookieInList(const CanonicalCookie& cookie, const CookieList& list) {
+    for (CookieList::const_iterator it = list.begin(); it != list.end(); ++it) {
+      if (it->Source() == cookie.Source() && it->Name() == cookie.Name() &&
+          it->Value() == cookie.Value() && it->Domain() == cookie.Domain() &&
+          it->Path() == cookie.Path() &&
+          it->CreationDate() == cookie.CreationDate() &&
+          it->ExpiryDate() == cookie.ExpiryDate() &&
+          it->LastAccessDate() == cookie.LastAccessDate() &&
+          it->IsSecure() == cookie.IsSecure() &&
+          it->IsHttpOnly() == cookie.IsHttpOnly() &&
+          it->Priority() == cookie.Priority()) {
+        return true;
+      }
+    }
+
+    return false;
+  }
 };
 
 // TODO(erikwright): Replace the other callbacks and synchronous helper methods
 // in this test suite with these Mocks.
 template <typename T, typename C>
 class MockCookieCallback {
  public:
   C AsCallback() {
     return base::Bind(&T::Invoke, base::Unretained(static_cast<T*>(this)));
   }
@@ skipping 63 matching lines @@
   cookie_monster->DeleteCookieAsync(url, name, callback->AsCallback());
 }
 ACTION_P3(GetCookiesAction, cookie_monster, url, callback) {
   cookie_monster->GetCookiesWithOptionsAsync(url, CookieOptions(),
                                              callback->AsCallback());
 }
 ACTION_P4(SetCookieAction, cookie_monster, url, cookie_line, callback) {
   cookie_monster->SetCookieWithOptionsAsync(url, cookie_line, CookieOptions(),
                                             callback->AsCallback());
 }
+ACTION_P3(SetAllCookiesAction, cookie_monster, list, callback) {
+  cookie_monster->SetAllCookiesAsync(list, callback->AsCallback());
+}
 ACTION_P4(DeleteAllCreatedBetweenAction,
           cookie_monster,
           delete_begin,
           delete_end,
           callback) {
   cookie_monster->DeleteAllCreatedBetweenAsync(delete_begin, delete_end,
                                                callback->AsCallback());
 }
 ACTION_P3(SetCookieWithDetailsAction, cookie_monster, cc, callback) {
   cookie_monster->SetCookieWithDetailsAsync(
@@ skipping 179 matching lines @@
 
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(SetCookieAction(&cookie_monster(), url_google_, "X=Y",
                                 &set_cookies_callback));
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
+TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
+  MockSetCookiesCallback set_cookies_callback;
+  CookieList list;
+  list.push_back(CanonicalCookie(url_google_, "A", "B", "google.izzle", "/",
+                                 base::Time::Now(), base::Time(), base::Time(),
+                                 false, true, false, COOKIE_PRIORITY_DEFAULT));
+  list.push_back(CanonicalCookie(url_google_, "C", "D", "google.izzle", "/",
+                                 base::Time::Now(), base::Time(), base::Time(),
+                                 false, true, false, COOKIE_PRIORITY_DEFAULT));
+
+  BeginWith(
+      SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(set_cookies_callback, Invoke(true))
+      .WillOnce(
+          SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
+  EXPECT_CALL(set_cookies_callback, Invoke(true))
+      .WillOnce(QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
   MockClosure delete_cookie_callback;
 
   BeginWithForDomainKey("google.izzle",
                         DeleteCookieAction(&cookie_monster(), url_google_, "A",
                                            &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Invoke())
@@ skipping 1262 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(2, counter->callback_count());
 
   cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(3, counter->callback_count());
 }
 
+TEST_F(CookieMonsterTest, SetAllCookies) {
+  scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
+  scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
+  cm->SetPersistSessionCookies(true);
+
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "U=V; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "W=X; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "Y=Z; path=/"));
+
+  CookieList list;
+  list.push_back(CanonicalCookie(url_google_, "A", "B", url_google_.host(), "/",
+                                 base::Time::Now(), base::Time(), base::Time(),
+                                 false, false, false, COOKIE_PRIORITY_DEFAULT));
+  list.push_back(CanonicalCookie(url_google_, "W", "X", url_google_.host(),
+                                 "/bar", base::Time::Now(), base::Time(),
+                                 base::Time(), false, false, false,
+                                 COOKIE_PRIORITY_DEFAULT));
+  list.push_back(CanonicalCookie(url_google_, "Y", "Z", url_google_.host(), "/",
+                                 base::Time::Now(), base::Time(), base::Time(),
+                                 false, false, false, COOKIE_PRIORITY_DEFAULT));
+
+  // SetAllCookies must not flush.

[erikwright (departed), 2015/03/17 17:46:16]

It should, presumably, still update the backend, no?

[droger, 2015/03/17 17:48:57]

Yes.

+  ASSERT_EQ(0, store->flush_count());
+  EXPECT_TRUE(SetAllCookies(cm.get(), list));
+  EXPECT_EQ(0, store->flush_count());
+
+  CookieList cookies = GetAllCookies(cm.get());
+  size_t expected_size = 3;  // "A", "W" and "Y". "U" is gone.
+  EXPECT_EQ(expected_size, cookies.size());
+  CookieList::iterator it = cookies.begin();
+
+  ASSERT_TRUE(it != cookies.end());
+  EXPECT_EQ("W", it->Name());
+  EXPECT_EQ("X", it->Value());
+  EXPECT_EQ("/bar", it->Path());  // The path has been updated.
+
+  ASSERT_TRUE(++it != cookies.end());
+  EXPECT_EQ("A", it->Name());
+  EXPECT_EQ("B", it->Value());
+
+  ASSERT_TRUE(++it != cookies.end());
+  EXPECT_EQ("Y", it->Name());
+  EXPECT_EQ("Z", it->Value());
+}
+
+TEST_F(CookieMonsterTest, ComputeCookieDiff) {
+  scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
+
+  base::Time now = base::Time::Now();
+  base::Time creation_time = now - base::TimeDelta::FromSeconds(1);
+
+  CanonicalCookie cookie1(url_google_, "A", "B", url_google_.host(), "/",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie2(url_google_, "C", "D", url_google_.host(), "/",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie3(url_google_, "E", "F", url_google_.host(), "/",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie4(url_google_, "G", "H", url_google_.host(), "/",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie4_with_new_value(
+      url_google_, "G", "iamnew", url_google_.host(), "/", creation_time,
+      base::Time(), base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie5(url_google_, "I", "J", url_google_.host(), "/",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie5_with_new_creation_time(
+      url_google_, "I", "J", url_google_.host(), "/", now, base::Time(),
+      base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie6(url_google_, "K", "L", url_google_.host(), "/foo",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie6_with_new_path(
+      url_google_, "K", "L", url_google_.host(), "/bar", creation_time,
+      base::Time(), base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie7(url_google_, "M", "N", url_google_.host(), "/foo",
+                          creation_time, base::Time(), base::Time(), false,
+                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie7_with_new_path(
+      url_google_, "M", "N", url_google_.host(), "/bar", creation_time,
+      base::Time(), base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
+
+  CookieList old_cookies;
+  old_cookies.push_back(cookie1);
+  old_cookies.push_back(cookie2);
+  old_cookies.push_back(cookie4);
+  old_cookies.push_back(cookie5);
+  old_cookies.push_back(cookie6);
+  old_cookies.push_back(cookie7);
+
+  CookieList new_cookies;
+  new_cookies.push_back(cookie1);
+  new_cookies.push_back(cookie3);
+  new_cookies.push_back(cookie4_with_new_value);
+  new_cookies.push_back(cookie5_with_new_creation_time);
+  new_cookies.push_back(cookie6_with_new_path);
+  new_cookies.push_back(cookie7);
+  new_cookies.push_back(cookie7_with_new_path);
+
+  CookieList cookies_to_add;
+  CookieList cookies_to_delete;
+
+  cm->ComputeCookieDiff(&old_cookies, &new_cookies, &cookies_to_add,
+                        &cookies_to_delete);
+
+  // |cookie1| has not changed.
+  EXPECT_FALSE(IsCookieInList(cookie1, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie1, cookies_to_delete));
+
+  // |cookie2| has been deleted.
+  EXPECT_FALSE(IsCookieInList(cookie2, cookies_to_add));
+  EXPECT_TRUE(IsCookieInList(cookie2, cookies_to_delete));
+
+  // |cookie3| has been added.
+  EXPECT_TRUE(IsCookieInList(cookie3, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie3, cookies_to_delete));
+
+  // |cookie4| has a new value: new cookie overrides the old one (which does not
+  // need to be explicitly removed).
+  EXPECT_FALSE(IsCookieInList(cookie4, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie4, cookies_to_delete));
+  EXPECT_TRUE(IsCookieInList(cookie4_with_new_value, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie4_with_new_value, cookies_to_delete));
+
+  // |cookie5| has a new creation time: new cookie overrides the old one (which
+  // does not need to be explicitly removed).
+  EXPECT_FALSE(IsCookieInList(cookie5, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie5, cookies_to_delete));
+  EXPECT_TRUE(IsCookieInList(cookie5_with_new_creation_time, cookies_to_add));
+  EXPECT_FALSE(
+      IsCookieInList(cookie5_with_new_creation_time, cookies_to_delete));
+
+  // |cookie6| has a new path: the new cookie does not overrides the old one,
+  // which needs to be explicitly removed.
+  EXPECT_FALSE(IsCookieInList(cookie6, cookies_to_add));
+  EXPECT_TRUE(IsCookieInList(cookie6, cookies_to_delete));
+  EXPECT_TRUE(IsCookieInList(cookie6_with_new_path, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie6_with_new_path, cookies_to_delete));
+
+  // |cookie7| is kept and |cookie7_with_new_path| is added as a new cookie.
+  EXPECT_FALSE(IsCookieInList(cookie7, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie7, cookies_to_delete));
+  EXPECT_TRUE(IsCookieInList(cookie7_with_new_path, cookies_to_add));
+  EXPECT_FALSE(IsCookieInList(cookie7_with_new_path, cookies_to_delete));
+}
+
 TEST_F(CookieMonsterTest, HistogramCheck) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   // Should match call in InitializeHistograms, but doesn't really matter
   // since the histogram should have been initialized by the CM construction
   // above.
   base::HistogramBase* expired_histogram = base::Histogram::FactoryGet(
       "Cookie.ExpirationDurationMinutes", 1, 10 * 365 * 24 * 60, 50,
       base::Histogram::kUmaTargetedHistogramFlag);
 
   scoped_ptr<base::HistogramSamples> samples1(
@@ skipping 624 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net