Add cookie priority to the cookie database.

content/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 "content/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_util.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_util.h"
@@ skipping 273 matching lines @@
   // it is unlikely that a second time will be successful.
   if (!attempted_to_kill_database_ && sql::IsErrorCatastrophic(error)) {
     attempted_to_kill_database_ = true;
 
     backend_->ScheduleKillDatabase();
   }
 
   return error;
 }
 
+namespace {
+
 // Version number of the database.
 //
+// Version 6 adds cookie priorities. This allows developers to influence the
+// order in which cookies are evicted in order to meet domain cookie limits.
+//
 // Version 5 adds the columns has_expires and is_persistent, so that the
 // database can store session cookies as well as persistent cookies. Databases
 // of version 5 are incompatible with older versions of code. If a database of
 // version 5 is read by older code, session cookies will be treated as normal
 // cookies. Currently, these fields are written, but not read anymore.
 //
 // In version 4, we migrated the time epoch.  If you open the DB with an older
 // version on Mac or Linux, the times will look wonky, but the file will likely
 // be usable. On Windows version 3 and 4 are the same.
 //
 // Version 3 updated the database to include the last access time, so we can
 // expire them in decreasing order of use when we've reached the maximum
 // number of cookies.
-static const int kCurrentVersionNumber = 5;
-static const int kCompatibleVersionNumber = 5;
+const int kCurrentVersionNumber = 6;
+const int kCompatibleVersionNumber = 5;
 
-namespace {
+// Possible values for the 'priority' column.
+enum DBCookiePriority {
+  kCookiePriorityLow = 0,
+  kCookiePriorityMedium = 1,
+  kCookiePriorityHigh = 2,
+};
+
+DBCookiePriority CookiePriorityToDBCookiePriority(net::CookiePriority value) {
+  switch (value) {
+    case net::COOKIE_PRIORITY_LOW:
+      return kCookiePriorityLow;
+    case net::COOKIE_PRIORITY_MEDIUM:
+      return kCookiePriorityMedium;
+    case net::COOKIE_PRIORITY_HIGH:
+      return kCookiePriorityHigh;
+  }
+
+  NOTREACHED();
+  return kCookiePriorityMedium;
+}
+
+net::CookiePriority DBCookiePriorityToCookiePriority(DBCookiePriority value) {
+  switch (value) {
+    case kCookiePriorityLow:
+      return net::COOKIE_PRIORITY_LOW;
+    case kCookiePriorityMedium:
+      return net::COOKIE_PRIORITY_MEDIUM;
+    case kCookiePriorityHigh:
+      return net::COOKIE_PRIORITY_HIGH;
+  }
+
+  NOTREACHED();
+  return net::COOKIE_PRIORITY_DEFAULT;
+}
 
 // Increments a specified TimeDelta by the duration between this object's
 // constructor and destructor. Not thread safe. Multiple instances may be
 // created with the same delta instance as long as their lifetimes are nested.
 // The shortest lived instances have no impact.
 class IncrementTimeDelta {
  public:
   explicit IncrementTimeDelta(base::TimeDelta* delta) :
       delta_(delta),
       original_value_(*delta),
       start_(base::Time::Now()) {}
 
   ~IncrementTimeDelta() {
     *delta_ = original_value_ + base::Time::Now() - start_;
   }
 
  private:
   base::TimeDelta* delta_;
   base::TimeDelta original_value_;
   base::Time start_;
 
   DISALLOW_COPY_AND_ASSIGN(IncrementTimeDelta);
 };
 
 // Initializes the cookies table, returning true on success.
 bool InitTable(sql::Connection* db) {
   if (!db->DoesTableExist("cookies")) {
-    if (!db->Execute("CREATE TABLE cookies ("
-                     "creation_utc INTEGER NOT NULL UNIQUE PRIMARY KEY,"
-                     "host_key TEXT NOT NULL,"
-                     "name TEXT NOT NULL,"
-                     "value TEXT NOT NULL,"
-                     "path TEXT NOT NULL,"
-                     "expires_utc INTEGER NOT NULL,"
-                     "secure INTEGER NOT NULL,"
-                     "httponly INTEGER NOT NULL,"
-                     "last_access_utc INTEGER NOT NULL, "
-                     "has_expires INTEGER NOT NULL DEFAULT 1, "
-                     "persistent INTEGER NOT NULL DEFAULT 1)")) {
-      // TODO(rogerm): Add priority.
+    std::string stmt(base::StringPrintf(
+        "CREATE TABLE cookies ("
+            "creation_utc INTEGER NOT NULL UNIQUE PRIMARY KEY,"
+            "host_key TEXT NOT NULL,"
+            "name TEXT NOT NULL,"
+            "value TEXT NOT NULL,"
+            "path TEXT NOT NULL,"
+            "expires_utc INTEGER NOT NULL,"
+            "secure INTEGER NOT NULL,"
+            "httponly INTEGER NOT NULL,"
+            "last_access_utc INTEGER NOT NULL, "
+            "has_expires INTEGER NOT NULL DEFAULT 1, "
+            "persistent INTEGER NOT NULL DEFAULT 1,"
+            "priority INTEGER NOT NULL DEFAULT %d)",
+        CookiePriorityToDBCookiePriority(net::COOKIE_PRIORITY_DEFAULT)));
+    if (!db->Execute(stmt.c_str()))
       return false;
-    }
   }
 
   // Older code created an index on creation_utc, which is already
   // primary key for the table.
   if (!db->Execute("DROP INDEX IF EXISTS cookie_times"))
     return false;
 
   if (!db->Execute("CREATE INDEX IF NOT EXISTS domain ON cookies(host_key)"))
     return false;
 
@@ skipping 265 matching lines @@
   }
 }
 
 bool SQLitePersistentCookieStore::Backend::LoadCookiesForDomains(
   const std::set<std::string>& domains) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
   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 = ?"));
-    // TODO(rogerm): Add priority.
+        SQL_FROM_HERE,
+        "SELECT creation_utc, host_key, name, value, path, expires_utc, "
+        "secure, httponly, last_access_utc, has_expires, persistent, priority "
+        "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"));
-    // TODO(rogerm): Add priority.
+        SQL_FROM_HERE,
+        "SELECT creation_utc, host_key, name, value, path, expires_utc, "
+        "secure, httponly, last_access_utc, has_expires, persistent, priority "
+        "FROM cookies WHERE host_key = ? AND persistent = 1"));
   }
   if (!smt.is_valid()) {
     smt.Clear();  // Disconnect smt_ref from db_.
     meta_table_.Reset();
     db_.reset();
     return false;
   }
 
   std::vector<net::CanonicalCookie*> cookies;
   std::set<std::string>::const_iterator it = domains.begin();
   for (; it != domains.end(); ++it) {
     smt.BindString(0, *it);
     while (smt.Step()) {
-      scoped_ptr<net::CanonicalCookie> cc(
-          new net::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
-              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
-              net::COOKIE_PRIORITY_DEFAULT));                 // priority
-      // TODO(rogerm): Change net::COOKIE_PRIORITY_DEFAULT above to
-      // net::StringToCookiePriority(smt.ColumnString(9))?
+      scoped_ptr<net::CanonicalCookie> cc(new net::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
+          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
+          DBCookiePriorityToCookiePriority(
+              static_cast<DBCookiePriority>(smt.ColumnInt(11)))));  // priority
       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_);
@@ skipping 80 matching lines @@
     }
     ++cur_version;
     meta_table_.SetVersionNumber(cur_version);
     meta_table_.SetCompatibleVersionNumber(
         std::min(cur_version, kCompatibleVersionNumber));
     transaction.Commit();
     UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV5",
                         base::TimeTicks::Now() - start_time);
   }
 
+  if (cur_version == 5) {
+    const base::TimeTicks start_time = base::TimeTicks::Now();
+    sql::Transaction transaction(db_.get());
+    if (!transaction.Begin())
+      return false;
+    // Alter the table to add the priority column with a default value.
+    std::string stmt(base::StringPrintf(
+        "ALTER TABLE cookies ADD COLUMN priority INTEGER DEFAULT %d",
+        CookiePriorityToDBCookiePriority(net::COOKIE_PRIORITY_DEFAULT)));
+    if (!db_->Execute(stmt.c_str())) {
+      LOG(WARNING) << "Unable to update cookie database to version 6.";
+      return false;
+    }
+    ++cur_version;
+    meta_table_.SetVersionNumber(cur_version);
+    meta_table_.SetCompatibleVersionNumber(
+        std::min(cur_version, kCompatibleVersionNumber));
+    transaction.Commit();
+    UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV6",
+                        base::TimeTicks::Now() - start_time);
+  }
+
   // Put future migration cases here.
 
   if (cur_version < kCurrentVersionNumber) {
     UMA_HISTOGRAM_COUNTS_100("Cookie.CorruptMetaTable", 1);
 
     meta_table_.Reset();
     db_.reset(new sql::Connection);
     if (!file_util::Delete(path_, false) ||
         !db_->Open(path_) ||
         !meta_table_.Init(
@@ skipping 63 matching lines @@
   {
     base::AutoLock locked(lock_);
     pending_.swap(ops);
     num_pending_ = 0;
   }
 
   // Maybe an old timer fired or we are already Close()'ed.
   if (!db_.get() || ops.empty())
     return;
 
-  // TODO(rogerm): Add priority.
   sql::Statement add_smt(db_->GetCachedStatement(SQL_FROM_HERE,
       "INSERT INTO cookies (creation_utc, host_key, name, value, path, "
       "expires_utc, secure, httponly, last_access_utc, has_expires, "
-      "persistent) "
-      "VALUES (?,?,?,?,?,?,?,?,?,?,?)"));
+      "persistent, priority) "
+      "VALUES (?,?,?,?,?,?,?,?,?,?,?,?)"));
   if (!add_smt.is_valid())
     return;
 
   sql::Statement update_access_smt(db_->GetCachedStatement(SQL_FROM_HERE,
       "UPDATE cookies SET last_access_utc=? WHERE creation_utc=?"));
   if (!update_access_smt.is_valid())
     return;
 
   sql::Statement del_smt(db_->GetCachedStatement(SQL_FROM_HERE,
                          "DELETE FROM cookies WHERE creation_utc=?"));
@@ skipping 17 matching lines @@
         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().IsPersistent());
         add_smt.BindInt(10, po->cc().IsPersistent());
-        // TODO(rogerm): Add priority.
+        add_smt.BindInt(
+            11, CookiePriorityToDBCookiePriority(po->cc().Priority()));
         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());
@@ skipping 214 matching lines @@
           path,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
               BrowserThread::GetBlockingPool()->GetSequenceToken()),
           restore_old_session_cookies,
           storage_policy);
   return new net::CookieMonster(persistent_store, cookie_monster_delegate);
 }
 
 }  // namespace content