[ios] Removed CookieStoreIOS::UnSynchronize.

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 61 matching lines @@
 // RoundTripTestCookieStore is un-synchronized and re-synchronized after all
 // cookie operations. This means all system cookies are converted to Chrome
 // cookies and converted back.
 // The purpose of this class is to test that cookie conversions do not break the
 // cookie store.
 class RoundTripTestCookieStore : public net::CookieStore {
  public:
   RoundTripTestCookieStore()
       : store_(new CookieStoreIOS(nullptr)),
         dummy_store_(new CookieStoreIOS(nullptr)) {
-    CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+    store_->SetSynchronizedWithSystemStore(true);
   }
 
-  ~RoundTripTestCookieStore() override { store_->UnSynchronize(); }
+  ~RoundTripTestCookieStore() override {
+    store_->SetSynchronizedWithSystemStore(false);
+  }
 
   // Inherited CookieStore methods.
   void SetCookieWithOptionsAsync(const GURL& url,
                                  const std::string& cookie_line,
                                  const net::CookieOptions& options,
                                  const SetCookiesCallback& callback) override {
     RoundTrip();
     store_->SetCookieWithOptionsAsync(url, cookie_line, options, callback);
   }
 
@@ skipping 85 matching lines @@
       const CookieChangedCallback& callback) override {
     return std::unique_ptr<CookieStore::CookieChangedSubscription>();
   }
 
   bool IsEphemeral() override {
     return store_->IsEphemeral();
   }
 
  private:
   void RoundTrip() {
-    CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store_.get());
+    store_->SetSynchronizedWithSystemStore(false);
+    dummy_store_->SetSynchronizedWithSystemStore(true);
     // Check that the system store is empty, because it is synchronized with
     // |dummy_store_| which is empty.
     NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
     EXPECT_EQ(0u, [[store cookies] count]);
-    CookieStoreIOS::SwitchSynchronizedStore(dummy_store_.get(), store_.get());
+    dummy_store_->SetSynchronizedWithSystemStore(false);
+    store_->SetSynchronizedWithSystemStore(true);
   }
 
   std::unique_ptr<CookieStoreIOS> store_;
   // |dummy_store_| is not directly used, but is needed to make |store_|
   // inactive.
   std::unique_ptr<CookieStoreIOS> dummy_store_;
 };
 
 struct RoundTripTestCookieStoreTraits {
   static std::unique_ptr<net::CookieStore> Create() {
@@ skipping 258 matching lines @@
   SetCookie("abc=ghi");
   EXPECT_EQ(3U, cookies_changed_.size());
   EXPECT_EQ(3U, cookies_removed_.size());
   EXPECT_EQ("abc", cookies_changed_[1].Name());
   EXPECT_EQ("def", cookies_changed_[1].Value());
   EXPECT_TRUE(cookies_removed_[1]);
   EXPECT_EQ("abc", cookies_changed_[2].Name());
   EXPECT_EQ("ghi", cookies_changed_[2].Value());
   EXPECT_FALSE(cookies_removed_[2]);
 
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, SetCookieCallsHookWhenSynchronized) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   GetCookies(base::Bind(&IgnoreString));
   backend_->RunLoadedCallback();
   base::RunLoop().RunUntilIdle();
   ClearCookies();
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
   EXPECT_EQ(1U, cookies_removed_.size());
   EXPECT_EQ("abc", cookies_changed_[0].Name());
   EXPECT_EQ("def", cookies_changed_[0].Value());
   EXPECT_FALSE(cookies_removed_[0]);
 
   SetCookie("abc=ghi");
   EXPECT_EQ(3U, cookies_changed_.size());
   EXPECT_EQ(3U, cookies_removed_.size());
   EXPECT_EQ("abc", cookies_changed_[1].Name());
   EXPECT_EQ("def", cookies_changed_[1].Value());
   EXPECT_TRUE(cookies_removed_[1]);
   EXPECT_EQ("abc", cookies_changed_[2].Name());
   EXPECT_EQ("ghi", cookies_changed_[2].Value());
   EXPECT_FALSE(cookies_removed_[2]);
   DeleteSystemCookie(kTestCookieURL, "abc");
 
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, DeleteCallsHook) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   GetCookies(base::Bind(&IgnoreString));
   backend_->RunLoadedCallback();
   base::RunLoop().RunUntilIdle();
   ClearCookies();
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
   EXPECT_EQ(1U, cookies_removed_.size());
   store_->DeleteCookieAsync(kTestCookieURL, "abc",
                             base::Bind(&IgnoreBoolean, false));
   CookieStoreIOS::NotifySystemCookiesChanged();
   base::RunLoop().RunUntilIdle();
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, SameValueDoesNotCallHook) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   GetCookieCallback callback;
   GetCookies(base::Bind(&IgnoreString));
   backend_->RunLoadedCallback();
   base::RunLoop().RunUntilIdle();
   ClearCookies();
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST(CookieStoreIOS, GetAllCookiesForURLAsync) {
   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());
+  cookie_store->SetSynchronizedWithSystemStore(true);
   // Add a cookie.
   net::CookieOptions options;
   options.set_include_httponly();
   cookie_store->SetCookieWithOptionsAsync(
       kTestCookieURL, "a=b", options, net::CookieStore::SetCookiesCallback());
   // Check we can get the cookie.
   GetAllCookiesCallback callback;
   cookie_store->GetAllCookiesForURLAsync(
       kTestCookieURL,
       base::Bind(&GetAllCookiesCallback::Run, base::Unretained(&callback)));
@@ skipping 11 matching lines @@
   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());
+  store_->SetSynchronizedWithSystemStore(true);
   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();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 // 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());
+  store_->SetSynchronizedWithSystemStore(true);
+  store_->SetSynchronizedWithSystemStore(false);
+  dummy_store->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   // No cookie leak in the system store.
   NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   EXPECT_EQ(0u, [[store cookies] count]);
   // No cookie lost.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
-  dummy_store->UnSynchronize();
+  dummy_store->SetSynchronizedWithSystemStore(false);
 }
 
 // Tests that Synchronization can be "aborted" while there are pending tasks
 // (i.e. the cookie store is unsynchronized while synchronization is in progress
 // and there are pending tasks).
 TEST_F(CookieStoreIOSWithBackend, SyncThenUnsyncWithPendingTasks) {
   ClearCookies();
   std::unique_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
   // Start synchornization.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   // Create a pending task while synchronization is in progress.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   // Cancel the synchronization.
-  CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
+  store_->SetSynchronizedWithSystemStore(false);
+  dummy_store->SetSynchronizedWithSystemStore(true);
   // 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();
+  dummy_store->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, UnSynchronizeBeforeLoadComplete) {
   ClearCookies();
   // Switch back and forth before synchronization can complete.
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(true);
+  store_->SetSynchronizedWithSystemStore(false);
   backend_->RunLoadedCallback();
   // No cookie lost.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
 }
 
 TEST_F(CookieStoreIOSWithBackend, UnSynchronize) {
   ClearCookies();
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
   // No cookie lost.
   GetCookieCallback callback;
   GetCookies(base::Bind(&GetCookieCallback::Run, base::Unretained(&callback)));
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("a=b", callback.cookie_line());
 }
 
 TEST_F(CookieStoreIOSWithBackend, FlushOnUnSynchronize) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   EXPECT_FALSE(backend_->flushed());
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
   EXPECT_TRUE(backend_->flushed());
 }
 
-TEST_F(CookieStoreIOSWithBackend, FlushOnSwitch) {
-  std::unique_ptr<CookieStoreIOS> dummy_store(new CookieStoreIOS(nullptr));
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
-  EXPECT_FALSE(backend_->flushed());
-  CookieStoreIOS::SwitchSynchronizedStore(store_.get(), dummy_store.get());
-  EXPECT_TRUE(backend_->flushed());
-  dummy_store->UnSynchronize();
-}
-
 TEST_F(CookieStoreIOSWithBackend, FlushOnCookieChanged) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   store_->set_flush_delay_for_testing(base::TimeDelta());
   backend_->RunLoadedCallback();
   EXPECT_FALSE(backend_->flushed());
 
   // Set a cookie an check that it triggers a flush.
   SetCookie("x=y");
   EXPECT_TRUE(backend_->flushed());
 
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, ManualFlush) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   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();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, NoInitialNotifyWithNoCookie) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   std::vector<net::CanonicalCookie> cookies;
   store_->AddCallbackForCookie(
       kTestCookieURL, "abc",
       base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, NoInitialNotifyWithSystemCookie) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   SetSystemCookie(kTestCookieURL, "abc", "def");
   std::vector<net::CanonicalCookie> cookies;
   store_->AddCallbackForCookie(
       kTestCookieURL, "abc",
       base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, NotifyOnAdd) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<bool> removes;
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, &removes));
   EXPECT_EQ(0U, cookies.size());
   EXPECT_EQ(0U, removes.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ(1U, removes.size());
   EXPECT_EQ("abc", cookies[0].Name());
   EXPECT_EQ("def", cookies[0].Value());
   EXPECT_FALSE(removes[0]);
 
   SetSystemCookie(kTestCookieURL, "ghi", "jkl");
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ(1U, removes.size());
 
   DeleteSystemCookie(kTestCookieURL, "abc");
   DeleteSystemCookie(kTestCookieURL, "ghi");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, NotifyOnChange) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<bool> removes;
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, &removes));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "ghi");
   EXPECT_EQ(3U, cookies.size());
   EXPECT_EQ(3U, removes.size());
   EXPECT_EQ("abc", cookies[1].Name());
   EXPECT_EQ("def", cookies[1].Value());
   EXPECT_TRUE(removes[1]);
   EXPECT_EQ("abc", cookies[2].Name());
   EXPECT_EQ("ghi", cookies[2].Value());
   EXPECT_FALSE(removes[2]);
 
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, NotifyOnDelete) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<bool> removes;
   SetSystemCookie(kTestCookieURL, "abc", "def");
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, &removes));
   EXPECT_EQ(0U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ(1U, removes.size());
   EXPECT_TRUE(removes[0]);
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(2U, cookies.size());
   EXPECT_EQ(2U, removes.size());
   EXPECT_FALSE(removes[1]);
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, NoNotifyOnNoChange) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, MultipleNotifies) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   std::vector<net::CanonicalCookie> cookies2;
   std::vector<net::CanonicalCookie> cookies3;
   std::vector<net::CanonicalCookie> cookies4;
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle2 =
@@ skipping 13 matching lines @@
   SetSystemCookie(kTestCookieURL3, "abc", "def");
   SetSystemCookie(kTestCookieURL4, "abc", "def");
   EXPECT_EQ(2U, cookies.size());
   EXPECT_EQ(2U, cookies2.size());
   EXPECT_EQ(1U, cookies3.size());
   EXPECT_EQ(1U, cookies4.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   DeleteSystemCookie(kTestCookieURL2, "abc");
   DeleteSystemCookie(kTestCookieURL3, "abc");
   DeleteSystemCookie(kTestCookieURL4, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, LessSpecificNestedCookie) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL2, "abc", "def");
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL3, "abc", "ghi");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, MoreSpecificNestedCookie) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL3, "abc", "def");
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL2, "abc", "ghi");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, MoreSpecificNestedCookieWithSameValue) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL3, "abc", "def");
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL2, "abc", "def");
   EXPECT_EQ(1U, cookies.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->UnSynchronize();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 TEST_F(CookieStoreIOSWithBackend, RemoveCallback) {
-  CookieStoreIOS::SwitchSynchronizedStore(nullptr, store_.get());
+  store_->SetSynchronizedWithSystemStore(true);
   backend_->RunLoadedCallback();
   std::vector<net::CanonicalCookie> cookies;
   SetSystemCookie(kTestCookieURL, "abc", "def");
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle =
       store_->AddCallbackForCookie(
           kTestCookieURL, "abc",
           base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
   SetSystemCookie(kTestCookieURL, "abc", "ghi");
   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();
+  store_->SetSynchronizedWithSystemStore(false);
 }
 
 }  // namespace net