Add FlushStore to CookieStore interface.

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 303 matching lines @@
 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.
   CookieStoreIOS* cookie_store = new CookieStoreIOS(nullptr, cookie_storage);
   cookie_store->synchronization_state_ = SYNCHRONIZED;
-  cookie_store->Flush(base::Closure());
+  cookie_store->FlushStore(base::Closure());
   return cookie_store;
 }
 
 // static
 void CookieStoreIOS::SwitchSynchronizedStore(CookieStoreIOS* old_store,
                                              CookieStoreIOS* new_store) {
   DCHECK(new_store);
   DCHECK_NE(new_store, old_store);
   if (old_store)
     old_store->SetSynchronizedWithSystemStore(false);
   new_store->SetSynchronizedWithSystemStore(true);
 }
 
 // static
 void CookieStoreIOS::NotifySystemCookiesChanged() {
   NotificationTrampoline::GetInstance()->NotifyCookiesChanged();
 }
 
-void CookieStoreIOS::Flush(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();
-}
-
 void CookieStoreIOS::UnSynchronize() {
   SetSynchronizedWithSystemStore(false);
 }
 
 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;
@@ skipping 244 matching lines @@
           base::Bind(&CookieStoreIOS::DeleteSessionCookiesAsync, this,
                      WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
       CookieFilterFunction filter = base::Bind(&IsCookieSessionCookie);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
+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 Protected methods
 
 CookieStoreIOS::~CookieStoreIOS() {
   NotificationTrampoline::GetInstance()->RemoveObserver(this);
   STLDeleteContainerPairSecondPointers(hook_map_.begin(), hook_map_.end());
 }
 
 #pragma mark -
 #pragma mark Private methods
@@ skipping 22 matching lines @@
       [system_store_ cookieAcceptPolicy];
   if (policy == NSHTTPCookieAcceptPolicyAlways) {
     // If cookies are disabled, the system cookie store should be empty.
     DCHECK(![[system_store_ cookies] count]);
     DCHECK(synchronization_state_ != SYNCHRONIZING);
     synchronization_state_ = SYNCHRONIZING;
     cookie_monster_->GetAllCookiesAsync(
         base::Bind(&CookieStoreIOS::AddCookiesToSystemStore, this));
   } else {
     DCHECK_EQ(NSHTTPCookieAcceptPolicyNever, policy);
-    // Flush() does not write the cookies to disk when they are disabled.
+    // FlushStore() does not write the cookies to disk when they are disabled.
     // Explicitly copy them.
     WriteToCookieMonster([system_store_ cookies]);
-    Flush(base::Closure());
+    FlushStore(base::Closure());
     ClearSystemStore();
     if (synchronization_state_ == SYNCHRONIZING) {
       // If synchronization was in progress, abort it and leave the cookie store
       // empty.
       // Temporarily toggle the synchronization state so that pending tasks are
       // redirected to cookie_monster_ and can complete normally.
       synchronization_state_ = NOT_SYNCHRONIZED;
       RunAllPendingTasks();
       synchronization_state_ = SYNCHRONIZED;
     }
@@ skipping 31 matching lines @@
   // cookies are re-enabled.
   if (policy == NSHTTPCookieAcceptPolicyAlways) {
     if (synchronized) {
       synchronization_state_ = SYNCHRONIZING;
       ClearSystemStore();
       cookie_monster_->GetAllCookiesAsync(
           base::Bind(&CookieStoreIOS::AddCookiesToSystemStore, this));
       return;
     } else {
       // Copy the cookies from the global store to |cookie_monster_|.
-      Flush(base::Closure());
+      FlushStore(base::Closure());
     }
   }
   synchronization_state_ = synchronized ? SYNCHRONIZED : NOT_SYNCHRONIZED;
 
   if (synchronization_state_ == NOT_SYNCHRONIZED) {
     // If there are pending tasks, then it means that the synchronization is
     // being canceled. All pending tasks can be sent to cookie_monster_.
     RunAllPendingTasks();
   }
 }
@@ skipping 112 matching lines @@
                                        &added_cookies)) {
       RunCallbacksForCookies(key.first, key.second, removed_cookies, true);
       RunCallbacksForCookies(key.first, key.second, added_cookies, false);
     }
   }
 
   // Do not schedule a flush if one is already scheduled.
   if (!flush_closure_.IsCancelled())
     return;
 
-  flush_closure_.Reset(base::Bind(&CookieStoreIOS::Flush,
+  flush_closure_.Reset(base::Bind(&CookieStoreIOS::FlushStore,
                                   base::Unretained(this), base::Closure()));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, flush_closure_.callback(), flush_delay_);
 }
 
 scoped_ptr<net::CookieStore::CookieChangedSubscription>
 CookieStoreIOS::AddCallbackForCookie(const GURL& gurl,
                                      const std::string& name,
                                      const CookieChangedCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 141 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Bind(&CookieStoreIOS::UpdateCachesAfterDelete, this, callback);
 }
 
 base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure, this, callback);
 }
 
 }  // namespace net