[ios] Do not use SetSynchronizedWithSystemStore in tests.

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 192 matching lines @@
 }
 
 void IgnoreBoolean(bool ignored) {
 }
 
 void IgnoreString(const std::string& ignored) {
 }
 
 }  // namespace
 
-class CookieStoreIOSWithBackend : public testing::Test {
+// Sets a cookie.
+void SetCookie(const std::string& cookie_line,
+               const GURL& url,
+               net::CookieStore* store) {
+  net::CookieOptions options;
+  options.set_include_httponly();
+  store->SetCookieWithOptionsAsync(url, cookie_line, options,
+                                   base::Bind(&IgnoreBoolean));
+  net::CookieStoreIOS::NotifySystemCookiesChanged();
+  // Wait until the flush is posted.
+  base::RunLoop().RunUntilIdle();
+}
+
+// Test fixture to exersize net::CookieStoreIOS created with
+// TestPersistentCookieStore backend and not synchronized with
+// NSHTTPCookieStorage.
+class NotSynchronizedCookieStoreIOSWithBackend : public testing::Test {
  public:
-  CookieStoreIOSWithBackend()
+  NotSynchronizedCookieStoreIOSWithBackend()
       : 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())) {
     cookie_changed_callback_ = store_->AddCallbackForCookie(
         kTestCookieURL, "abc",
         base::Bind(&RecordCookieChanges, &cookies_changed_, &cookies_removed_));
   }
 
-  ~CookieStoreIOSWithBackend() override {}
+  ~NotSynchronizedCookieStoreIOSWithBackend() override {}
 
   // Gets the cookies. |callback| will be called on completion.
   void GetCookies(const net::CookieStore::GetCookiesCallback& callback) {
     net::CookieOptions options;
     options.set_include_httponly();
     store_->GetCookiesWithOptionsAsync(kTestCookieURL, options, callback);
   }
 
   // Sets a cookie.
   void SetCookie(const std::string& cookie_line) {
+    ::SetCookie(cookie_line, kTestCookieURL, store_.get());
+  }
+
+ private:
+  const GURL kTestCookieURL;
+
+ protected:
+  base::MessageLoop loop_;
+  scoped_refptr<TestPersistentCookieStore> backend_;
+  std::unique_ptr<net::CookieStoreIOS> store_;
+  std::unique_ptr<net::CookieStore::CookieChangedSubscription>
+      cookie_changed_callback_;
+  std::vector<net::CanonicalCookie> cookies_changed_;
+  std::vector<bool> cookies_removed_;
+};
+
+// Test fixture to exersize net::CookieStoreIOS created without backend and
+// synchronized with |[NSHTTPCookieStorage sharedHTTPCookieStorage]|.
+class SynchronizedCookieStoreIOS : public testing::Test {
+ public:
+  SynchronizedCookieStoreIOS()
+      : 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_(net::CookieStoreIOS::CreateCookieStore(
+            [NSHTTPCookieStorage sharedHTTPCookieStorage])) {
+    cookie_changed_callback_ = store_->AddCallbackForCookie(
+        kTestCookieURL, "abc",
+        base::Bind(&RecordCookieChanges, &cookies_changed_, &cookies_removed_));
+  }
+
+  ~SynchronizedCookieStoreIOS() override {}
+
+  // Gets the cookies. |callback| will be called on completion.
+  void GetCookies(const net::CookieStore::GetCookiesCallback& callback) {
     net::CookieOptions options;
     options.set_include_httponly();
-    store_->SetCookieWithOptionsAsync(kTestCookieURL, cookie_line, options,
-                                      base::Bind(&IgnoreBoolean));
-    net::CookieStoreIOS::NotifySystemCookiesChanged();
-    // Wait until the flush is posted.
-    base::RunLoop().RunUntilIdle();
+    store_->GetCookiesWithOptionsAsync(kTestCookieURL, options, callback);
+  }
+
+  // Sets a cookie.
+  void SetCookie(const std::string& cookie_line) {
+    ::SetCookie(cookie_line, kTestCookieURL, store_.get());
   }
 
   void SetSystemCookie(const GURL& url,
                        const std::string& name,
                        const std::string& value) {
     NSHTTPCookieStorage* storage =
         [NSHTTPCookieStorage sharedHTTPCookieStorage];
     [storage setCookie:[NSHTTPCookie cookieWithProperties:@{
       NSHTTPCookiePath : base::SysUTF8ToNSString(url.path()),
       NSHTTPCookieName : base::SysUTF8ToNSString(name),
@@ skipping 31 matching lines @@
   std::unique_ptr<net::CookieStore::CookieChangedSubscription>
       cookie_changed_callback_;
   std::vector<net::CanonicalCookie> cookies_changed_;
   std::vector<bool> cookies_removed_;
 };
 
 }  // namespace
 
 namespace net {
 
-TEST_F(CookieStoreIOSWithBackend, SetCookieCallsHookWhenNotSynchronized) {
+TEST_F(NotSynchronizedCookieStoreIOSWithBackend, SetCookieCallsHook) {
   ClearCookies();
   SetCookie("abc=def");
   EXPECT_EQ(0U, cookies_changed_.size());
   EXPECT_EQ(0U, cookies_removed_.size());
   backend_->RunLoadedCallback();
   base::RunLoop().RunUntilIdle();
   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]);
 
   // Replacing an existing cookie is actually a two-phase delete + set
   // operation, so we get an extra notification.
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, SetCookieCallsHookWhenSynchronized) {
-  store_->SetSynchronizedWithSystemStore(true);
+TEST_F(SynchronizedCookieStoreIOS, SetCookieCallsHookWhenSynchronized) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, DeleteCallsHook) {
-  store_->SetSynchronizedWithSystemStore(true);
+TEST_F(SynchronizedCookieStoreIOS, DeleteCallsHook) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, SameValueDoesNotCallHook) {
-  store_->SetSynchronizedWithSystemStore(true);
+TEST_F(SynchronizedCookieStoreIOS, SameValueDoesNotCallHook) {
   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_->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));
-  cookie_store->SetSynchronizedWithSystemStore(true);
+  std::unique_ptr<CookieStoreIOS> cookie_store(
+      CookieStoreIOS::CreateCookieStore(
+          [NSHTTPCookieStorage sharedHTTPCookieStorage]));
   // 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)));
   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());
 }
 
 // Tests that cookies can be read before the backend is loaded.
-TEST_F(CookieStoreIOSWithBackend, NotSynchronized) {
+TEST_F(NotSynchronizedCookieStoreIOSWithBackend, 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.
-  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_->SetSynchronizedWithSystemStore(false);
-}
-
-TEST_F(CookieStoreIOSWithBackend, FlushOnCookieChanged) {
-  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_->SetSynchronizedWithSystemStore(false);
-}
-
-TEST_F(CookieStoreIOSWithBackend, ManualFlush) {
-  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_->SetSynchronizedWithSystemStore(false);
-}
-
-TEST_F(CookieStoreIOSWithBackend, NoInitialNotifyWithNoCookie) {
-  store_->SetSynchronizedWithSystemStore(true);
+TEST_F(SynchronizedCookieStoreIOS, NoInitialNotifyWithNoCookie) {
   std::vector<net::CanonicalCookie> cookies;
   store_->AddCallbackForCookie(
       kTestCookieURL, "abc",
       base::Bind(&RecordCookieChanges, &cookies, nullptr));
   EXPECT_EQ(0U, cookies.size());
-  store_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, NoInitialNotifyWithSystemCookie) {
-  store_->SetSynchronizedWithSystemStore(true);
+TEST_F(SynchronizedCookieStoreIOS, NoInitialNotifyWithSystemCookie) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, NotifyOnAdd) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, NotifyOnAdd) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, NotifyOnChange) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, NotifyOnChange) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, NotifyOnDelete) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, NotifyOnDelete) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, NoNotifyOnNoChange) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, NoNotifyOnNoChange) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, MultipleNotifies) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, MultipleNotifies) {
   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 =
       store_->AddCallbackForCookie(
           kTestCookieURL2, "abc",
           base::Bind(&RecordCookieChanges, &cookies2, nullptr));
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle3 =
       store_->AddCallbackForCookie(
           kTestCookieURL3, "abc",
           base::Bind(&RecordCookieChanges, &cookies3, nullptr));
   std::unique_ptr<net::CookieStore::CookieChangedSubscription> handle4 =
       store_->AddCallbackForCookie(
           kTestCookieURL4, "abc",
           base::Bind(&RecordCookieChanges, &cookies4, nullptr));
   SetSystemCookie(kTestCookieURL, "abc", "def");
   SetSystemCookie(kTestCookieURL2, "abc", "def");
   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, cookies.size());

[Eugene But (OOO till 7-30), 2016/12/28 19:34:23]

Synchronized CookieStoreIOS works differently if created without backend.
Testing synchronized CookieStoreIOS with backend does not make any sense,
because this configuration is not used in prod. However I'm not sure why
callbacks now return different cookie set. Mark, do you think I should file bug
for these tests or the change is expected?

[marq (ping after 24h), 2016/12/30 09:24:38]

I don't know these interfaces well at all, so I would treat a change in behavior
as a bug. 

+  EXPECT_EQ(1U, cookies2.size());
+  EXPECT_EQ(0U, cookies3.size());
   EXPECT_EQ(1U, cookies4.size());
   DeleteSystemCookie(kTestCookieURL, "abc");
   DeleteSystemCookie(kTestCookieURL2, "abc");
   DeleteSystemCookie(kTestCookieURL3, "abc");
   DeleteSystemCookie(kTestCookieURL4, "abc");
-  store_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, LessSpecificNestedCookie) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, LessSpecificNestedCookie) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, MoreSpecificNestedCookie) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, MoreSpecificNestedCookie) {
   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());
+  EXPECT_EQ(2U, cookies.size());

[Eugene But (OOO till 7-30), 2016/12/28 19:34:23]

Same change here

   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, MoreSpecificNestedCookieWithSameValue) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, MoreSpecificNestedCookieWithSameValue) {
   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());
+  EXPECT_EQ(2U, cookies.size());

[Eugene But (OOO till 7-30), 2016/12/28 19:34:23]

And here...

   DeleteSystemCookie(kTestCookieURL, "abc");
-  store_->SetSynchronizedWithSystemStore(false);
 }
 
-TEST_F(CookieStoreIOSWithBackend, RemoveCallback) {
-  store_->SetSynchronizedWithSystemStore(true);
-  backend_->RunLoadedCallback();
+TEST_F(SynchronizedCookieStoreIOS, RemoveCallback) {
   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_->SetSynchronizedWithSystemStore(false);
 }
 
 }  // namespace net