Moves SQLitePersistentCookieStore to net/extras/sqlite.

The application of special storage policy is split out into a new class,
QuotaPolicyCookieStore, in content/browser/net.

BUG=467596
TEST=No visible impact.

Review URL: https://codereview.chromium.org/1016643004

Cr-Commit-Position: refs/heads/master@{#329950}

content/browser/BUILD.gn

@@ -34,6 +34,7 @@ source_set("browser") {
     "//device/vibration",
     "//google_apis",
     "//net",
+    "//net:extras",
     "//skia",
     "//sql",
     "//third_party/npapi",

content/browser/net/quota_policy_cookie_store.cc

+// Copyright 2015 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/quota_policy_cookie_store.h"
+
+#include <list>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/profiler/scoped_tracker.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/cookie_store_factory.h"
+#include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_constants.h"
+#include "net/cookies/cookie_util.h"
+#include "net/extras/sqlite/cookie_crypto_delegate.h"
+#include "storage/browser/quota/special_storage_policy.h"
+#include "url/gurl.h"
+
+namespace content {
+
+QuotaPolicyCookieStore::QuotaPolicyCookieStore(
+    const scoped_refptr<net::SQLitePersistentCookieStore>& cookie_store,
+    storage::SpecialStoragePolicy* special_storage_policy)
+    : special_storage_policy_(special_storage_policy),
+      persistent_store_(cookie_store) {
+}
+
+QuotaPolicyCookieStore::~QuotaPolicyCookieStore() {
+  if (!special_storage_policy_.get() ||
+      !special_storage_policy_->HasSessionOnlyOrigins()) {
+    return;
+  }
+
+  std::list<net::SQLitePersistentCookieStore::CookieOrigin>
+      session_only_cookies;
+  for (const auto& cookie : cookies_per_origin_) {
+    if (cookie.second == 0) {
+      continue;
+    }
+    const GURL url(net::cookie_util::CookieOriginToURL(cookie.first.first,
+                                                       cookie.first.second));
+    if (!url.is_valid() || !special_storage_policy_->IsStorageSessionOnly(url))
+      continue;
+
+    session_only_cookies.push_back(cookie.first);
+  }
+
+  persistent_store_->DeleteAllInList(session_only_cookies);
+}
+
+void QuotaPolicyCookieStore::Load(const LoadedCallback& loaded_callback) {
+  persistent_store_->Load(
+      base::Bind(&QuotaPolicyCookieStore::OnLoad, this, loaded_callback));
+}
+
+void QuotaPolicyCookieStore::LoadCookiesForKey(
+    const std::string& key,
+    const LoadedCallback& loaded_callback) {
+  persistent_store_->LoadCookiesForKey(
+      key,
+      base::Bind(&QuotaPolicyCookieStore::OnLoad, this, loaded_callback));
+}
+
+void QuotaPolicyCookieStore::AddCookie(const net::CanonicalCookie& cc) {
+  net::SQLitePersistentCookieStore::CookieOrigin origin(
+      cc.Domain(), cc.IsSecure());
+  ++cookies_per_origin_[origin];
+  persistent_store_->AddCookie(cc);
+}
+
+void QuotaPolicyCookieStore::UpdateCookieAccessTime(
+    const net::CanonicalCookie& cc) {
+  persistent_store_->UpdateCookieAccessTime(cc);
+}
+
+void QuotaPolicyCookieStore::DeleteCookie(const net::CanonicalCookie& cc) {
+  net::SQLitePersistentCookieStore::CookieOrigin origin(
+      cc.Domain(), cc.IsSecure());
+  DCHECK_GE(cookies_per_origin_[origin], 1U);
+  --cookies_per_origin_[origin];
+  persistent_store_->DeleteCookie(cc);
+}
+
+void QuotaPolicyCookieStore::SetForceKeepSessionState() {
+  special_storage_policy_ = nullptr;
+}
+
+void QuotaPolicyCookieStore::Flush(const base::Closure& callback) {
+  persistent_store_->Flush(callback);
+}
+
+void QuotaPolicyCookieStore::OnLoad(
+    const LoadedCallback& loaded_callback,
+    const std::vector<net::CanonicalCookie*>& cookies) {
+  for (const auto& cookie : cookies) {
+    net::SQLitePersistentCookieStore::CookieOrigin origin(
+        cookie->Domain(), cookie->IsSecure());
+    ++cookies_per_origin_[origin];
+  }
+
+  loaded_callback.Run(cookies);
+}
+
+CookieStoreConfig::CookieStoreConfig()
+  : session_cookie_mode(EPHEMERAL_SESSION_COOKIES),
+    crypto_delegate(nullptr) {
+  // Default to an in-memory cookie store.
+}
+
+CookieStoreConfig::CookieStoreConfig(
+    const base::FilePath& path,
+    SessionCookieMode session_cookie_mode,
+    storage::SpecialStoragePolicy* storage_policy,
+    net::CookieMonsterDelegate* cookie_delegate)
+    : path(path),
+      session_cookie_mode(session_cookie_mode),
+      storage_policy(storage_policy),
+      cookie_delegate(cookie_delegate),
+      crypto_delegate(nullptr) {
+  CHECK(!path.empty() || session_cookie_mode == EPHEMERAL_SESSION_COOKIES);
+}
+
+CookieStoreConfig::~CookieStoreConfig() {
+}
+
+net::CookieStore* CreateCookieStore(const CookieStoreConfig& config) {
+  // TODO(bcwhite): Remove ScopedTracker below once crbug.com/483686 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("483686 content::CreateCookieStore"));
+
+  net::CookieMonster* cookie_monster = nullptr;
+
+  if (config.path.empty()) {
+    // Empty path means in-memory store.
+    cookie_monster = new net::CookieMonster(nullptr,
+                                            config.cookie_delegate.get());
+  } else {
+    scoped_refptr<base::SequencedTaskRunner> client_task_runner =
+        config.client_task_runner;
+    scoped_refptr<base::SequencedTaskRunner> background_task_runner =
+        config.background_task_runner;
+
+    if (!client_task_runner.get()) {
+      client_task_runner =
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
+    }
+
+    if (!background_task_runner.get()) {
+      background_task_runner =
+          BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
+              BrowserThread::GetBlockingPool()->GetSequenceToken());
+    }
+
+    scoped_refptr<net::SQLitePersistentCookieStore> sqlite_store(
+        new net::SQLitePersistentCookieStore(
+            config.path,
+            client_task_runner,
+            background_task_runner,
+            (config.session_cookie_mode ==
+             CookieStoreConfig::RESTORED_SESSION_COOKIES),
+            config.crypto_delegate));
+
+    QuotaPolicyCookieStore* persistent_store =
+        new QuotaPolicyCookieStore(
+            sqlite_store.get(),
+            config.storage_policy.get());
+
+    cookie_monster =
+        new net::CookieMonster(persistent_store, config.cookie_delegate.get());
+    if ((config.session_cookie_mode ==
+         CookieStoreConfig::PERSISTANT_SESSION_COOKIES) ||
+        (config.session_cookie_mode ==
+         CookieStoreConfig::RESTORED_SESSION_COOKIES)) {
+      cookie_monster->SetPersistSessionCookies(true);
+    }
+  }
+
+  return cookie_monster;
+}
+
+}  // namespace content

content/browser/net/quota_policy_cookie_store.h

+// Copyright 2015 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.
+
+#ifndef CONTENT_BROWSER_NET_QUOTA_POLICY_COOKIE_STORE_H_
+#define CONTENT_BROWSER_NET_QUOTA_POLICY_COOKIE_STORE_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "content/common/content_export.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/extras/sqlite/sqlite_persistent_cookie_store.h"
+
+class Task;
+
+namespace base {
+class FilePath;
+class SequencedTaskRunner;
+}  // namespace base
+
+namespace net {
+class CanonicalCookie;
+class CookieCryptoDelegate;
+}  // namespace net
+
+namespace storage {
+class SpecialStoragePolicy;
+}  // namespace storage
+
+namespace content {
+
+// Implements a PersistentCookieStore that deletes session cookies on
+// shutdown. For documentation about the actual member functions consult the
+// parent class |net::CookieMonster::PersistentCookieStore|. If provided, a
+// |SpecialStoragePolicy| is consulted when the SQLite database is closed to
+// decide which cookies to keep.
+class CONTENT_EXPORT QuotaPolicyCookieStore
+    : public net::CookieMonster::PersistentCookieStore {
+ public:
+  // Wraps the passed-in |cookie_store|.
+  QuotaPolicyCookieStore(
+      const scoped_refptr<net::SQLitePersistentCookieStore>& cookie_store,
+      storage::SpecialStoragePolicy* special_storage_policy);
+
+  // net::CookieMonster::PersistentCookieStore:
+  void Load(const LoadedCallback& loaded_callback) override;
+  void LoadCookiesForKey(const std::string& key,
+                         const LoadedCallback& callback) override;
+  void AddCookie(const net::CanonicalCookie& cc) override;
+  void UpdateCookieAccessTime(const net::CanonicalCookie& cc) override;
+  void DeleteCookie(const net::CanonicalCookie& cc) override;
+  void SetForceKeepSessionState() override;
+  void Flush(const base::Closure& callback) override;
+
+ private:
+  typedef std::map<net::SQLitePersistentCookieStore::CookieOrigin, size_t>
+      CookiesPerOriginMap;
+
+  ~QuotaPolicyCookieStore() override;
+
+  // Called after cookies are loaded from the database.  Calls |loaded_callback|
+  // when done.
+  void OnLoad(const LoadedCallback& loaded_callback,
+              const std::vector<net::CanonicalCookie*>& cookies);
+
+  // Map of (domain keys(eTLD+1), is secure cookie) to number of cookies in the
+  // database.
+  CookiesPerOriginMap cookies_per_origin_;
+
+  scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
+  scoped_refptr<net::SQLitePersistentCookieStore> persistent_store_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuotaPolicyCookieStore);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_NET_QUOTA_POLICY_COOKIE_STORE_H_

content/browser/net/quota_policy_cookie_store_unittest.cc

+// Copyright 2015 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 "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_vector.h"
+#include "base/run_loop.h"
+#include "base/stl_util.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/time/time.h"
+#include "content/browser/net/quota_policy_cookie_store.h"
+#include "content/public/test/mock_special_storage_policy.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "net/base/test_data_directory.h"
+#include "net/cookies/cookie_util.h"
+#include "net/ssl/ssl_client_cert_type.h"
+#include "net/test/cert_test_util.h"
+#include "sql/statement.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+const base::FilePath::CharType kTestCookiesFilename[] =
+    FILE_PATH_LITERAL("Cookies");
+}
+
+namespace content {
+namespace {
+
+typedef std::vector<net::CanonicalCookie*> CanonicalCookieVector;
+
+class QuotaPolicyCookieStoreTest : public testing::Test {
+ public:
+  QuotaPolicyCookieStoreTest()
+      : pool_owner_(new base::SequencedWorkerPoolOwner(3, "Background Pool")),
+        loaded_event_(false, false) {
+  }
+
+  void OnLoaded(const CanonicalCookieVector& cookies) {
+    cookies_ = cookies;
+    loaded_event_.Signal();
+  }
+
+  void Load(CanonicalCookieVector* cookies) {
+    EXPECT_FALSE(loaded_event_.IsSignaled());
+    store_->Load(base::Bind(&QuotaPolicyCookieStoreTest::OnLoaded,
+                            base::Unretained(this)));
+    loaded_event_.Wait();
+    *cookies = cookies_;
+  }
+
+ protected:
+  scoped_refptr<base::SequencedTaskRunner> background_task_runner() {
+    return pool_owner_->pool()->GetSequencedTaskRunner(
+        pool_owner_->pool()->GetNamedSequenceToken("background"));
+  }
+
+  scoped_refptr<base::SequencedTaskRunner> client_task_runner() {
+    return pool_owner_->pool()->GetSequencedTaskRunner(
+        pool_owner_->pool()->GetNamedSequenceToken("client"));
+  }
+
+  void CreateAndLoad(storage::SpecialStoragePolicy* storage_policy,
+                     CanonicalCookieVector* cookies) {
+    scoped_refptr<net::SQLitePersistentCookieStore> sqlite_store(
+        new net::SQLitePersistentCookieStore(
+            temp_dir_.path().Append(kTestCookiesFilename),
+            client_task_runner(),
+            background_task_runner(),
+            true, nullptr));
+    store_ = new QuotaPolicyCookieStore(sqlite_store.get(), storage_policy);
+    Load(cookies);
+  }
+
+  // Adds a persistent cookie to store_.
+  void AddCookie(const std::string& name,
+                 const std::string& value,
+                 const std::string& domain,
+                 const std::string& path,
+                 const base::Time& creation) {
+    store_->AddCookie(
+        net::CanonicalCookie(
+            GURL(), name, value, domain, path, creation, creation, creation,
+            false, false, false, net::COOKIE_PRIORITY_DEFAULT));
+  }
+
+  void DestroyStore() {
+    store_ = nullptr;
+    // Ensure that |store_|'s destructor has run by shutting down the pool and
+    // then forcing the pool to be destructed. This will ensure that all the
+    // tasks that block pool shutdown (e.g. |store_|'s cleanup) have run before
+    // yielding control.
+    pool_owner_->pool()->FlushForTesting();
+    pool_owner_->pool()->Shutdown();
+    pool_owner_.reset(new base::SequencedWorkerPoolOwner(3, "Background Pool"));
+  }
+
+  void SetUp() override {
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  }
+
+  void TearDown() override {
+    DestroyStore();
+    pool_owner_->pool()->Shutdown();
+  }
+
+  TestBrowserThreadBundle bundle_;
+  scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
+  base::WaitableEvent loaded_event_;
+  base::ScopedTempDir temp_dir_;
+  scoped_refptr<QuotaPolicyCookieStore> store_;
+  CanonicalCookieVector cookies_;
+};
+
+// Test if data is stored as expected in the QuotaPolicy database.
+TEST_F(QuotaPolicyCookieStoreTest, TestPersistence) {
+  CanonicalCookieVector cookies;
+  CreateAndLoad(nullptr, &cookies);
+  ASSERT_EQ(0U, cookies.size());
+
+  base::Time t = base::Time::Now();
+  AddCookie("A", "B", "foo.com", "/", t);
+  t += base::TimeDelta::FromInternalValue(10);
+  AddCookie("A", "B", "persistent.com", "/", t);
+
+  // Replace the store effectively destroying the current one and forcing it
+  // to write its data to disk. Then we can see if after loading it again it
+  // is still there.
+  DestroyStore();
+
+  // Reload and test for persistence.
+  STLDeleteElements(&cookies);
+  CreateAndLoad(nullptr, &cookies);
+  EXPECT_EQ(2U, cookies.size());
+  bool found_foo_cookie = false;
+  bool found_persistent_cookie = false;
+  for (const auto& cookie : cookies) {
+    if (cookie->Domain() == "foo.com")
+      found_foo_cookie = true;
+    else if (cookie->Domain() == "persistent.com")
+      found_persistent_cookie = true;
+  }
+  EXPECT_TRUE(found_foo_cookie);
+  EXPECT_TRUE(found_persistent_cookie);
+
+  // Now delete the cookies and check persistence again.
+  store_->DeleteCookie(*cookies[0]);
+  store_->DeleteCookie(*cookies[1]);
+  DestroyStore();
+
+  // Reload and check if the cookies have been removed.
+  STLDeleteElements(&cookies);
+  CreateAndLoad(nullptr, &cookies);
+  EXPECT_EQ(0U, cookies.size());
+  STLDeleteElements(&cookies);
+}
+
+// Test if data is stored as expected in the QuotaPolicy database.
+TEST_F(QuotaPolicyCookieStoreTest, TestPolicy) {
+  CanonicalCookieVector cookies;
+  CreateAndLoad(nullptr, &cookies);
+  ASSERT_EQ(0U, cookies.size());
+
+  base::Time t = base::Time::Now();
+  AddCookie("A", "B", "foo.com", "/", t);
+  t += base::TimeDelta::FromInternalValue(10);
+  AddCookie("A", "B", "persistent.com", "/", t);
+  t += base::TimeDelta::FromInternalValue(10);
+  AddCookie("A", "B", "nonpersistent.com", "/", t);
+
+  // Replace the store effectively destroying the current one and forcing it
+  // to write its data to disk. Then we can see if after loading it again it
+  // is still there.
+  DestroyStore();
+  // Specify storage policy that makes "nonpersistent.com" session only.
+  scoped_refptr<content::MockSpecialStoragePolicy> storage_policy =
+      new content::MockSpecialStoragePolicy();
+  storage_policy->AddSessionOnly(
+      net::cookie_util::CookieOriginToURL("nonpersistent.com", false));
+
+  // Reload and test for persistence
+  STLDeleteElements(&cookies);
+  CreateAndLoad(storage_policy.get(), &cookies);
+  EXPECT_EQ(3U, cookies.size());
+
+  t += base::TimeDelta::FromInternalValue(10);
+  AddCookie("A", "B", "nonpersistent.com", "/second", t);
+
+  // Now close the store, and "nonpersistent.com" should be deleted according to
+  // policy.
+  DestroyStore();
+  STLDeleteElements(&cookies);
+  CreateAndLoad(nullptr, &cookies);
+
+  EXPECT_EQ(2U, cookies.size());
+  for (const auto& cookie : cookies) {
+    EXPECT_NE("nonpersistent.com", cookie->Domain());
+  }
+  STLDeleteElements(&cookies);
+}
+
+TEST_F(QuotaPolicyCookieStoreTest, ForceKeepSessionState) {
+  CanonicalCookieVector cookies;
+  CreateAndLoad(nullptr, &cookies);
+  ASSERT_EQ(0U, cookies.size());
+
+  base::Time t = base::Time::Now();
+  AddCookie("A", "B", "foo.com", "/", t);
+
+  // Recreate |store_| with a storage policy that makes "nonpersistent.com"
+  // session only, but then instruct the store to forcibly keep all cookies.
+  DestroyStore();
+  scoped_refptr<content::MockSpecialStoragePolicy> storage_policy =
+      new content::MockSpecialStoragePolicy();
+  storage_policy->AddSessionOnly(
+      net::cookie_util::CookieOriginToURL("nonpersistent.com", false));
+
+  // Reload and test for persistence
+  STLDeleteElements(&cookies);
+  CreateAndLoad(storage_policy.get(), &cookies);
+  EXPECT_EQ(1U, cookies.size());
+
+  t += base::TimeDelta::FromInternalValue(10);
+  AddCookie("A", "B", "persistent.com", "/", t);
+  t += base::TimeDelta::FromInternalValue(10);
+  AddCookie("A", "B", "nonpersistent.com", "/", t);
+
+  // Now close the store, but the "nonpersistent.com" cookie should not be
+  // deleted.
+  store_->SetForceKeepSessionState();
+  DestroyStore();
+  STLDeleteElements(&cookies);
+  CreateAndLoad(nullptr, &cookies);
+
+  EXPECT_EQ(3U, cookies.size());
+  STLDeleteElements(&cookies);
+}
+
+}  // namespace
+}  // namespace content

content/content_browser.gypi

@@ -12,6 +12,7 @@
     '../device/vibration/vibration.gyp:device_vibration_mojo_bindings',
     '../google_apis/google_apis.gyp:google_apis',
     '../net/net.gyp:net',
+    '../net/net.gyp:net_extras',
     '../skia/skia.gyp:skia',
     '../sql/sql.gyp:sql',
     '../third_party/re2/re2.gyp:re2',
@@ -1024,8 +1025,8 @@
       'browser/navigator_connect/navigator_connect_service_worker_service_factory.h',
       'browser/net/browser_online_state_observer.cc',
       'browser/net/browser_online_state_observer.h',
-      'browser/net/sqlite_persistent_cookie_store.cc',
-      'browser/net/sqlite_persistent_cookie_store.h',
+      'browser/net/quota_policy_cookie_store.cc',
+      'browser/net/quota_policy_cookie_store.h',
       'browser/net/view_blob_internals_job_factory.cc',
       'browser/net/view_blob_internals_job_factory.h',
       'browser/net/view_http_cache_job_factory.cc',

content/content_tests.gypi

@@ -478,7 +478,7 @@
       'browser/media/media_internals_unittest.cc',
       'browser/media/midi_host_unittest.cc',
       'browser/media/webrtc_identity_store_unittest.cc',
-      'browser/net/sqlite_persistent_cookie_store_unittest.cc',
+      'browser/net/quota_policy_cookie_store_unittest.cc',
       'browser/notification_service_impl_unittest.cc',
       'browser/notifications/notification_database_data_unittest.cc',
       'browser/notifications/notification_database_unittest.cc',
@@ -977,6 +977,7 @@
         '../device/battery/battery.gyp:device_battery',
         '../device/battery/battery.gyp:device_battery_mojo_bindings',
         '../mojo/mojo_base.gyp:mojo_environment_chromium',
+        '../net/net.gyp:net_extras',
         '../net/net.gyp:net_test_support',
         '../skia/skia.gyp:skia',
         '../sql/sql.gyp:sql',
@@ -1251,7 +1252,6 @@
             '..',
           ],
           'sources': [
-            'browser/net/sqlite_persistent_cookie_store_perftest.cc',
             'browser/renderer_host/input/input_router_impl_perftest.cc',
             'common/cc_messages_perftest.cc',
             'common/discardable_shared_memory_heap_perftest.cc',

content/test/BUILD.gn

@@ -439,6 +439,7 @@ test("content_unittests") {
     "//device/battery",
     "//device/battery:mojo_bindings",
     "//mojo/environment:chromium",
+    "//net:extras",
     "//net:test_support",
     "//skia",
     "//sql",
@@ -622,7 +623,6 @@ test("content_unittests") {
 if (!is_mac) {  # TODO(GYP) enable on Mac once it links.
   test("content_perftests") {
     sources = [
-      "../browser/net/sqlite_persistent_cookie_store_perftest.cc",
       "../browser/renderer_host/input/input_router_impl_perftest.cc",
       "../common/cc_messages_perftest.cc",
       "../test/run_all_perftests.cc",

net/BUILD.gn

@@ -1588,6 +1588,7 @@ executable("net_perftests") {
   sources = [
     "cookies/cookie_monster_perftest.cc",
     "disk_cache/blockfile/disk_cache_perftest.cc",
+    "extras/sqlite/sqlite_persistent_cookie_store_perftest.cc",
     "proxy/proxy_resolver_perftest.cc",
     "udp/udp_socket_perftest.cc",
   ]
@@ -1600,6 +1601,7 @@ executable("net_perftests") {
     "//base/test:test_support_perf",
     "//testing/gtest",
     "//url",
+    ":extras",
     ":net",
     ":test_support",
   ]

content/browser/net/sqlite_persistent_cookie_store.h → net/extras/sqlite/sqlite_persistent_cookie_store.h

@@ -2,18 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// A sqlite implementation of a cookie monster persistent store.
-
-#ifndef CONTENT_BROWSER_NET_SQLITE_PERSISTENT_COOKIE_STORE_H_
-#define CONTENT_BROWSER_NET_SQLITE_PERSISTENT_COOKIE_STORE_H_
+#ifndef NET_EXTRAS_SQLITE_SQLITE_PERSISTENT_COOKIE_STORE_H_
+#define NET_EXTRAS_SQLITE_SQLITE_PERSISTENT_COOKIE_STORE_H_
 
+#include <list>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/callback_forward.h"
-#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
-#include "content/common/content_export.h"
 #include "net/cookies/cookie_monster.h"
 
 class Task;
@@ -21,27 +19,22 @@ class Task;
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
-}
+}  // namespace base
 
 namespace net {
 class CanonicalCookie;
 class CookieCryptoDelegate;
-}
-
-namespace storage {
-class SpecialStoragePolicy;
-}
-
-namespace content {
 
 // Implements the PersistentCookieStore interface in terms of a SQLite database.
 // For documentation about the actual member functions consult the documentation
-// of the parent class |net::CookieMonster::PersistentCookieStore|.
-// If provided, a |SpecialStoragePolicy| is consulted when the SQLite database
-// is closed to decide which cookies to keep.
-class CONTENT_EXPORT SQLitePersistentCookieStore
-    : public net::CookieMonster::PersistentCookieStore {
+// of the parent class |CookieMonster::PersistentCookieStore|.
+class SQLitePersistentCookieStore
+    : public CookieMonster::PersistentCookieStore {
  public:
+  // Contains the origin and a bool indicating whether or not the
+  // origin is secure.
+  typedef std::pair<std::string, bool> CookieOrigin;
+
   // All blocking database accesses will be performed on
   // |background_task_runner|, while |client_task_runner| is used to invoke
   // callbacks.
@@ -50,23 +43,24 @@ class CONTENT_EXPORT SQLitePersistentCookieStore
       const scoped_refptr<base::SequencedTaskRunner>& client_task_runner,
       const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
       bool restore_old_session_cookies,
-      storage::SpecialStoragePolicy* special_storage_policy,
-      net::CookieCryptoDelegate* crypto_delegate);
+      CookieCryptoDelegate* crypto_delegate);
 
-  // net::CookieMonster::PersistentCookieStore:
+  // Deletes the cookies whose origins match those given in |cookies|.
+  void DeleteAllInList(const std::list<CookieOrigin>& cookies);
+
+  // CookieMonster::PersistentCookieStore:
   void Load(const LoadedCallback& loaded_callback) override;
   void LoadCookiesForKey(const std::string& key,
                          const LoadedCallback& callback) override;
-  void AddCookie(const net::CanonicalCookie& cc) override;
-  void UpdateCookieAccessTime(const net::CanonicalCookie& cc) override;
-  void DeleteCookie(const net::CanonicalCookie& cc) override;
+  void AddCookie(const CanonicalCookie& cc) override;
+  void UpdateCookieAccessTime(const CanonicalCookie& cc) override;
+  void DeleteCookie(const CanonicalCookie& cc) override;
   void SetForceKeepSessionState() override;
   void Flush(const base::Closure& callback) override;
 
- protected:
+ private:
   ~SQLitePersistentCookieStore() override;
 
- private:
   class Backend;
 
   scoped_refptr<Backend> backend_;
@@ -74,6 +68,6 @@ class CONTENT_EXPORT SQLitePersistentCookieStore
   DISALLOW_COPY_AND_ASSIGN(SQLitePersistentCookieStore);
 };
 
-}  // namespace content
+}  // namespace net
 
-#endif  // CONTENT_BROWSER_NET_SQLITE_PERSISTENT_COOKIE_STORE_H_
+#endif  // NET_EXTRAS_SQLITE_SQLITE_PERSISTENT_COOKIE_STORE_H_

content/browser/net/sqlite_persistent_cookie_store_perftest.cc → net/extras/sqlite/sqlite_persistent_cookie_store_perftest.cc

@@ -2,11 +2,14 @@
 // 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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
+
+#include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ -19,7 +22,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
-namespace content {
+namespace net {
 
 namespace {
 
@@ -32,22 +35,21 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
   SQLitePersistentCookieStorePerfTest()
       : pool_owner_(new base::SequencedWorkerPoolOwner(1, "Background Pool")),
         loaded_event_(false, false),
-        key_loaded_event_(false, false) {
-  }
+        key_loaded_event_(false, false) {}
 
-  void OnLoaded(const std::vector<net::CanonicalCookie*>& cookies) {
+  void OnLoaded(const std::vector<CanonicalCookie*>& cookies) {
     cookies_ = cookies;
     loaded_event_.Signal();
   }
 
-  void OnKeyLoaded(const std::vector<net::CanonicalCookie*>& cookies) {
+  void OnKeyLoaded(const std::vector<CanonicalCookie*>& cookies) {
     cookies_ = cookies;
     key_loaded_event_.Signal();
   }
 
   void Load() {
     store_->Load(base::Bind(&SQLitePersistentCookieStorePerfTest::OnLoaded,
-                                base::Unretained(this)));
+                            base::Unretained(this)));
     loaded_event_.Wait();
   }
 
@@ -64,11 +66,9 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     store_ = new SQLitePersistentCookieStore(
-        temp_dir_.path().Append(cookie_filename),
-        client_task_runner(),
-        background_task_runner(),
-        false, NULL, NULL);
-    std::vector<net::CanonicalCookie*> cookies;
+        temp_dir_.path().Append(cookie_filename), client_task_runner(),
+        background_task_runner(), false, NULL);
+    std::vector<CanonicalCookie*> cookies;
     Load();
     ASSERT_EQ(0u, cookies_.size());
     // Creates 15000 cookies from 300 eTLD+1s.
@@ -78,9 +78,9 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
       GURL gurl("www" + domain_name);
       for (int cookie_num = 0; cookie_num < 50; ++cookie_num) {
         t += base::TimeDelta::FromInternalValue(10);
-        store_->AddCookie(net::CanonicalCookie(
+        store_->AddCookie(CanonicalCookie(
             gurl, base::StringPrintf("Cookie_%d", cookie_num), "1", domain_name,
-            "/", t, t, t, false, false, false, net::COOKIE_PRIORITY_DEFAULT));
+            "/", t, t, t, false, false, false, COOKIE_PRIORITY_DEFAULT));
       }
     }
     // Replace the store effectively destroying the current one and forcing it
@@ -93,10 +93,8 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
     pool_owner_.reset(new base::SequencedWorkerPoolOwner(1, "pool"));
 
     store_ = new SQLitePersistentCookieStore(
-        temp_dir_.path().Append(cookie_filename),
-        client_task_runner(),
-        background_task_runner(),
-        false, NULL, NULL);
+        temp_dir_.path().Append(cookie_filename), client_task_runner(),
+        background_task_runner(), false, NULL);
   }
 
   void TearDown() override {
@@ -105,10 +103,11 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
   }
 
  protected:
+  base::MessageLoop main_loop_;
   scoped_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
   base::WaitableEvent loaded_event_;
   base::WaitableEvent key_loaded_event_;
-  std::vector<net::CanonicalCookie*> cookies_;
+  std::vector<CanonicalCookie*> cookies_;
   base::ScopedTempDir temp_dir_;
   scoped_refptr<SQLitePersistentCookieStore> store_;
 };
@@ -118,10 +117,11 @@ TEST_F(SQLitePersistentCookieStorePerfTest, TestLoadForKeyPerformance) {
   for (int domain_num = 0; domain_num < 3; ++domain_num) {
     std::string domain_name(base::StringPrintf("domain_%d.com", domain_num));
     base::PerfTimeLogger timer(
-      ("Load cookies for the eTLD+1 " + domain_name).c_str());
-    store_->LoadCookiesForKey(domain_name,
-      base::Bind(&SQLitePersistentCookieStorePerfTest::OnKeyLoaded,
-                 base::Unretained(this)));
+        ("Load cookies for the eTLD+1 " + domain_name).c_str());
+    store_->LoadCookiesForKey(
+        domain_name,
+        base::Bind(&SQLitePersistentCookieStorePerfTest::OnKeyLoaded,
+                   base::Unretained(this)));
     key_loaded_event_.Wait();
     timer.Done();
 
@@ -138,4 +138,4 @@ TEST_F(SQLitePersistentCookieStorePerfTest, TestLoadPerformance) {
   ASSERT_EQ(15000U, cookies_.size());
 }
 
-}  // namespace content
+}  // namespace net

net/net.gyp

@@ -448,11 +448,13 @@
         '../testing/gtest.gyp:gtest',
         '../url/url.gyp:url_lib',
         'net',
+        'net_extras',
         'net_test_support',
       ],
       'sources': [
         'cookies/cookie_monster_perftest.cc',
         'disk_cache/blockfile/disk_cache_perftest.cc',
+        'extras/sqlite/sqlite_persistent_cookie_store_perftest.cc',
         'proxy/proxy_resolver_perftest.cc',
         'udp/udp_socket_perftest.cc',
         'websockets/websocket_frame_perftest.cc',

net/net.gypi

@@ -1272,6 +1272,8 @@
       'extras/sqlite/cookie_crypto_delegate.h',
       'extras/sqlite/sqlite_channel_id_store.cc',
       'extras/sqlite/sqlite_channel_id_store.h',
+      'extras/sqlite/sqlite_persistent_cookie_store.cc',
+      'extras/sqlite/sqlite_persistent_cookie_store.h',
     ],
     'net_test_sources': [
       'android/keystore_unittest.cc',
@@ -1388,6 +1390,7 @@
       'dns/serial_worker_unittest.cc',
       'dns/single_request_host_resolver_unittest.cc',
       'extras/sqlite/sqlite_channel_id_store_unittest.cc',
+      'extras/sqlite/sqlite_persistent_cookie_store_unittest.cc',
       'filter/filter_unittest.cc',
       'filter/gzip_filter_unittest.cc',
       'filter/mock_filter_context.cc',