Divide CookieStoreIOS into two different classes with different backends

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>
 
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
+#import "ios/net/cookies/cookie_store_ios_persistent.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/cookies/cookie_store_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 // Clears the underlying NSHTTPCookieStorage.
 void ClearCookies() {
   NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   [store setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
   NSArray* cookies = [store cookies];
   for (NSHTTPCookie* cookie in cookies)
     [store deleteCookie:cookie];
   EXPECT_EQ(0u, [[store cookies] count]);
 }
 }  // namespace
 
 namespace net {
 
 struct CookieStoreIOSTestTraits {
   static std::unique_ptr<net::CookieStore> Create() {
     ClearCookies();
-    std::unique_ptr<CookieStoreIOS> store(new CookieStoreIOS(nullptr));
-    store->synchronization_state_ = CookieStoreIOS::SYNCHRONIZED;
-    return std::move(store);
+    return base::MakeUnique<CookieStoreIOS>(
+        [NSHTTPCookieStorage sharedHTTPCookieStorage]);
   }
 
   static const bool supports_http_only = false;
   static const bool supports_non_dotted_domains = false;
   static const bool preserves_trailing_dots = false;
   static const bool filters_schemes = false;
   static const bool has_path_prefix_bug = true;
   static const int creation_time_granularity_in_ms = 1000;
 
   base::MessageLoop loop_;
 };
 
 struct InactiveCookieStoreIOSTestTraits {
   static std::unique_ptr<net::CookieStore> Create() {
-    return base::MakeUnique<CookieStoreIOS>(nullptr);
+    return base::MakeUnique<CookieStoreIOSPersistent>(nullptr);
   }
 
   static const bool is_cookie_monster = false;
   static const bool supports_http_only = false;
   static const bool supports_non_dotted_domains = true;
   static const bool preserves_trailing_dots = true;
   static const bool filters_schemes = false;
   static const bool has_path_prefix_bug = false;
   static const int creation_time_granularity_in_ms = 0;
   static const int enforces_prefixes = true;
@@ skipping 157 matching lines @@
 }
 
 // Test fixture to exersize net::CookieStoreIOS created with
 // TestPersistentCookieStore backend and not synchronized with
 // NSHTTPCookieStorage.
 class NotSynchronizedCookieStoreIOSWithBackend : public testing::Test {
  public:
   NotSynchronizedCookieStoreIOSWithBackend()
       : kTestCookieURL("http://foo.google.com/bar"),
         backend_(new TestPersistentCookieStore),
-        store_(new net::CookieStoreIOS(backend_.get())) {
+        store_(base::MakeUnique<net::CookieStoreIOSPersistent>(backend_.get()))
+  {
     cookie_changed_callback_ = store_->AddCallbackForCookie(
         kTestCookieURL, "abc",
         base::Bind(&RecordCookieChanges, &cookies_changed_, &cookies_removed_));
   }
 
   ~NotSynchronizedCookieStoreIOSWithBackend() override {}
 
   // Gets the cookies. |callback| will be called on completion.
   void GetCookies(const net::CookieStore::GetCookiesCallback& callback) {
     net::CookieOptions options;
@@ skipping 22 matching lines @@
 // 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])) {
+        store_(base::MakeUnique<net::CookieStoreIOS>(
+                [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;
@@ skipping 122 matching lines @@
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
   SetCookie("abc=def");
   EXPECT_EQ(1U, cookies_changed_.size());
 }
 
 TEST(CookieStoreIOS, GetAllCookiesForURLAsync) {
   base::MessageLoop loop;
   const GURL kTestCookieURL("http://foo.google.com/bar");
   ClearCookies();
-  std::unique_ptr<CookieStoreIOS> cookie_store(
-      CookieStoreIOS::CreateCookieStore(
-          [NSHTTPCookieStorage sharedHTTPCookieStorage]));
+  std::unique_ptr<CookieStoreIOS> cookie_store(base::MakeUnique<CookieStoreIOS>(
+      [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)));
@@ skipping 199 matching lines @@
   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");
 }
 
 }  // namespace net