Moves SQLitePersistentCookieStore to net/extras/sqlite.

content/browser/net/quota_policy_cookie_store.cc

+// Copyright (c) 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/command_line.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 "content/public/browser/browser_thread.h"
+#include "content/public/browser/cookie_store_factory.h"
+#include "content/public/common/content_switches.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 base::FilePath& path,
+    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)
+    : special_storage_policy_(special_storage_policy),
+      persistent_store_(
+          new net::SQLitePersistentCookieStore(path,
+                                               client_task_runner,
+                                               background_task_runner,
+                                               restore_old_session_cookies,
+                                               crypto_delegate)) {
+  DCHECK(client_task_runner);
+  DCHECK(background_task_runner);
+}
+
+QuotaPolicyCookieStore::~QuotaPolicyCookieStore() {
+  if (!special_storage_policy_.get() ||
+      !special_storage_policy_->HasSessionOnlyOrigins()) {
+    return;
+  }
+
+  std::list<net::SQLitePersistentCookieStore::CookieOrigin>
+      session_only_cookies;
+  for (auto it = cookies_per_origin_.begin();
+       it != cookies_per_origin_.end(); ++it) {

[Ryan Sleevi, 2015/03/19 03:37:51]

Doesn't this vend a mutable |it| due to auto binding to the non-const invocation
of .begin() (since C++14 is cbegin)? ;(

why not use range-based and let it do the right thing?

for (const auto& cookie : cookies_per_orgin_) {

}

[rohitrao (ping after 24h), 2015/03/19 14:55:42]

Did not know that was possible, but I like it way better =)  Done.

+    if (it->second <= 0) {
+      DCHECK_EQ(0, it->second);
+      continue;
+    }
+    const GURL url(net::cookie_util::CookieOriginToURL(it->first.first,
+                                                       it->first.second));
+    if (!url.is_valid() || !special_storage_policy_->IsStorageSessionOnly(url))
+      continue;
+
+    session_only_cookies.push_back(it->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) {
+  cookies_per_origin_[
+      net::SQLitePersistentCookieStore::CookieOrigin(cc.Domain(),
+                                                     cc.IsSecure())]++;
+  persistent_store_->AddCookie(cc);
+}
+
+void QuotaPolicyCookieStore::UpdateCookieAccessTime(
+    const net::CanonicalCookie& cc) {
+  persistent_store_->UpdateCookieAccessTime(cc);
+}
+
+void QuotaPolicyCookieStore::DeleteCookie(const net::CanonicalCookie& cc) {
+  cookies_per_origin_[
+      net::SQLitePersistentCookieStore::CookieOrigin(cc.Domain(),
+                                                     cc.IsSecure())]--;
+  persistent_store_->DeleteCookie(cc);
+}
+
+void QuotaPolicyCookieStore::SetForceKeepSessionState() {
+  special_storage_policy_ = NULL;
+}
+
+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 (auto it = cookies.begin(); it != cookies.end(); ++it) {

[Ryan Sleevi, 2015/03/19 03:37:51]

ditto const auto& + range

[rohitrao (ping after 24h), 2015/03/19 14:55:42]

Done.

+    cookies_per_origin_[
+        net::SQLitePersistentCookieStore::CookieOrigin((*it)->Domain(),
+                                                       (*it)->IsSecure())]++;
+  }
+
+  loaded_callback.Run(cookies);
+}
+
+CookieStoreConfig::CookieStoreConfig()
+  : session_cookie_mode(EPHEMERAL_SESSION_COOKIES),
+    crypto_delegate(NULL) {
+  // 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(NULL) {
+  CHECK(!path.empty() || session_cookie_mode == EPHEMERAL_SESSION_COOKIES);
+}
+
+CookieStoreConfig::~CookieStoreConfig() {
+}
+
+net::CookieStore* CreateCookieStore(const CookieStoreConfig& config) {
+  net::CookieMonster* cookie_monster = NULL;
+
+  if (config.path.empty()) {
+    // Empty path means in-memory store.
+    cookie_monster = new net::CookieMonster(NULL, 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());

[Ryan Sleevi, 2015/03/19 03:37:51]

Is it right that every cookie store should be given their own SequenceToken?

Would it make more sense to use a common token for all the cookie stores? It
would still guarantee the same FIFOness, it just wouldn't burn a token. 

The only reason to use a SequenceToken is to allow multiple participants to get
the same STR from the blocking pool if needed, but you seem entirely unreliant
on needing that, so just using a single named pool is all the same.

[rohitrao (ping after 24h), 2015/03/19 14:55:42]

This entire block was copied verbatim from the old content/ class.  I am not
sure what the intent was, but I can figure out who wrote it and file a bug.

It sounds like the current code isn't incorrect, just wasteful of tokens?

+    }
+
+    QuotaPolicyCookieStore* persistent_store =
+        new QuotaPolicyCookieStore(
+            config.path,
+            client_task_runner,
+            background_task_runner,
+            (config.session_cookie_mode ==
+             CookieStoreConfig::RESTORED_SESSION_COOKIES),
+            config.storage_policy.get(),
+            config.crypto_delegate);
+
+    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);
+    }
+  }
+
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableFileCookies)) {
+    cookie_monster->SetEnableFileScheme(true);
+  }
+
+  return cookie_monster;
+}
+
+}  // namespace content