Add CookieStoreConfig to unify API for in-memory and persistent CookieStore Creation.

content/browser/net/sqlite_persistent_cookie_store_unittest.cc

 // Copyright (c) 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 "content/browser/net/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 110 matching lines @@
     // resetting the owner (whose destructor blocks on the pool completion).
     pool_owner_->pool()->Shutdown();
     // Create a new pool for the few tests that create multiple stores. In other
     // cases this is wasted but harmless.
     pool_owner_.reset(new base::SequencedWorkerPoolOwner(3, "Background Pool"));
   }
 
   void CreateAndLoad(bool crypt_cookies,
                      bool restore_old_session_cookies,
                      CanonicalCookieVector* cookies) {
+    if (crypt_cookies)
+      cookie_crypto_delegate_.reset(new CookieCryptor());
+
     store_ = new SQLitePersistentCookieStore(
         temp_dir_.path().Append(kCookieFilename),
         client_task_runner(),
         background_task_runner(),
         restore_old_session_cookies,
         NULL,
-        crypt_cookies ?
-            scoped_ptr<content::CookieCryptoDelegate>(new CookieCryptor) :
-            scoped_ptr<content::CookieCryptoDelegate>());
+        cookie_crypto_delegate_.get());
     Load(cookies);
   }
 
   void InitializeStore(bool crypt, bool restore_old_session_cookies) {
     CanonicalCookieVector cookies;
     CreateAndLoad(crypt, restore_old_session_cookies, &cookies);
     EXPECT_EQ(0U, cookies.size());
   }
 
   // We have to create this method to wrap WaitableEvent::Wait, since we cannot
@@ skipping 33 matching lines @@
 
  protected:
   base::MessageLoop main_loop_;
   scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
   base::WaitableEvent loaded_event_;
   base::WaitableEvent key_loaded_event_;
   base::WaitableEvent db_thread_event_;
   CanonicalCookieVector cookies_;
   base::ScopedTempDir temp_dir_;
   scoped_refptr<SQLitePersistentCookieStore> store_;
+  scoped_ptr<content::CookieCryptoDelegate> cookie_crypto_delegate_;
 };
 
 TEST_F(SQLitePersistentCookieStoreTest, TestInvalidMetaTableRecovery) {
   InitializeStore(false, false);
   AddCookie("A", "B", "foo.bar", "/", base::Time::Now());
   DestroyStore();
 
   // Load up the store and verify that it has good data in it.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, false, &cookies);
@@ skipping 66 matching lines @@
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie("A", "B", "travel.aaa.com", "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie("A", "B", "www.bbb.com", "/", t);
   DestroyStore();
 
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.path().Append(kCookieFilename),
       client_task_runner(),
       background_task_runner(),
-      false, NULL,
-      scoped_ptr<content::CookieCryptoDelegate>());
+      false, NULL, NULL);
 
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and LoadCookiesForKey have been posted to its task queue.
   background_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
                  base::Unretained(this)));
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   store_->LoadCookiesForKey("aaa.com",
@@ skipping 307 matching lines @@
   EXPECT_EQ(2, resultcount);
 
   // Verify that "encrypted_value" is NOT visible in the file.
   contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_EQ(contents.find("encrypted_value123XYZ"), std::string::npos);
   EXPECT_EQ(contents.find("something456ABC"), std::string::npos);
 }
 
 }  // namespace content