[ios] Removed CookieStoreIOS::SetCookiePolicy.

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 43 matching lines @@
 // CookieStoreIOS.
 class NotificationTrampoline {
  public:
   static NotificationTrampoline* GetInstance();
 
   void AddObserver(CookieNotificationObserver* obs);
   void RemoveObserver(CookieNotificationObserver* obs);
 
   // Notify the observers.
   void NotifyCookiesChanged();
-  void NotifyCookiePolicyChanged();
 
  private:
   NotificationTrampoline();
   ~NotificationTrampoline();
 
   base::ObserverList<CookieNotificationObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationTrampoline);
 
   static NotificationTrampoline* g_notification_trampoline;
@@ skipping 13 matching lines @@
 
 void NotificationTrampoline::RemoveObserver(CookieNotificationObserver* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
 void NotificationTrampoline::NotifyCookiesChanged() {
   for (auto& observer : observer_list_)
     observer.OnSystemCookiesChanged();
 }
 
-void NotificationTrampoline::NotifyCookiePolicyChanged() {
-  for (auto& observer : observer_list_)
-    observer.OnSystemCookiePolicyChanged();
-}
-
 NotificationTrampoline::NotificationTrampoline() {
 }
 
 NotificationTrampoline::~NotificationTrampoline() {
 }
 
 // Global instance of NotificationTrampoline.
 NotificationTrampoline* NotificationTrampoline::g_notification_trampoline =
     nullptr;
 
@@ skipping 197 matching lines @@
 
   cookie_monster_->SetPersistSessionCookies(true);
   cookie_monster_->SetForceKeepSessionState();
 }
 
 CookieStoreIOS::~CookieStoreIOS() {
   NotificationTrampoline::GetInstance()->RemoveObserver(this);
 }
 
 // static
-void CookieStoreIOS::SetCookiePolicy(CookiePolicy setting) {
-  NSHTTPCookieAcceptPolicy policy = (setting == ALLOW)
-                                        ? NSHTTPCookieAcceptPolicyAlways
-                                        : NSHTTPCookieAcceptPolicyNever;
-  NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
-  NSHTTPCookieAcceptPolicy current_policy = [store cookieAcceptPolicy];
-  if (current_policy == policy)
-    return;
-  [store setCookieAcceptPolicy:policy];
-  NotificationTrampoline::GetInstance()->NotifyCookiePolicyChanged();
-}
-
-// 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));
@@ skipping 417 matching lines @@
 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();
 }
 
-void CookieStoreIOS::OnSystemCookiePolicyChanged() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // If the CookieStoreIOS is not synchronized or is not backed by
-  // |NSHTTPCookieStorage sharedHTTPCookieStorage| this callback is irrelevant.
-  if (synchronization_state_ == NOT_SYNCHRONIZED ||
-      system_store_ != [NSHTTPCookieStorage sharedHTTPCookieStorage]) {
-    return;
-  }
-
-  NSHTTPCookieAcceptPolicy policy =
-      [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, weak_factory_.GetWeakPtr()));
-  } else {
-    DCHECK_EQ(NSHTTPCookieAcceptPolicyNever, policy);
-    // FlushStore() does not write the cookies to disk when they are disabled.
-    // Explicitly copy them.
-    WriteToCookieMonster([system_store_ cookies]);
-    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;
-    }
-  }
-}
-
 void CookieStoreIOS::SetSynchronizedWithSystemStore(bool synchronized) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (synchronized == (synchronization_state_ != NOT_SYNCHRONIZED))
     return;  // The cookie store is already in the desired state.
 
 #if !defined(NDEBUG)
   if (!synchronized) {
     DCHECK_EQ(this, g_current_synchronized_store)
         << "This cookie store was not synchronized";
@@ skipping 341 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