Simplify CookieMonster::SetAllCookies{,Async}() implementation.

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 178 matching lines @@
 
 bool LRACookieSorter(const CookieMonster::CookieMap::iterator& it1,
                      const CookieMonster::CookieMap::iterator& it2) {
   if (it1->second->LastAccessDate() != it2->second->LastAccessDate())
     return it1->second->LastAccessDate() < it2->second->LastAccessDate();
 
   // Ensure stability for == last access times by falling back to creation.
   return it1->second->CreationDate() < it2->second->CreationDate();
 }
 
-// Compare cookies using name, domain and path, so that "equivalent" cookies
-// (per RFC 2965) are equal to each other.
-bool PartialDiffCookieSorter(const CanonicalCookie& a,
-                             const CanonicalCookie& b) {
-  return a.PartialCompare(b);
-}
-
-// This is a stricter ordering than PartialDiffCookieOrdering, where all fields
-// are used.
-bool FullDiffCookieSorter(const CanonicalCookie& a, const CanonicalCookie& b) {
-  return a.FullCompare(b);
-}
-
 // Our strategy to find duplicates is:
 // (1) Build a map from (cookiename, cookiepath) to
 //     {list of cookies with this signature, sorted by creation time}.
 // (2) For each list with more than 1 entry, keep the cookie having the
 //     most recent creation time, and delete the others.
 //
 // Two cookies are considered equivalent if they have the same domain,
 // name, and path.
 struct CookieSignature {
  public:
@@ skipping 1253 matching lines @@
   // if a cookie was set, in the common case it will be used soon after,
   // and we will purge the expired cookies in GetCookies().
   GarbageCollect(creation_date, key);
 
   MaybeRunCookieCallback(std::move(callback), true);
 }
 
 void CookieMonster::SetAllCookies(CookieList list,
                                   SetCookiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  CookieList positive_diff;
-  CookieList negative_diff;
 
-  CookieList old_cookies;
-  old_cookies.reserve(cookies_.size());
-  for (const auto& cookie : cookies_)
-    old_cookies.push_back(*cookie.second.get());
-
-  ComputeCookieDiff(&old_cookies, &list, &positive_diff, &negative_diff);
-
-  for (const auto& cookie_to_delete : negative_diff) {
-    for (CookieMapItPair its =
-             cookies_.equal_range(GetKey(cookie_to_delete.Domain()));
-         its.first != its.second; ++its.first) {
-      // The creation date acts as the unique index...
-      if (its.first->second->CreationDate() ==
-          cookie_to_delete.CreationDate()) {
-        // TODO(rdsmith): DELETE_COOKIE_CANONICAL is incorrect and should
-        // be changed.
-        InternalDeleteCookie(its.first, true, DELETE_COOKIE_CANONICAL);
-        break;
-      }
-    }
+  // Nuke the existing store.
+  while (!cookies_.empty()) {
+    // TODO(rdsmith): The CANONICAL is a lie.
+    InternalDeleteCookie(cookies_.begin(), true, DELETE_COOKIE_CANONICAL);
   }
 
-  if (positive_diff.size() == 0) {
-    MaybeRunCookieCallback(std::move(callback), true);
-    return;
-  }
-
+  // Set all passed in cookies.
   for (const auto& cookie : list) {
     const std::string key(GetKey(cookie.Domain()));
     Time creation_time = cookie.CreationDate();
-    bool already_expired = cookie.IsExpired(creation_time);
-
-    bool result =
-        DeleteAnyEquivalentCookie(key, cookie, true, false, already_expired);
-    DCHECK(!result);
-
-    if (already_expired)
+    if (cookie.IsExpired(creation_time))
       continue;
 
     if (cookie.IsPersistent()) {
       histogram_expiration_duration_minutes_->Add(
           (cookie.ExpiryDate() - creation_time).InMinutes());
     }
 
     InternalInsertCookie(key, base::MakeUnique<CanonicalCookie>(cookie), true);
     GarbageCollect(creation_time, key);
   }
@@ skipping 512 matching lines @@
                  .first;
       }
       it->second.push_back(std::move(callback));
       return;
     }
   }
 
   std::move(callback).Run();
 }
 
-void CookieMonster::ComputeCookieDiff(CookieList* old_cookies,
-                                      CookieList* new_cookies,
-                                      CookieList* cookies_to_add,
-                                      CookieList* cookies_to_delete) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  DCHECK(old_cookies);
-  DCHECK(new_cookies);
-  DCHECK(cookies_to_add);
-  DCHECK(cookies_to_delete);
-  DCHECK(cookies_to_add->empty());
-  DCHECK(cookies_to_delete->empty());
-
-  // Sort both lists.
-  // A set ordered by FullDiffCookieSorter is also ordered by
-  // PartialDiffCookieSorter.
-  std::sort(old_cookies->begin(), old_cookies->end(), FullDiffCookieSorter);
-  std::sort(new_cookies->begin(), new_cookies->end(), FullDiffCookieSorter);
-
-  // Select any old cookie for deletion if no new cookie has the same name,
-  // domain, and path.
-  std::set_difference(
-      old_cookies->begin(), old_cookies->end(), new_cookies->begin(),
-      new_cookies->end(),
-      std::inserter(*cookies_to_delete, cookies_to_delete->begin()),
-      PartialDiffCookieSorter);
-
-  // Select any new cookie for addition (or update) if no old cookie is exactly
-  // equivalent.
-  std::set_difference(new_cookies->begin(), new_cookies->end(),
-                      old_cookies->begin(), old_cookies->end(),
-                      std::inserter(*cookies_to_add, cookies_to_add->begin()),
-                      FullDiffCookieSorter);
-}
-
 void CookieMonster::RunCookieChangedCallbacks(const CanonicalCookie& cookie,
                                               ChangeCause cause) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CookieOptions opts;
   opts.set_include_httponly();
   opts.set_same_site_cookie_mode(
       CookieOptions::SameSiteCookieMode::INCLUDE_STRICT_AND_LAX);
   // Note that the callbacks in hook_map_ are wrapped with RunAsync(), so they
   // are guaranteed to not take long - they just post a RunAsync task back to
   // the appropriate thread's message loop and return.
   // TODO(mmenke): Consider running these synchronously?
   for (CookieChangedHookMap::iterator it = hook_map_.begin();
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, cause);
     }
   }
 }
 
 }  // namespace net