Divide CookieStoreIOS into two different classes with different backends

ios/net/cookies/cookie_store_ios.mm

 // Copyright 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 "ios/net/cookies/cookie_store_ios.h"
 
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 
 #include "base/bind.h"
@@ skipping 256 matching lines @@
 bool HasExplicitDomain(const std::string& cookie_line) {
   ParsedCookie cookie(cookie_line);
   return cookie.HasDomain();
 }
 
 }  // namespace
 
 #pragma mark -
 #pragma mark CookieStoreIOS
 
-CookieStoreIOS::CookieStoreIOS(
-    net::CookieMonster::PersistentCookieStore* persistent_store)
-    : CookieStoreIOS(persistent_store,
-                     [NSHTTPCookieStorage sharedHTTPCookieStorage]) {
-}
+CookieStoreIOS::CookieStoreIOS(NSHTTPCookieStorage* cookie_storage)
+    : CookieStoreIOS(nullptr, cookie_storage) {}
 
 CookieStoreIOS::~CookieStoreIOS() {
   NotificationTrampoline::GetInstance()->RemoveObserver(this);
 }
 
 // static
 std::unique_ptr<CookieStoreIOS> CookieStoreIOS::CreateCookieStore(
     NSHTTPCookieStorage* cookie_storage) {
   DCHECK(cookie_storage);
   // TODO(huey): Update this when CrNet supports multiple cookie jars.
   [cookie_storage setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
 
   // Create a cookie store with no persistent store backing. Then, populate
   // it from the system's cookie jar.
   std::unique_ptr<CookieStoreIOS> cookie_store(
-      new CookieStoreIOS(nullptr, cookie_storage));
-  cookie_store->synchronization_state_ = SYNCHRONIZED;
+      new CookieStoreIOS(cookie_storage));
   cookie_store->FlushStore(base::Closure());
   return cookie_store;
 }
 
 // static
 void CookieStoreIOS::NotifySystemCookiesChanged() {
   NotificationTrampoline::GetInstance()->NotifyCookiesChanged();
 }
 
 void CookieStoreIOS::SetMetricsEnabled() {
   static CookieStoreIOS* g_cookie_store_with_metrics = nullptr;
   DCHECK(!g_cookie_store_with_metrics || g_cookie_store_with_metrics == this)
       << "Only one cookie store may use metrics.";
   g_cookie_store_with_metrics = this;
   metrics_enabled_ = true;
 }
 
 #pragma mark -
 #pragma mark CookieStore methods
 
 void CookieStoreIOS::SetCookieWithOptionsAsync(
     const GURL& url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
     const SetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->SetCookieWithOptionsAsync(url, cookie_line, options,
-                                                 WrapSetCallback(callback));
-      break;
-    case SYNCHRONIZED:
-      // The exclude_httponly() option would only be used by a javascript
-      // engine.
-      DCHECK(!options.exclude_httponly());
-      // If cookies are not allowed, they are stashed in the CookieMonster, and
-      // should be written there instead.
-      DCHECK(SystemCookiesAllowed());
+  // The exclude_httponly() option would only be used by a javascript
+  // engine.
+  DCHECK(!options.exclude_httponly());
 
-      base::Time server_time =
-          options.has_server_time() ? options.server_time() : base::Time();
-      NSHTTPCookie* cookie =
-          GetNSHTTPCookieFromCookieLine(cookie_line, url, server_time);
-      DLOG_IF(WARNING, !cookie)
-          << "Could not create cookie for line: " << cookie_line;
+  // If cookies are not allowed, they are stashed in the CookieMonster, and
+  // should be written there instead.
+  DCHECK(SystemCookiesAllowed());
 
-      // On iOS, [cookie domain] is not empty when the cookie domain is not
-      // specified: it is inferred from the URL instead. The only case when it
-      // is empty is when the domain attribute is incorrectly formatted.
-      std::string domain_string(base::SysNSStringToUTF8([cookie domain]));
-      std::string dummy;
-      bool has_explicit_domain = HasExplicitDomain(cookie_line);
-      bool has_valid_domain =
-          net::cookie_util::GetCookieDomainWithString(
-              url, domain_string, &dummy);
-      // A cookie can be set if all of:
-      //   a) The cookie line is well-formed
-      //   b) The Domain attribute, if present, was not malformed
-      //   c) At least one of:
-      //       1) The cookie had no explicit Domain, so the Domain was inferred
-      //          from the URL, or
-      //       2) The cookie had an explicit Domain for which the URL is allowed
-      //          to set cookies.
-      bool success = (cookie != nil) && !domain_string.empty() &&
-                     (!has_explicit_domain || has_valid_domain);
+  base::Time server_time =
+      options.has_server_time() ? options.server_time() : base::Time();
+  NSHTTPCookie* cookie =
+      GetNSHTTPCookieFromCookieLine(cookie_line, url, server_time);
+  DLOG_IF(WARNING, !cookie) << "Could not create cookie for line: "
+                            << cookie_line;
 
-      if (success) {
-        [system_store_ setCookie:cookie];
-        creation_time_manager_->SetCreationTime(
-            cookie,
-            creation_time_manager_->MakeUniqueCreationTime(base::Time::Now()));
-      }
+  // On iOS, [cookie domain] is not empty when the cookie domain is not
+  // specified: it is inferred from the URL instead. The only case when it
+  // is empty is when the domain attribute is incorrectly formatted.
+  std::string domain_string(base::SysNSStringToUTF8([cookie domain]));
+  std::string dummy;
+  bool has_explicit_domain = HasExplicitDomain(cookie_line);
+  bool has_valid_domain =
+      net::cookie_util::GetCookieDomainWithString(url, domain_string, &dummy);
+  // A cookie can be set if all of:
+  //   a) The cookie line is well-formed
+  //   b) The Domain attribute, if present, was not malformed
+  //   c) At least one of:
+  //       1) The cookie had no explicit Domain, so the Domain was inferred
+  //          from the URL, or
+  //       2) The cookie had an explicit Domain for which the URL is allowed
+  //          to set cookies.
+  bool success = (cookie != nil) && !domain_string.empty() &&
+                 (!has_explicit_domain || has_valid_domain);
 
-      if (!callback.is_null())
-        callback.Run(success);
-      break;
+  if (success) {
+    [system_store_ setCookie:cookie];
+    creation_time_manager_->SetCreationTime(
+        cookie,
+        creation_time_manager_->MakeUniqueCreationTime(base::Time::Now()));
   }
+
+  if (!callback.is_null())
+    callback.Run(success);
 }
 
 void CookieStoreIOS::SetCookieWithDetailsAsync(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     base::Time creation_time,
     base::Time expiration_time,
     base::Time last_access_time,
     bool secure,
     bool http_only,
     CookieSameSite same_site,
     bool enforce_strict_secure,
     CookiePriority priority,
     const SetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  // If cookies are not allowed, they are stashed in the CookieMonster, and
+  // should be written there instead.
+  DCHECK(SystemCookiesAllowed());
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->SetCookieWithDetailsAsync(
+  bool success = false;
+
+  if (creation_time.is_null())
+    creation_time = base::Time::Now();
+
+  // First create a CanonicalCookie, to normalize the arguments,
+  // particularly domain and path, and perform validation.
+  std::unique_ptr<net::CanonicalCookie> canonical_cookie =
+      net::CanonicalCookie::Create(
           url, name, value, domain, path, creation_time, expiration_time,
-          last_access_time, secure, http_only, same_site, enforce_strict_secure,
-          priority, WrapSetCallback(callback));
-      break;
-    case SYNCHRONIZED:
-      // If cookies are not allowed, they are stashed in the CookieMonster, and
-      // should be written there instead.
-      DCHECK(SystemCookiesAllowed());
+          secure, http_only, same_site, enforce_strict_secure, priority);
 
-      bool success = false;
+  if (canonical_cookie) {
+    NSHTTPCookie* cookie = SystemCookieFromCanonicalCookie(*canonical_cookie);
 
-      if (creation_time.is_null())
-        creation_time = base::Time::Now();
+    if (cookie != nil) {
+      [system_store_ setCookie:cookie];
+      creation_time_manager_->SetCreationTime(
+          cookie, creation_time_manager_->MakeUniqueCreationTime(
+                      canonical_cookie->CreationDate()));
+      success = true;
+    }
+  }
 
-      // First create a CanonicalCookie, to normalize the arguments,
-      // particularly domain and path, and perform validation.
-      std::unique_ptr<net::CanonicalCookie> canonical_cookie =
-          net::CanonicalCookie::Create(
-              url, name, value, domain, path, creation_time, expiration_time,
-              secure, http_only, same_site, enforce_strict_secure, priority);
-
-      if (canonical_cookie) {
-        NSHTTPCookie* cookie =
-            SystemCookieFromCanonicalCookie(*canonical_cookie);
-
-        if (cookie != nil) {
-          [system_store_ setCookie:cookie];
-          creation_time_manager_->SetCreationTime(
-              cookie, creation_time_manager_->MakeUniqueCreationTime(
-                          canonical_cookie->CreationDate()));
-          success = true;
-        }
-      }
-
-      if (!callback.is_null())
-        callback.Run(success);
-      break;
-  }
+  if (!callback.is_null())
+    callback.Run(success);
 }
 
 void CookieStoreIOS::GetCookiesWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
     const GetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->GetCookiesWithOptionsAsync(url, options, callback);
-      break;
-    case SYNCHRONIZED:
-      // If cookies are not allowed, they are stashed in the CookieMonster, and
-      // should be read from there instead.
-      DCHECK(SystemCookiesAllowed());
-      // The exclude_httponly() option would only be used by a javascript
-      // engine.
-      DCHECK(!options.exclude_httponly());
+  // If cookies are not allowed, they are stashed in the CookieMonster, and
+  // should be read from there instead.
+  DCHECK(SystemCookiesAllowed());
+  // The exclude_httponly() option would only be used by a javascript
+  // engine.
+  DCHECK(!options.exclude_httponly());
 
-      // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
-      // options in here as well. https://crbug.com/459154
-      NSArray* cookies = GetCookiesForURL(system_store_,
-                                          url, creation_time_manager_.get());
-      if (!callback.is_null())
-        callback.Run(BuildCookieLineWithOptions(cookies, options));
-      break;
-  }
+  // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
+  // options in here as well. https://crbug.com/459154
+  NSArray* cookies =
+      GetCookiesForURL(system_store_, url, creation_time_manager_.get());
+  if (!callback.is_null())
+    callback.Run(BuildCookieLineWithOptions(cookies, options));
 }
 
 void CookieStoreIOS::GetCookieListWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
     const GetCookieListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (!SystemCookiesAllowed()) {
+    // If cookies are not allowed, the cookies are stashed in the
+    // CookieMonster, so get them from there.
+    cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
+    return;
+  }
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
-      break;
-    case SYNCHRONIZED:
-      if (!SystemCookiesAllowed()) {
-        // If cookies are not allowed, the cookies are stashed in the
-        // CookieMonster, so get them from there.
-        cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
-        return;
-      }
-
-      // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
-      // options in here as well. https://crbug.com/459154
-      NSArray* cookies = GetCookiesForURL(system_store_,
-                                          url, creation_time_manager_.get());
-      net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(
-          cookies);
-      if (!callback.is_null())
-        callback.Run(cookie_list);
-      break;
-  }
+  // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
+  // options in here as well. https://crbug.com/459154
+  NSArray* cookies =
+      GetCookiesForURL(system_store_, url, creation_time_manager_.get());
+  net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(cookies);
+  if (!callback.is_null())
+    callback.Run(cookie_list);
 }
 
 void CookieStoreIOS::GetAllCookiesAsync(const GetCookieListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->GetAllCookiesAsync(callback);
-      break;
-    case SYNCHRONIZED:
-      if (!SystemCookiesAllowed()) {
-        // If cookies are not allowed, the cookies are stashed in the
-        // CookieMonster, so get them from there.
-        cookie_monster_->GetAllCookiesAsync(callback);
-        return;
-      }
+  if (!SystemCookiesAllowed()) {
+    // If cookies are not allowed, the cookies are stashed in the
+    // CookieMonster, so get them from there.
+    cookie_monster_->GetAllCookiesAsync(callback);
+    return;
+  }
 
-      NSArray* cookies = GetAllCookies(system_store_,
-                                       creation_time_manager_.get());
-      net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(
-          cookies);
-      if (!callback.is_null()) {
-        callback.Run(cookie_list);
-      }
-      break;
+  NSArray* cookies = GetAllCookies(system_store_, creation_time_manager_.get());
+  net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(cookies);
+  if (!callback.is_null()) {
+    callback.Run(cookie_list);
   }
 }
 
 void CookieStoreIOS::DeleteCookieAsync(const GURL& url,
                                        const std::string& cookie_name,
                                        const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->DeleteCookieAsync(url, cookie_name,
-                                         WrapClosure(callback));
-      break;
-    case SYNCHRONIZED:
-      NSArray* cookies = GetCookiesForURL(system_store_,
-                                          url, creation_time_manager_.get());
-      for (NSHTTPCookie* cookie in cookies) {
-        if ([[cookie name]
-                isEqualToString:base::SysUTF8ToNSString(cookie_name)]) {
-          [system_store_ deleteCookie:cookie];
-          creation_time_manager_->DeleteCreationTime(cookie);
-        }
-      }
-      if (!callback.is_null())
-        callback.Run();
-      break;
+  NSArray* cookies =
+      GetCookiesForURL(system_store_, url, creation_time_manager_.get());
+  for (NSHTTPCookie* cookie in cookies) {
+    if ([[cookie name] isEqualToString:base::SysUTF8ToNSString(cookie_name)]) {
+      [system_store_ deleteCookie:cookie];
+      creation_time_manager_->DeleteCreationTime(cookie);
+    }
   }
+
+  if (!callback.is_null())
+    callback.Run();
 }
 
 void CookieStoreIOS::DeleteCanonicalCookieAsync(
     const CanonicalCookie& cookie,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->DeleteCanonicalCookieAsync(cookie,
-                                                  WrapDeleteCallback(callback));
-      break;
-    case SYNCHRONIZED:
-      // This relies on the fact cookies are given unique creation dates.
-      CookieFilterFunction filter = base::Bind(
-          IsCookieCreatedBetween, cookie.CreationDate(), cookie.CreationDate());
-      DeleteCookiesWithFilter(filter, callback);
-  }
+  // This relies on the fact cookies are given unique creation dates.
+  CookieFilterFunction filter = base::Bind(
+      IsCookieCreatedBetween, cookie.CreationDate(), cookie.CreationDate());
+  DeleteCookiesWithFilter(filter, callback);
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->DeleteAllCreatedBetweenAsync(
-          delete_begin, delete_end, WrapDeleteCallback(callback));
-      break;
-    case SYNCHRONIZED:
-      CookieFilterFunction filter =
-          base::Bind(&IsCookieCreatedBetween, delete_begin, delete_end);
-      DeleteCookiesWithFilter(filter, callback);
-      break;
-  }
+  CookieFilterFunction filter =
+      base::Bind(&IsCookieCreatedBetween, delete_begin, delete_end);
+  DeleteCookiesWithFilter(filter, callback);
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const CookiePredicate& predicate,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->DeleteAllCreatedBetweenWithPredicateAsync(
-          delete_begin, delete_end, predicate, WrapDeleteCallback(callback));
-      break;
-    case SYNCHRONIZED:
-      CookieFilterFunction filter =
-          base::Bind(IsCookieCreatedBetweenWithPredicate, delete_begin,
-                     delete_end, predicate);
-      DeleteCookiesWithFilter(filter, callback);
-      break;
-  }
+  CookieFilterFunction filter = base::Bind(IsCookieCreatedBetweenWithPredicate,
+                                           delete_begin, delete_end, predicate);
+  DeleteCookiesWithFilter(filter, callback);
 }
 
 void CookieStoreIOS::DeleteSessionCookiesAsync(const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
-  switch (synchronization_state_) {
-    case NOT_SYNCHRONIZED:
-      cookie_monster_->DeleteSessionCookiesAsync(WrapDeleteCallback(callback));
-      break;
-    case SYNCHRONIZED:
-      CookieFilterFunction filter = base::Bind(&IsCookieSessionCookie);
-      DeleteCookiesWithFilter(filter, callback);
-      break;
-  }
+  CookieFilterFunction filter = base::Bind(&IsCookieSessionCookie);
+  DeleteCookiesWithFilter(filter, callback);
 }
 
 void CookieStoreIOS::FlushStore(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (SystemCookiesAllowed()) {
     // If cookies are disabled, the system store is empty, and the cookies are
     // stashed on disk. Do not delete the cookies on the disk in this case.
     WriteToCookieMonster([system_store_ cookies]);
   }
   cookie_monster_->FlushStore(closure);
   flush_closure_.Cancel();
 }
 
 #pragma mark -
-#pragma mark Private methods
+#pragma mark Protected methods
 
 CookieStoreIOS::CookieStoreIOS(
     net::CookieMonster::PersistentCookieStore* persistent_store,
     NSHTTPCookieStorage* system_store)
     : cookie_monster_(new net::CookieMonster(persistent_store, nullptr)),
       system_store_(system_store),
       creation_time_manager_(new CookieCreationTimeManager),
       metrics_enabled_(false),
-      synchronization_state_(NOT_SYNCHRONIZED),
       cookie_cache_(new CookieCache()),
       weak_factory_(this) {
   DCHECK(system_store);
 
   NotificationTrampoline::GetInstance()->AddObserver(this);
 
   cookie_monster_->SetPersistSessionCookies(true);
   cookie_monster_->SetForceKeepSessionState();
 }
 
+CookieStoreIOS::SetCookiesCallback CookieStoreIOS::WrapSetCallback(
+    const SetCookiesCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return base::Bind(&CookieStoreIOS::UpdateCachesAfterSet,
+                    weak_factory_.GetWeakPtr(), callback);
+}
+
+CookieStoreIOS::DeleteCallback CookieStoreIOS::WrapDeleteCallback(
+    const DeleteCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return base::Bind(&CookieStoreIOS::UpdateCachesAfterDelete,
+                    weak_factory_.GetWeakPtr(), callback);
+}
+
+base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
+                    weak_factory_.GetWeakPtr(), callback);
+}
+
+#pragma mark -
+#pragma mark Private methods
+
 void CookieStoreIOS::ClearSystemStore() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::scoped_nsobject<NSArray> copy(
       [[NSArray alloc] initWithArray:[system_store_ cookies]]);
   for (NSHTTPCookie* cookie in copy.get())
     [system_store_ deleteCookie:cookie];
   DCHECK_EQ(0u, [[system_store_ cookies] count]);
   creation_time_manager_->Clear();
 }
 
 bool CookieStoreIOS::SystemCookiesAllowed() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return [system_store_ cookieAcceptPolicy] ==
          NSHTTPCookieAcceptPolicyAlways;
 }
 
 void CookieStoreIOS::WriteToCookieMonster(NSArray* system_cookies) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (synchronization_state_ != SYNCHRONIZED)
+  if (!cookie_monster_->IsEphemeral())

[Eugene But (OOO till 7-30), 2017/01/24 22:31:30]

Conceptually it seems strange to have no-op behavior for Ephemeral cookie
monster. Also I think this changes the logic for case when
CookieStoreIOSPersistent object is created with null persistent_store. Maybe
CookieStoreIOSPersistent::WriteToCookieMonster should be explicitly no-op
instead by implementing that method with the empty body?

[maksims (do not use this acc), 2017/01/27 12:46:36]

Done.

     return;
 
   // Copy the cookies from the global cookie store to |cookie_monster_|.
   // Unlike the system store, CookieMonster requires unique creation times.
   net::CookieList cookie_list;
   NSUInteger cookie_count = [system_cookies count];
   cookie_list.reserve(cookie_count);
   for (NSHTTPCookie* cookie in system_cookies) {
     cookie_list.push_back(CanonicalCookieFromSystemCookie(
         cookie, creation_time_manager_->GetCreationTime(cookie)));
   }
   cookie_monster_->SetAllCookiesAsync(cookie_list, SetCookiesCallback());
 
   // Update metrics.
   if (metrics_enabled_)
     UMA_HISTOGRAM_COUNTS_10000("CookieIOS.CookieWrittenCount", cookie_count);
 }
 
 void CookieStoreIOS::DeleteCookiesWithFilter(const CookieFilterFunction& filter,
                                              const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(SYNCHRONIZED, synchronization_state_);
   NSArray* cookies = [system_store_ cookies];
 
   // Collect the cookies to delete.
   base::scoped_nsobject<NSMutableArray> to_delete(
       [[NSMutableArray alloc] init]);
   for (NSHTTPCookie* cookie in cookies) {
     base::Time creation_time = creation_time_manager_->GetCreationTime(cookie);
     if (filter.Run(cookie, creation_time))
       [to_delete addObject:cookie];
   }
 
   // Delete them.
   for (NSHTTPCookie* cookie in to_delete.get()) {
     [system_store_ deleteCookie:cookie];
     creation_time_manager_->DeleteCreationTime(cookie);
   }
 
   if (!callback.is_null())
     callback.Run([to_delete count]);
 }
 
 void CookieStoreIOS::OnSystemCookiesChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the CookieStoreIOS is not synchronized or is not backed by
   // |NSHTTPCookieStorage sharedHTTPCookieStorage| this callback is irrelevant.
-  if (synchronization_state_ != SYNCHRONIZED ||
+  if (!cookie_monster_->IsEphemeral() ||

[Eugene But (OOO till 7-30), 2017/01/24 22:31:30]

Same question here? Should we make
CookieStoreIOSPersistent::WriteToCookieMonster empty instead?

[maksims (do not use this acc), 2017/01/27 12:46:36]

Done.

       system_store_ != [NSHTTPCookieStorage sharedHTTPCookieStorage]) {
     return;
   }
 
   for (const auto& hook_map_entry : hook_map_) {
     std::pair<GURL, std::string> key = hook_map_entry.first;
     std::vector<net::CanonicalCookie> removed_cookies;
     std::vector<net::CanonicalCookie> added_cookies;
     if (UpdateCacheForCookieFromSystem(key.first, key.second, &removed_cookies,
                                        &added_cookies)) {
@@ skipping 167 matching lines @@
 CookieStoreIOS::CanonicalCookieListFromSystemCookies(NSArray* cookies) {
   net::CookieList cookie_list;
   cookie_list.reserve([cookies count]);
   for (NSHTTPCookie* cookie in cookies) {
     base::Time created = creation_time_manager_->GetCreationTime(cookie);
     cookie_list.push_back(CanonicalCookieFromSystemCookie(cookie, created));
   }
   return cookie_list;
 }
 
-CookieStoreIOS::SetCookiesCallback CookieStoreIOS::WrapSetCallback(
-    const SetCookiesCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterSet,
-                    weak_factory_.GetWeakPtr(), callback);
-}
-
-CookieStoreIOS::DeleteCallback CookieStoreIOS::WrapDeleteCallback(
-    const DeleteCallback& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterDelete,
-                    weak_factory_.GetWeakPtr(), callback);
-}
-
-base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
-                    weak_factory_.GetWeakPtr(), callback);
-}
-
 }  // namespace net