[ios] Removed CookieStoreIOS::SynchronizationState::SYNCHRONIZING.

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 310 matching lines @@
     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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::SetCookieWithOptionsAsync,
-                     weak_factory_.GetWeakPtr(), 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());
 
       base::Time server_time =
           options.has_server_time() ? options.server_time() : base::Time();
@@ skipping 52 matching lines @@
     const SetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->SetCookieWithDetailsAsync(
           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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::SetCookieWithDetailsAsync,
-                     weak_factory_.GetWeakPtr(), 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());
 
       bool success = false;
 
       if (creation_time.is_null())
         creation_time = base::Time::Now();
 
@@ skipping 26 matching lines @@
 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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::GetCookiesWithOptionsAsync,
-                     weak_factory_.GetWeakPtr(), 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());
 
       // 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;
   }
 }
 
 void CookieStoreIOS::GetCookieListWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
     const GetCookieListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
       break;
-    case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::GetCookieListWithOptionsAsync,
-                     weak_factory_.GetWeakPtr(), 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;
   }
 }
 
 void CookieStoreIOS::GetAllCookiesAsync(const GetCookieListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->GetAllCookiesAsync(callback);
       break;
-    case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::GetAllCookiesAsync,
-                     weak_factory_.GetWeakPtr(), 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;
       }
 
       NSArray* cookies = GetAllCookies(system_store_,
                                        creation_time_manager_.get());
       net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(
           cookies);
       if (!callback.is_null()) {
         callback.Run(cookie_list);
       }
       break;
   }
 }
 
 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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(base::Bind(
-          &CookieStoreIOS::DeleteCookieAsync, weak_factory_.GetWeakPtr(), 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;
   }
 }
 
 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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(base::Bind(
-          &CookieStoreIOS::DeleteCanonicalCookieAsync,
-          weak_factory_.GetWeakPtr(), 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);
   }
 }
 
 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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenAsync,
-                     weak_factory_.GetWeakPtr(), delete_begin, delete_end,
-                     WrapDeleteCallback(callback)));
-      break;
     case SYNCHRONIZED:
       CookieFilterFunction filter =
           base::Bind(&IsCookieCreatedBetween, delete_begin, delete_end);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
 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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenWithPredicateAsync,
-                     weak_factory_.GetWeakPtr(), delete_begin, delete_end,
-                     predicate, WrapDeleteCallback(callback)));
-      break;
     case SYNCHRONIZED:
       CookieFilterFunction filter =
           base::Bind(IsCookieCreatedBetweenWithPredicate, delete_begin,
                      delete_end, predicate);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
 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 SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteSessionCookiesAsync,
-                     weak_factory_.GetWeakPtr(), 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());
 
@@ skipping 297 matching lines @@
                     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