Don't force non-session only cookies to be session only cookies, instead delete on shutdown

chrome/browser/net/sqlite_persistent_cookie_store.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 "chrome/browser/net/sqlite_persistent_cookie_store.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
+#include "chrome/browser/net/clear_on_exit_policy.h"
 #include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/registry_controlled_domain.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using base::Time;
 using content::BrowserThread;
 
@@ skipping 15 matching lines @@
 // CompleteLoadForKeyOnIOThread to the IO thread to notify the caller of
 // SQLitePersistentCookieStore::LoadCookiesForKey that that load is complete.
 //
 // Subsequent to loading, mutations may be queued by any thread using
 // AddCookie, UpdateCookieAccessTime, and DeleteCookie. These are flushed to
 // disk on the DB thread every 30 seconds, 512 operations, or call to Flush(),
 // whichever occurs first.
 class SQLitePersistentCookieStore::Backend
     : public base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend> {
  public:
-  Backend(const FilePath& path, bool restore_old_session_cookies)
+  Backend(const FilePath& path,
+          bool restore_old_session_cookies,
+          ClearOnExitPolicy* clear_on_exit_policy)
       : path_(path),
         db_(NULL),
         num_pending_(0),
         clear_local_state_on_exit_(false),
         initialized_(false),
         restore_old_session_cookies_(restore_old_session_cookies),
+        clear_on_exit_policy_(clear_on_exit_policy),
         num_cookies_read_(0),
         num_priority_waiting_(0),
         total_priority_requests_(0) {
   }
 
   // Creates or loads the SQLite database.
   void Load(const LoadedCallback& loaded_callback);
 
   // Loads cookies for the domain key (eTLD+1).
   void LoadCookiesForKey(const std::string& domain,
@@ skipping 95 matching lines @@
   bool LoadCookiesForDomains(const std::set<std::string>& key);
 
   // Batch a cookie operation (add or delete)
   void BatchOperation(PendingOperation::OperationType op,
                       const net::CookieMonster::CanonicalCookie& cc);
   // Commit our pending operations to the database.
   void Commit();
   // Close() executed on the background thread.
   void InternalBackgroundClose();
 
-  void DeleteSessionCookies();
+  void DeleteSessionCookiesOnStartup();
+
+  void DeleteSessionCookiesOnShutdown();
 
   FilePath path_;
   scoped_ptr<sql::Connection> db_;
   sql::MetaTable meta_table_;
 
   typedef std::list<PendingOperation*> PendingOperationsList;
   PendingOperationsList pending_;
   PendingOperationsList::size_type num_pending_;
   // True if the persistent store should be deleted upon destruction.
   bool clear_local_state_on_exit_;
-  // Guard |cookies_|, |pending_|, |num_pending_|, |clear_local_state_on_exit_|
+  // Guard |cookies_|, |pending_|, |num_pending_|, |clear_local_state_on_exit_|,
+  // and |cookies_per_origin_|.

[erikwright (departed), 2012/05/29 13:09:03]

As far as I can tell, cookies_per_origin_ is only accessed on DB thread
(assertions at the top of each method that touches it).

If so, you can avoid locking around those accesses and you can remove the
temporary deltas structure.

[jochen (gone - plz use gerrit), 2012/05/30 11:28:42]

Done.

   base::Lock lock_;
 
   // Temporary buffer for cookies loaded from DB. Accumulates cookies to reduce
   // the number of messages sent to the IO thread. Sent back in response to
   // individual load requests for domain keys or when all loading completes.
   std::vector<net::CookieMonster::CanonicalCookie*> cookies_;
 
   // Map of domain keys(eTLD+1) to domains/hosts that are to be loaded from DB.
   std::map<std::string, std::set<std::string> > keys_to_load_;
 
+  // Map of (domain keys(eTLD+1), is secure cookie) to number of cookies in the
+  // database.
+  typedef std::pair<std::string, bool> CookieOrigin;
+  typedef std::map<CookieOrigin, int> CookiesPerOriginMap;
+  CookiesPerOriginMap cookies_per_origin_;
+
   // Indicates if DB has been initialized.
   bool initialized_;
 
   // If false, we should filter out session cookies when reading the DB.
   bool restore_old_session_cookies_;
 
+  // Policy defining what data is deleted on shutdown.
+  scoped_refptr<ClearOnExitPolicy> clear_on_exit_policy_;
+
   // The cumulative time spent loading the cookies on the DB thread. Incremented
   // and reported from the DB thread.
   base::TimeDelta cookie_load_duration_;
 
   // The total number of cookies read. Incremented and reported on the DB
   // thread.
   int num_cookies_read_;
 
   // Guards the following metrics-related properties (only accessed when
   // starting/completing priority loads or completing the total load).
@@ skipping 336 matching lines @@
   if (load_success && keys_to_load_.size() > 0) {
     BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&Backend::ChainLoadCookies, this, loaded_callback));
   } else {
     BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SQLitePersistentCookieStore::Backend::CompleteLoadOnIOThread,
                  this, loaded_callback, load_success));
     if (load_success && !restore_old_session_cookies_)
-      DeleteSessionCookies();
+      DeleteSessionCookiesOnStartup();
   }
 }
 
 bool SQLitePersistentCookieStore::Backend::LoadCookiesForDomains(
   const std::set<std::string>& domains) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   sql::Statement smt;
   if (restore_old_session_cookies_) {
     smt.Assign(db_->GetCachedStatement(
       SQL_FROM_HERE,
       "SELECT creation_utc, host_key, name, value, path, expires_utc, "
       "secure, httponly, last_access_utc, has_expires, persistent "
       "FROM cookies WHERE host_key = ?"));
   } else {
     smt.Assign(db_->GetCachedStatement(
       SQL_FROM_HERE,
       "SELECT creation_utc, host_key, name, value, path, expires_utc, "
       "secure, httponly, last_access_utc, has_expires, persistent "
       "FROM cookies WHERE host_key = ? AND persistent = 1"));
   }
   if (!smt.is_valid()) {
     smt.Clear();  // Disconnect smt_ref from db_.
     db_.reset();
     return false;
   }
 
   std::vector<net::CookieMonster::CanonicalCookie*> cookies;
   std::set<std::string>::const_iterator it = domains.begin();
+  CookiesPerOriginMap cookies_per_origin;
   for (; it != domains.end(); ++it) {
     smt.BindString(0, *it);
     while (smt.Step()) {
       scoped_ptr<net::CookieMonster::CanonicalCookie> cc(
           new net::CookieMonster::CanonicalCookie(
               // The "source" URL is not used with persisted cookies.
               GURL(),                                         // Source
               smt.ColumnString(2),                            // name
               smt.ColumnString(3),                            // value
               smt.ColumnString(1),                            // domain
               smt.ColumnString(4),                            // path
               std::string(),  // TODO(abarth): Persist mac_key
               std::string(),  // TODO(abarth): Persist mac_algorithm
               Time::FromInternalValue(smt.ColumnInt64(0)),    // creation_utc
               Time::FromInternalValue(smt.ColumnInt64(5)),    // expires_utc
               Time::FromInternalValue(smt.ColumnInt64(8)),    // last_access_utc
               smt.ColumnInt(6) != 0,                          // secure
               smt.ColumnInt(7) != 0,                          // httponly
               smt.ColumnInt(9) != 0,                          // has_expires
               smt.ColumnInt(10) != 0));                       // is_persistent
       DLOG_IF(WARNING,
               cc->CreationDate() > Time::Now()) << L"CreationDate too recent";
+      cookies_per_origin[CookieOrigin(cc->Domain(), cc->IsSecure())]++;
       cookies.push_back(cc.release());
       ++num_cookies_read_;
     }
     smt.Reset(true);
   }
   {
     base::AutoLock locked(lock_);
     cookies_.insert(cookies_.end(), cookies.begin(), cookies.end());
+    for (CookiesPerOriginMap::iterator it = cookies_per_origin.begin();
+         it != cookies_per_origin.end(); ++it) {
+      cookies_per_origin_[it->first] += it->second;
+    }
   }
   return true;
 }
 
 bool SQLitePersistentCookieStore::Backend::EnsureDatabaseVersion() {
   // Version check.
   if (!meta_table_.Init(
       db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) {
     return false;
   }
@@ skipping 175 matching lines @@
 
   sql::Statement del_smt(db_->GetCachedStatement(SQL_FROM_HERE,
                          "DELETE FROM cookies WHERE creation_utc=?"));
   if (!del_smt.is_valid())
     return;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return;
 
+  CookiesPerOriginMap cookies_delta_per_origin;

[erikwright (departed), 2012/05/29 13:09:03]

nit: cookies_delta -> cookie_deltas

[jochen (gone - plz use gerrit), 2012/05/30 11:28:42]

removed the variable as per above comment

   for (PendingOperationsList::iterator it = ops.begin();
        it != ops.end(); ++it) {
     // Free the cookies as we commit them to the database.
     scoped_ptr<PendingOperation> po(*it);
     switch (po->op()) {
       case PendingOperation::COOKIE_ADD:
+        cookies_delta_per_origin[
+            CookieOrigin(po->cc().Domain(), po->cc().IsSecure())]++;
         add_smt.Reset(true);
         add_smt.BindInt64(0, po->cc().CreationDate().ToInternalValue());
         add_smt.BindString(1, po->cc().Domain());
         add_smt.BindString(2, po->cc().Name());
         add_smt.BindString(3, po->cc().Value());
         add_smt.BindString(4, po->cc().Path());
         add_smt.BindInt64(5, po->cc().ExpiryDate().ToInternalValue());
         add_smt.BindInt(6, po->cc().IsSecure());
         add_smt.BindInt(7, po->cc().IsHttpOnly());
         add_smt.BindInt64(8, po->cc().LastAccessDate().ToInternalValue());
         add_smt.BindInt(9, po->cc().DoesExpire());
         add_smt.BindInt(10, po->cc().IsPersistent());
         if (!add_smt.Run())
           NOTREACHED() << "Could not add a cookie to the DB.";
         break;
 
       case PendingOperation::COOKIE_UPDATEACCESS:
         update_access_smt.Reset(true);
         update_access_smt.BindInt64(0,
             po->cc().LastAccessDate().ToInternalValue());
         update_access_smt.BindInt64(1,
             po->cc().CreationDate().ToInternalValue());
         if (!update_access_smt.Run())
           NOTREACHED() << "Could not update cookie last access time in the DB.";
         break;
 
       case PendingOperation::COOKIE_DELETE:
+        cookies_delta_per_origin[
+            CookieOrigin(po->cc().Domain(), po->cc().IsSecure())]--;
         del_smt.Reset(true);
         del_smt.BindInt64(0, po->cc().CreationDate().ToInternalValue());
         if (!del_smt.Run())
           NOTREACHED() << "Could not delete a cookie from the DB.";
         break;
 
       default:
         NOTREACHED();
         break;
     }
   }
   bool succeeded = transaction.Commit();
   UMA_HISTOGRAM_ENUMERATION("Cookie.BackingStoreUpdateResults",
                             succeeded ? 0 : 1, 2);
+  if (succeeded) {
+    base::AutoLock locked(lock_);
+    for (CookiesPerOriginMap::iterator it = cookies_delta_per_origin.begin();
+         it != cookies_delta_per_origin.end(); ++it) {
+      cookies_per_origin_[it->first] += it->second;
+    }
+  }
 }
 
 void SQLitePersistentCookieStore::Backend::Flush(
     const base::Closure& callback) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::DB));
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE, base::Bind(&Backend::Commit, this));
   if (!callback.is_null()) {
     // We want the completion task to run immediately after Commit() returns.
     // Posting it from here means there is less chance of another task getting
@@ skipping 14 matching lines @@
         BrowserThread::DB, FROM_HERE,
         base::Bind(&Backend::InternalBackgroundClose, this));
   }
 }
 
 void SQLitePersistentCookieStore::Backend::InternalBackgroundClose() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   // Commit any pending operations
   Commit();
 
+  if (!clear_local_state_on_exit_ && clear_on_exit_policy_.get() &&
+      clear_on_exit_policy_->HasClearOnExitOrigins()) {
+    DeleteSessionCookiesOnShutdown();
+  }
+
   db_.reset();
 
   if (clear_local_state_on_exit_)
     file_util::Delete(path_, false);
 }
 
+void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnShutdown() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+
+  if (!db_.get())
+    return;
+
+  sql::Statement del_smt(db_->GetCachedStatement(
+      SQL_FROM_HERE, "DELETE FROM cookies WHERE host_key=? AND secure=?"));
+  if (!del_smt.is_valid()) {
+    LOG(WARNING) << "Unable to delete cookies on shutdown.";
+    return;
+  }
+
+  sql::Transaction transaction(db_.get());
+  if (!transaction.Begin()) {
+    LOG(WARNING) << "Unable to delete cookies on shutdown.";
+    return;
+  }
+
+  base::AutoLock locked(lock_);
+  for (CookiesPerOriginMap::iterator it = cookies_per_origin_.begin();
+       it != cookies_per_origin_.end(); ++it) {
+    if (it->second <= 0) {
+      DCHECK_EQ(0, it->second);
+      continue;
+    }
+    if (!clear_on_exit_policy_->ShouldClearOriginOnExit(it->first.first,
+                                                        it->first.second)) {
+      continue;
+    }
+
+    del_smt.Reset(true);
+    del_smt.BindString(0, it->first.first);
+    del_smt.BindInt(1, it->first.second);
+    if (!del_smt.Run())
+      NOTREACHED() << "Could not delete a cookie from the DB.";
+  }
+
+  if (!transaction.Commit())
+    LOG(WARNING) << "Unable to delete cookies on shutdown.";
+}
+
 void SQLitePersistentCookieStore::Backend::SetClearLocalStateOnExit(
     bool clear_local_state) {
   base::AutoLock locked(lock_);
   clear_local_state_on_exit_ = clear_local_state;
 }
 
-void SQLitePersistentCookieStore::Backend::DeleteSessionCookies() {
+void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnStartup() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!db_->Execute("DELETE FROM cookies WHERE persistent == 0"))
     LOG(WARNING) << "Unable to delete session cookies.";
 }
 
 SQLitePersistentCookieStore::SQLitePersistentCookieStore(
     const FilePath& path,
-    bool restore_old_session_cookies)
-    : backend_(new Backend(path, restore_old_session_cookies)) {
+    bool restore_old_session_cookies,
+    ClearOnExitPolicy* clear_on_exit_policy)
+    : backend_(
+        new Backend(path, restore_old_session_cookies, clear_on_exit_policy)) {
 }
 
 void SQLitePersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
   backend_->Load(loaded_callback);
 }
 
 void SQLitePersistentCookieStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
   backend_->LoadCookiesForKey(key, loaded_callback);
@@ skipping 31 matching lines @@
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   if (backend_.get()) {
     backend_->Close();
     // Release our reference, it will probably still have a reference if the
     // background thread has not run Close() yet.
     backend_ = NULL;
   }
 }