xref: /external/chromium/chrome/browser/net/sqlite_persistent_cookie_store.cc

// Copyright (c) 2011 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 "app/sql/meta_table.h"
#include "app/sql/statement.h"
#include "app/sql/transaction.h"
#include "base/basictypes.h"
#include "base/file_path.h"
#include "base/file_util.h"
#ifdef ANDROID
#include "base/lazy_instance.h"
#endif
#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/threading/thread.h"
#include "base/threading/thread_restrictions.h"
#include "chrome/browser/diagnostics/sqlite_diagnostics.h"
#ifndef ANDROID
#include "content/browser/browser_thread.h"
#endif
#include "googleurl/src/gurl.h"

#ifdef ANDROID
namespace {

// This class is used by CookieMonster, which is threadsafe, so this class must
// be threadsafe too.
base::LazyInstance<base::Lock> db_thread_lock(base::LINKER_INITIALIZED);

base::Thread* getDbThread() {
  base::AutoLock lock(*db_thread_lock.Pointer());

  // FIXME: We should probably be using LazyInstance here.
  static base::Thread* db_thread = NULL;

  if (db_thread && db_thread->IsRunning())
    return db_thread;

  if (!db_thread)
    db_thread = new base::Thread("db");

  if (!db_thread)
    return NULL;

  base::Thread::Options options;
  options.message_loop_type = MessageLoop::TYPE_DEFAULT;
  if (!db_thread->StartWithOptions(options)) {
    delete db_thread;
    db_thread = NULL;
  }
  return db_thread;
}

}  // namespace
#endif

using base::Time;

// This class is designed to be shared between any calling threads and the
// database thread.  It batches operations and commits them on a timer.
class SQLitePersistentCookieStore::Backend
    : public base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend> {
 public:
  explicit Backend(const FilePath& path)
      : path_(path),
        db_(NULL),
        num_pending_(0),
        clear_local_state_on_exit_(false)
#if defined(ANDROID)
        , cookie_count_(0)
#endif
  {
  }

  // Creates or load the SQLite database.
  bool Load(std::vector<net::CookieMonster::CanonicalCookie*>* cookies);

  // Batch a cookie addition.
  void AddCookie(const net::CookieMonster::CanonicalCookie& cc);

  // Batch a cookie access time update.
  void UpdateCookieAccessTime(const net::CookieMonster::CanonicalCookie& cc);

  // Batch a cookie deletion.
  void DeleteCookie(const net::CookieMonster::CanonicalCookie& cc);

  // Commit pending operations as soon as possible.
  void Flush(Task* completion_task);

  // Commit any pending operations and close the database.  This must be called
  // before the object is destructed.
  void Close();

  void SetClearLocalStateOnExit(bool clear_local_state);

#if defined(ANDROID)
  int get_cookie_count() const { return cookie_count_; }
  void set_cookie_count(int count) { cookie_count_ = count; }
#endif

 private:
  friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;

  // You should call Close() before destructing this object.
  ~Backend() {
    DCHECK(!db_.get()) << "Close should have already been called.";
    DCHECK(num_pending_ == 0 && pending_.empty());
  }

  // Database upgrade statements.
  bool EnsureDatabaseVersion();

  class PendingOperation {
   public:
    typedef enum {
      COOKIE_ADD,
      COOKIE_UPDATEACCESS,
      COOKIE_DELETE,
    } OperationType;

    PendingOperation(OperationType op,
                     const net::CookieMonster::CanonicalCookie& cc)
        : op_(op), cc_(cc) { }

    OperationType op() const { return op_; }
    const net::CookieMonster::CanonicalCookie& cc() const { return cc_; }

   private:
    OperationType op_;
    net::CookieMonster::CanonicalCookie cc_;
  };

 private:
  // Batch a cookie operation (add or delete)
  void BatchOperation(PendingOperation::OperationType op,
                      const net::CookieMonster::CanonicalCookie& cc);
  // Commit our pending operations to the database.
#if defined(ANDROID)
  void Commit(Task* completion_task);
#else
  void Commit();
#endif
  // Close() executed on the background thread.
  void InternalBackgroundClose();

  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 |pending_|, |num_pending_| and |clear_local_state_on_exit_|.
  base::Lock lock_;

#if defined(ANDROID)
  // Number of cookies that have actually been saved. Updated during Commit().
  volatile int cookie_count_;
#endif

  DISALLOW_COPY_AND_ASSIGN(Backend);
};

// Version number of the database. 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 = 4;
static const int kCompatibleVersionNumber = 3;

namespace {

// 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,"
#if defined(ANDROID)
                     // On some mobile platforms, we persist session cookies
                     // because the OS can kill the browser during a session.
                     // If so, expires_utc is set to 0. When the field is read
                     // into a Time object, Time::is_null() will return true.
#else
                     // We only store persistent, so we know it expires
#endif
                     "expires_utc INTEGER NOT NULL,"
                     "secure INTEGER NOT NULL,"
                     "httponly INTEGER NOT NULL,"
                     "last_access_utc INTEGER NOT NULL)"))
      return false;
  }

  // Try to create the index every time. Older versions did not have this index,
  // so we want those people to get it. Ignore errors, since it may exist.
  db->Execute(
      "CREATE INDEX IF NOT EXISTS cookie_times ON cookies (creation_utc)");
  return true;
}

}  // namespace

bool SQLitePersistentCookieStore::Backend::Load(
    std::vector<net::CookieMonster::CanonicalCookie*>* cookies) {
  // This function should be called only once per instance.
  DCHECK(!db_.get());

  // Ensure the parent directory for storing cookies is created before reading
  // from it.  We make an exception to allow IO on the UI thread here because
  // we are going to disk anyway in db_->Open.  (This code will be moved to the
  // DB thread as part of http://crbug.com/52909.)
  {
    base::ThreadRestrictions::ScopedAllowIO allow_io;
    const FilePath dir = path_.DirName();
    if (!file_util::PathExists(dir) && !file_util::CreateDirectory(dir))
      return false;
  }

  db_.reset(new sql::Connection);
  if (!db_->Open(path_)) {
    NOTREACHED() << "Unable to open cookie DB.";
    db_.reset();
    return false;
  }

#ifndef ANDROID
  // GetErrorHandlerForCookieDb is defined in sqlite_diagnostics.h
  // which we do not currently include on Android
  db_->set_error_delegate(GetErrorHandlerForCookieDb());
#endif

  if (!EnsureDatabaseVersion() || !InitTable(db_.get())) {
    NOTREACHED() << "Unable to open cookie DB.";
    db_.reset();
    return false;
  }

  db_->Preload();

  // Slurp all the cookies into the out-vector.
  sql::Statement smt(db_->GetUniqueStatement(
      "SELECT creation_utc, host_key, name, value, path, expires_utc, secure, "
      "httponly, last_access_utc FROM cookies"));
  if (!smt) {
    NOTREACHED() << "select statement prep failed";
    db_.reset();
    return false;
  }

  while (smt.Step()) {
#if defined(ANDROID)
    base::Time expires = Time::FromInternalValue(smt.ColumnInt64(5));
#endif
    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
            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
#if defined(ANDROID)
            !expires.is_null()));                           // has_expires
#else
            true));                                         // has_expires
#endif
    DLOG_IF(WARNING,
            cc->CreationDate() > Time::Now()) << L"CreationDate too recent";
    cookies->push_back(cc.release());
  }

#ifdef ANDROID
  set_cookie_count(cookies->size());
#endif

  return true;
}

bool SQLitePersistentCookieStore::Backend::EnsureDatabaseVersion() {
  // Version check.
  if (!meta_table_.Init(
      db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) {
    return false;
  }

  if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
    LOG(WARNING) << "Cookie database is too new.";
    return false;
  }

  int cur_version = meta_table_.GetVersionNumber();
  if (cur_version == 2) {
    sql::Transaction transaction(db_.get());
    if (!transaction.Begin())
      return false;
    if (!db_->Execute("ALTER TABLE cookies ADD COLUMN last_access_utc "
                     "INTEGER DEFAULT 0") ||
        !db_->Execute("UPDATE cookies SET last_access_utc = creation_utc")) {
      LOG(WARNING) << "Unable to update cookie database to version 3.";
      return false;
    }
    ++cur_version;
    meta_table_.SetVersionNumber(cur_version);
    meta_table_.SetCompatibleVersionNumber(
        std::min(cur_version, kCompatibleVersionNumber));
    transaction.Commit();
  }

  if (cur_version == 3) {
    // The time epoch changed for Mac & Linux in this version to match Windows.
    // This patch came after the main epoch change happened, so some
    // developers have "good" times for cookies added by the more recent
    // versions. So we have to be careful to only update times that are under
    // the old system (which will appear to be from before 1970 in the new
    // system). The magic number used below is 1970 in our time units.
    sql::Transaction transaction(db_.get());
    transaction.Begin();
#if !defined(OS_WIN)
    db_->Execute(
        "UPDATE cookies "
        "SET creation_utc = creation_utc + 11644473600000000 "
        "WHERE rowid IN "
        "(SELECT rowid FROM cookies WHERE "
          "creation_utc > 0 AND creation_utc < 11644473600000000)");
    db_->Execute(
        "UPDATE cookies "
        "SET expires_utc = expires_utc + 11644473600000000 "
        "WHERE rowid IN "
        "(SELECT rowid FROM cookies WHERE "
          "expires_utc > 0 AND expires_utc < 11644473600000000)");
    db_->Execute(
        "UPDATE cookies "
        "SET last_access_utc = last_access_utc + 11644473600000000 "
        "WHERE rowid IN "
        "(SELECT rowid FROM cookies WHERE "
          "last_access_utc > 0 AND last_access_utc < 11644473600000000)");
#endif
    ++cur_version;
    meta_table_.SetVersionNumber(cur_version);
    transaction.Commit();
  }

  // Put future migration cases here.

  // When the version is too old, we just try to continue anyway, there should
  // not be a released product that makes a database too old for us to handle.
  LOG_IF(WARNING, cur_version < kCurrentVersionNumber) <<
      "Cookie database version " << cur_version << " is too old to handle.";

  return true;
}

void SQLitePersistentCookieStore::Backend::AddCookie(
    const net::CookieMonster::CanonicalCookie& cc) {
  BatchOperation(PendingOperation::COOKIE_ADD, cc);
}

void SQLitePersistentCookieStore::Backend::UpdateCookieAccessTime(
    const net::CookieMonster::CanonicalCookie& cc) {
  BatchOperation(PendingOperation::COOKIE_UPDATEACCESS, cc);
}

void SQLitePersistentCookieStore::Backend::DeleteCookie(
    const net::CookieMonster::CanonicalCookie& cc) {
  BatchOperation(PendingOperation::COOKIE_DELETE, cc);
}

void SQLitePersistentCookieStore::Backend::BatchOperation(
    PendingOperation::OperationType op,
    const net::CookieMonster::CanonicalCookie& cc) {
  // Commit every 30 seconds.
  static const int kCommitIntervalMs = 30 * 1000;
  // Commit right away if we have more than 512 outstanding operations.
  static const size_t kCommitAfterBatchSize = 512;
#ifndef ANDROID
  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::DB));
#endif

  // We do a full copy of the cookie here, and hopefully just here.
  scoped_ptr<PendingOperation> po(new PendingOperation(op, cc));

  PendingOperationsList::size_type num_pending;
  {
    base::AutoLock locked(lock_);
    pending_.push_back(po.release());
    num_pending = ++num_pending_;
  }

#ifdef ANDROID
  if (!getDbThread())
    return;
  MessageLoop* loop = getDbThread()->message_loop();
#endif

  if (num_pending == 1) {
    // We've gotten our first entry for this batch, fire off the timer.
#ifdef ANDROID
    loop->PostDelayedTask(FROM_HERE, NewRunnableMethod(
        this, &Backend::Commit, static_cast<Task*>(NULL)), kCommitIntervalMs);
#else
    BrowserThread::PostDelayedTask(
        BrowserThread::DB, FROM_HERE,
        NewRunnableMethod(this, &Backend::Commit), kCommitIntervalMs);
#endif
  } else if (num_pending == kCommitAfterBatchSize) {
    // We've reached a big enough batch, fire off a commit now.
#ifdef ANDROID
    loop->PostTask(FROM_HERE, NewRunnableMethod(
        this, &Backend::Commit, static_cast<Task*>(NULL)));
#else
    BrowserThread::PostTask(
        BrowserThread::DB, FROM_HERE,
        NewRunnableMethod(this, &Backend::Commit));
#endif
  }
}

#if defined(ANDROID)
void SQLitePersistentCookieStore::Backend::Commit(Task* completion_task) {
#else
void SQLitePersistentCookieStore::Backend::Commit() {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
#endif

#if defined(ANDROID)
  if (completion_task) {
    // We post this task to the current thread, so it won't run until we exit.
    MessageLoop::current()->PostTask(FROM_HERE, completion_task);
  }
#endif

  PendingOperationsList ops;
  {
    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;

  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) "
      "VALUES (?,?,?,?,?,?,?,?,?)"));
  if (!add_smt) {
    NOTREACHED();
    return;
  }

  sql::Statement update_access_smt(db_->GetCachedStatement(SQL_FROM_HERE,
      "UPDATE cookies SET last_access_utc=? WHERE creation_utc=?"));
  if (!update_access_smt) {
    NOTREACHED();
    return;
  }

  sql::Statement del_smt(db_->GetCachedStatement(SQL_FROM_HERE,
                         "DELETE FROM cookies WHERE creation_utc=?"));
  if (!del_smt) {
    NOTREACHED();
    return;
  }

  sql::Transaction transaction(db_.get());
  if (!transaction.Begin()) {
    NOTREACHED();
    return;
  }
#if defined(ANDROID)
  int cookie_delta = 0;
#endif
  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:
#if defined(ANDROID)
        ++cookie_delta;
#endif
        add_smt.Reset();
        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());
        if (!add_smt.Run())
          NOTREACHED() << "Could not add a cookie to the DB.";
        break;

      case PendingOperation::COOKIE_UPDATEACCESS:
        update_access_smt.Reset();
        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:
#if defined(ANDROID)
        --cookie_delta;
#endif
        del_smt.Reset();
        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();
#if defined(ANDROID)
  if (succeeded)
      cookie_count_ += cookie_delta;
#endif
  UMA_HISTOGRAM_ENUMERATION("Cookie.BackingStoreUpdateResults",
                            succeeded ? 0 : 1, 2);
}

void SQLitePersistentCookieStore::Backend::Flush(Task* completion_task) {
#if defined(ANDROID)
    if (!getDbThread()) {
      if (completion_task)
        MessageLoop::current()->PostTask(FROM_HERE, completion_task);
      return;
    }

    MessageLoop* loop = getDbThread()->message_loop();
    loop->PostTask(FROM_HERE, NewRunnableMethod(
        this, &Backend::Commit, completion_task));
#else
  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::DB));
  BrowserThread::PostTask(
      BrowserThread::DB, FROM_HERE, NewRunnableMethod(this, &Backend::Commit));
  if (completion_task) {
    // We want the completion task to run immediately after Commit() returns.
    // Posting it from here means there is less chance of another task getting
    // onto the message queue first, than if we posted it from Commit() itself.
    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, completion_task);
  }
#endif
}

// Fire off a close message to the background thread.  We could still have a
// pending commit timer that will be holding a reference on us, but if/when
// this fires we will already have been cleaned up and it will be ignored.
void SQLitePersistentCookieStore::Backend::Close() {
#ifndef ANDROID
  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::DB));
#endif

#ifdef ANDROID
  if (!getDbThread())
    return;

  MessageLoop* loop = getDbThread()->message_loop();
  loop->PostTask(FROM_HERE,
      NewRunnableMethod(this, &Backend::InternalBackgroundClose));
#else
  // Must close the backend on the background thread.
  BrowserThread::PostTask(
      BrowserThread::DB, FROM_HERE,
      NewRunnableMethod(this, &Backend::InternalBackgroundClose));
#endif
}

void SQLitePersistentCookieStore::Backend::InternalBackgroundClose() {
#ifndef ANDROID
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
#endif
  // Commit any pending operations
#if defined(ANDROID)
  Commit(NULL);
#else
  Commit();
#endif

  db_.reset();

  if (clear_local_state_on_exit_)
    file_util::Delete(path_, false);
}

void SQLitePersistentCookieStore::Backend::SetClearLocalStateOnExit(
    bool clear_local_state) {
  base::AutoLock locked(lock_);
  clear_local_state_on_exit_ = clear_local_state;
}
SQLitePersistentCookieStore::SQLitePersistentCookieStore(const FilePath& path)
    : backend_(new Backend(path)) {
}

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;
  }
}

bool SQLitePersistentCookieStore::Load(
    std::vector<net::CookieMonster::CanonicalCookie*>* cookies) {
  return backend_->Load(cookies);
}

void SQLitePersistentCookieStore::AddCookie(
    const net::CookieMonster::CanonicalCookie& cc) {
  if (backend_.get())
    backend_->AddCookie(cc);
}

void SQLitePersistentCookieStore::UpdateCookieAccessTime(
    const net::CookieMonster::CanonicalCookie& cc) {
  if (backend_.get())
    backend_->UpdateCookieAccessTime(cc);
}

void SQLitePersistentCookieStore::DeleteCookie(
    const net::CookieMonster::CanonicalCookie& cc) {
  if (backend_.get())
    backend_->DeleteCookie(cc);
}

void SQLitePersistentCookieStore::SetClearLocalStateOnExit(
    bool clear_local_state) {
  if (backend_.get())
    backend_->SetClearLocalStateOnExit(clear_local_state);
}

void SQLitePersistentCookieStore::Flush(Task* completion_task) {
  if (backend_.get())
    backend_->Flush(completion_task);
  else if (completion_task)
    MessageLoop::current()->PostTask(FROM_HERE, completion_task);
}

#if defined(ANDROID)
int SQLitePersistentCookieStore::GetCookieCount() {
  int result = backend_ ? backend_->get_cookie_count() : 0;
  return result;
}
#endif