[ios] Removed CookieStoreIOS::SetCookiePolicy.

ios/net/cookies/cookie_store_ios_unittest.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 <memory>
 
@@ skipping 355 matching lines @@
 
 class CookieStoreIOSWithBackend : public testing::Test {
  public:
   CookieStoreIOSWithBackend()
       : kTestCookieURL("http://foo.google.com/bar"),
         kTestCookieURL2("http://foo.google.com/baz"),
         kTestCookieURL3("http://foo.google.com"),
         kTestCookieURL4("http://bar.google.com/bar"),
         backend_(new TestPersistentCookieStore),
         store_(new net::CookieStoreIOS(backend_.get())) {
-    net::CookieStoreIOS::SetCookiePolicy(net::CookieStoreIOS::ALLOW);
     cookie_changed_callback_ = store_->AddCallbackForCookie(
         kTestCookieURL, "abc",
         base::Bind(&RecordCookieChanges, &cookies_changed_, &cookies_removed_));
   }
 
   ~CookieStoreIOSWithBackend() override {}
 
   // Gets the cookies. |callback| will be called on completion.
   void GetCookies(const net::CookieStore::GetCookiesCallback& callback) {
     net::CookieOptions options;
@@ skipping 150 matching lines @@
   base::MessageLoop loop;
   const GURL kTestCookieURL("http://foo.google.com/bar");
   ClearCookies();
   std::unique_ptr<CookieStoreIOS> cookie_store(new CookieStoreIOS(nullptr));
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, cookie_store.get());
   // Add a cookie.
   net::CookieOptions options;
   options.set_include_httponly();
   cookie_store->SetCookieWithOptionsAsync(
       kTestCookieURL, "a=b", options, net::CookieStore::SetCookiesCallback());
-  // Disallow cookies.
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
-  // No cookie in the system store.
-  NSHTTPCookieStorage* system_store =
-      [NSHTTPCookieStorage sharedHTTPCookieStorage];
-  EXPECT_EQ(0u, [[system_store cookies] count]);
-  // Flushing should not have any effect.
-  cookie_store->FlushStore(base::Closure());
-  // Check we can get the cookie even though cookies are disabled.
+  // Check we can get the cookie.
   GetAllCookiesCallback callback;
   cookie_store->GetAllCookiesForURLAsync(
       kTestCookieURL,
       base::Bind(&GetAllCookiesCallback::Run, base::Unretained(&callback)));
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1u, callback.cookie_list().size());
   net::CanonicalCookie cookie = callback.cookie_list()[0];
   EXPECT_EQ("a", cookie.Name());
   EXPECT_EQ("b", cookie.Value());
-  // Re-enable cookies.
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::ALLOW);
-  // Cookie is back in the system store.
-  EXPECT_EQ(1u, [[system_store cookies] count]);
-  cookie_store->UnSynchronize();
 }
 
 // Tests that cookies can be read before the backend is loaded.
 TEST_F(CookieStoreIOSWithBackend, NotSynchronized) {
   // Start fetching the cookie.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   // Backend loading completes.
   backend_->RunLoadedCallback();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
 }
 
 // Tests that cookies can be read before synchronization is complete.
 TEST_F(CookieStoreIOSWithBackend, Synchronizing) {
   // Start synchronization.
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   // Backend loading completes (end of synchronization).
   backend_->RunLoadedCallback();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
   store_->UnSynchronize();
 }
 
-// Tests that cookies can be read before synchronization is complete, when
-// triggered by a change in cookie policy.
-TEST_F(CookieStoreIOSWithBackend, SynchronizingAfterPolicyChange) {
-  ClearCookies();
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
-  // SwitchSynchronizedStore() does nothing when cookies are blocked.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  // Start synchronization by allowing cookies.
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::ALLOW);
-  GetCookieCallback callback;
-  GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
-  // Backend loading completes (end of synchronization).
-  backend_->RunLoadedCallback();
-  EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ("a=b", callback.cookie_line());
-  store_->UnSynchronize();
-}
-
 // Tests that Synchronization can be "aborted" (i.e. the cookie store is
 // unsynchronized while synchronization is in progress).
 TEST_F(CookieStoreIOSWithBackend, SyncThenUnsync) {
   ClearCookies();
   std::unique_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
   // Switch back and forth before synchronization can complete.
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
   backend_->RunLoadedCallback();
   // No cookie leak in the system store.
@@ skipping 21 matching lines @@
   // Cancel the synchronization.
   CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
   // Synchronization completes after being cancelled.
   backend_->RunLoadedCallback();
   // The task is not lost.
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
   dummy_store->UnSynchronize();
 }
 
-TEST_F(CookieStoreIOSWithBackend, ChangePolicyOnceDuringSynchronization) {
-  // Start synchronization.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  // Toggle cookie policy to trigger another synchronization while the first one
-  // is still in progress.
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
-  // Backend loading completes (end of synchronization).
-  backend_->RunLoadedCallback();
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::ALLOW);
-  GetCookieCallback callback;
-  GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
-  EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ("a=b", callback.cookie_line());
-  store_->UnSynchronize();
-}
-
-TEST_F(CookieStoreIOSWithBackend,
-       ChangePolicyDuringSynchronizationWithPendingTask) {
-  // Start synchronization.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  // Create a pending task while synchronization is in progress.
-  GetCookieCallback callback;
-  GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
-  // Toggle cookie policy to trigger another synchronization while the first one
-  // is still in progress.
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
-  // Backend loading completes (end of synchronization).
-  backend_->RunLoadedCallback();
-  EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ("a=b", callback.cookie_line());
-  store_->UnSynchronize();
-}
-
-TEST_F(CookieStoreIOSWithBackend, ChangePolicyTwiceDuringSynchronization) {
-  // Start synchronization.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  // Toggle cookie policy to trigger another synchronization while the first one
-  // is still in progress.
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::ALLOW);
-  // Backend loading completes (end of synchronization).
-  backend_->RunLoadedCallback();
-  GetCookieCallback callback;
-  GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
-  EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ("a=b", callback.cookie_line());
-  store_->UnSynchronize();
-}
-
 TEST_F(CookieStoreIOSWithBackend, UnSynchronizeBeforeLoadComplete) {
   ClearCookies();
   // Switch back and forth before synchronization can complete.
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   store_->UnSynchronize();
   backend_->RunLoadedCallback();
   // No cookie lost.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   EXPECT_TRUE(callback.did_run());
@@ skipping 46 matching lines @@
   backend_->RunLoadedCallback();
   EXPECT_FALSE(backend_->flushed());
 
   // The store should be flushed even if it is not dirty.
   store_->FlushStore(base::Closure());
   EXPECT_TRUE(backend_->flushed());
 
   store_->UnSynchronize();
 }
 
-TEST_F(CookieStoreIOSWithBackend, FlushOnPolicyChange) {
-  // Start synchronization.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  // Toggle cookie policy to trigger a flush.
-  EXPECT_FALSE(backend_->flushed());
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::BLOCK);
-  EXPECT_TRUE(backend_->flushed());
-  store_->UnSynchronize();
-  CookieStoreIOS::SetCookiePolicy(CookieStoreIOS::ALLOW);
-}
-
 TEST_F(CookieStoreIOSWithBackend, NoInitialNotifyWithNoCookie) {
   CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
   std::vector<net::CanonicalCookie> cookies;
   store_->AddCallbackForCookie(
       kTestCookieURL, "abc",
       base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   store_->UnSynchronize();
 }
 
@@ skipping 202 matching lines @@
   EXPECT_EQ(2U, cookies.size());
   // this deletes the callback
   handle.reset();
   SetSystemCookie(kTestCookieURL, "abc", "jkl");
   EXPECT_EQ(2U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   store_->UnSynchronize();
 }
 
 }  // namespace net