src/chrome/browser/net/sqlite_channel_id_store.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/net/sqlite_channel_id_store.h"
   6
   7 #include <list>
   8 #include <set>
   9
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/file_util.h"
  13 #include "base/files/file_path.h"
  14 #include "base/logging.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/threading/thread.h"
  19 #include "base/threading/thread_restrictions.h"
  20 #include "net/cert/x509_certificate.h"
  21 #include "net/cookies/cookie_util.h"
  22 #include "net/ssl/ssl_client_cert_type.h"
  23 #include "sql/error_delegate_util.h"
  24 #include "sql/meta_table.h"
  25 #include "sql/statement.h"
  26 #include "sql/transaction.h"
  27 #include "third_party/sqlite/sqlite3.h"
  28 #include "url/gurl.h"
  29 #include "webkit/browser/quota/special_storage_policy.h"
  30
  31 // This class is designed to be shared between any calling threads and the
  32 // background task runner. It batches operations and commits them on a timer.
  33 class SQLiteChannelIDStore::Backend
  34     : public base::RefCountedThreadSafe<SQLiteChannelIDStore::Backend> {
  35  public:
  36   Backend(
  37       const base::FilePath& path,
  38       const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
  39       quota::SpecialStoragePolicy* special_storage_policy)
  40       : path_(path),
  41         num_pending_(0),
  42         force_keep_session_state_(false),
  43         background_task_runner_(background_task_runner),
  44         special_storage_policy_(special_storage_policy),
  45         corruption_detected_(false) {}
  46
  47   // Creates or loads the SQLite database.
  48   void Load(const LoadedCallback& loaded_callback);
  49
  50   // Batch a channel ID addition.
  51   void AddChannelID(
  52       const net::DefaultChannelIDStore::ChannelID& channel_id);
  53
  54   // Batch a channel ID deletion.
  55   void DeleteChannelID(
  56       const net::DefaultChannelIDStore::ChannelID& channel_id);
  57
  58   // Commit any pending operations and close the database.  This must be called
  59   // before the object is destructed.
  60   void Close();
  61
  62   void SetForceKeepSessionState();
  63
  64  private:
  65   void LoadOnDBThread(
  66       ScopedVector<net::DefaultChannelIDStore::ChannelID>* channel_ids);
  67
  68   friend class base::RefCountedThreadSafe<SQLiteChannelIDStore::Backend>;
  69
  70   // You should call Close() before destructing this object.
  71   ~Backend() {
  72     DCHECK(!db_.get()) << "Close should have already been called.";
  73     DCHECK(num_pending_ == 0 && pending_.empty());
  74   }
  75
  76   // Database upgrade statements.
  77   bool EnsureDatabaseVersion();
  78
  79   class PendingOperation {
  80    public:
  81     typedef enum {
  82       CHANNEL_ID_ADD,
  83       CHANNEL_ID_DELETE
  84     } OperationType;
  85
  86     PendingOperation(
  87         OperationType op,
  88         const net::DefaultChannelIDStore::ChannelID& channel_id)
  89         : op_(op), channel_id_(channel_id) {}
  90
  91     OperationType op() const { return op_; }
  92     const net::DefaultChannelIDStore::ChannelID& channel_id() const {
  93         return channel_id_;
  94     }
  95
  96    private:
  97     OperationType op_;
  98     net::DefaultChannelIDStore::ChannelID channel_id_;
  99   };
 100
 101  private:
 102   // Batch a channel id operation (add or delete).
 103   void BatchOperation(
 104       PendingOperation::OperationType op,
 105       const net::DefaultChannelIDStore::ChannelID& channel_id);
 106   // Commit our pending operations to the database.
 107   void Commit();
 108   // Close() executed on the background thread.
 109   void InternalBackgroundClose();
 110
 111   void DeleteCertificatesOnShutdown();
 112
 113   void DatabaseErrorCallback(int error, sql::Statement* stmt);
 114   void KillDatabase();
 115
 116   base::FilePath path_;
 117   scoped_ptr<sql::Connection> db_;
 118   sql::MetaTable meta_table_;
 119
 120   typedef std::list<PendingOperation*> PendingOperationsList;
 121   PendingOperationsList pending_;
 122   PendingOperationsList::size_type num_pending_;
 123   // True if the persistent store should skip clear on exit rules.
 124   bool force_keep_session_state_;
 125   // Guard |pending_|, |num_pending_| and |force_keep_session_state_|.
 126   base::Lock lock_;
 127
 128   // Cache of origins we have channel IDs stored for.
 129   std::set<std::string> channel_id_origins_;
 130
 131   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 132
 133   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
 134
 135   // Indicates if the kill-database callback has been scheduled.
 136   bool corruption_detected_;
 137
 138   DISALLOW_COPY_AND_ASSIGN(Backend);
 139 };
 140
 141 // Version number of the database.
 142 static const int kCurrentVersionNumber = 4;
 143 static const int kCompatibleVersionNumber = 1;
 144
 145 namespace {
 146
 147 // Initializes the certs table, returning true on success.
 148 bool InitTable(sql::Connection* db) {
 149   // The table is named "origin_bound_certs" for backwards compatability before
 150   // we renamed this class to SQLiteChannelIDStore.  Likewise, the primary
 151   // key is "origin", but now can be other things like a plain domain.
 152   if (!db->DoesTableExist("origin_bound_certs")) {
 153     if (!db->Execute("CREATE TABLE origin_bound_certs ("
 154                      "origin TEXT NOT NULL UNIQUE PRIMARY KEY,"
 155                      "private_key BLOB NOT NULL,"
 156                      "cert BLOB NOT NULL,"
 157                      "cert_type INTEGER,"
 158                      "expiration_time INTEGER,"
 159                      "creation_time INTEGER)"))
 160       return false;
 161   }
 162
 163   return true;
 164 }
 165
 166 }  // namespace
 167
 168 void SQLiteChannelIDStore::Backend::Load(
 169     const LoadedCallback& loaded_callback) {
 170   // This function should be called only once per instance.
 171   DCHECK(!db_.get());
 172   scoped_ptr<ScopedVector<net::DefaultChannelIDStore::ChannelID> >
 173       channel_ids(new ScopedVector<net::DefaultChannelIDStore::ChannelID>());
 174   ScopedVector<net::DefaultChannelIDStore::ChannelID>* channel_ids_ptr =
 175       channel_ids.get();
 176
 177   background_task_runner_->PostTaskAndReply(
 178       FROM_HERE,
 179       base::Bind(&Backend::LoadOnDBThread, this, channel_ids_ptr),
 180       base::Bind(loaded_callback, base::Passed(&channel_ids)));
 181 }
 182
 183 void SQLiteChannelIDStore::Backend::LoadOnDBThread(
 184     ScopedVector<net::DefaultChannelIDStore::ChannelID>* channel_ids) {
 185   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 186
 187   // This method should be called only once per instance.
 188   DCHECK(!db_.get());
 189
 190   base::TimeTicks start = base::TimeTicks::Now();
 191
 192   // Ensure the parent directory for storing certs is created before reading
 193   // from it.
 194   const base::FilePath dir = path_.DirName();
 195   if (!base::PathExists(dir) && !base::CreateDirectory(dir))
 196     return;
 197
 198   int64 db_size = 0;
 199   if (base::GetFileSize(path_, &db_size))
 200     UMA_HISTOGRAM_COUNTS("DomainBoundCerts.DBSizeInKB", db_size / 1024 );
 201
 202   db_.reset(new sql::Connection);
 203   db_->set_histogram_tag("DomainBoundCerts");
 204
 205   // Unretained to avoid a ref loop with db_.
 206   db_->set_error_callback(
 207       base::Bind(&SQLiteChannelIDStore::Backend::DatabaseErrorCallback,
 208                  base::Unretained(this)));
 209
 210   if (!db_->Open(path_)) {
 211     NOTREACHED() << "Unable to open cert DB.";
 212     if (corruption_detected_)
 213       KillDatabase();
 214     db_.reset();
 215     return;
 216   }
 217
 218   if (!EnsureDatabaseVersion() || !InitTable(db_.get())) {
 219     NOTREACHED() << "Unable to open cert DB.";
 220     if (corruption_detected_)
 221       KillDatabase();
 222     meta_table_.Reset();
 223     db_.reset();
 224     return;
 225   }
 226
 227   db_->Preload();
 228
 229   // Slurp all the certs into the out-vector.
 230   sql::Statement smt(db_->GetUniqueStatement(
 231       "SELECT origin, private_key, cert, cert_type, expiration_time, "
 232       "creation_time FROM origin_bound_certs"));
 233   if (!smt.is_valid()) {
 234     if (corruption_detected_)
 235       KillDatabase();
 236     meta_table_.Reset();
 237     db_.reset();
 238     return;
 239   }
 240
 241   while (smt.Step()) {
 242     net::SSLClientCertType type =
 243         static_cast<net::SSLClientCertType>(smt.ColumnInt(3));
 244     if (type != net::CLIENT_CERT_ECDSA_SIGN)
 245       continue;
 246     std::string private_key_from_db, cert_from_db;
 247     smt.ColumnBlobAsString(1, &private_key_from_db);
 248     smt.ColumnBlobAsString(2, &cert_from_db);
 249     scoped_ptr<net::DefaultChannelIDStore::ChannelID> channel_id(
 250         new net::DefaultChannelIDStore::ChannelID(
 251             smt.ColumnString(0),  // origin
 252             base::Time::FromInternalValue(smt.ColumnInt64(5)),
 253             base::Time::FromInternalValue(smt.ColumnInt64(4)),
 254             private_key_from_db,
 255             cert_from_db));
 256     channel_id_origins_.insert(channel_id->server_identifier());
 257     channel_ids->push_back(channel_id.release());
 258   }
 259
 260   UMA_HISTOGRAM_COUNTS_10000("DomainBoundCerts.DBLoadedCount",
 261                              channel_ids->size());
 262   base::TimeDelta load_time = base::TimeTicks::Now() - start;
 263   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.DBLoadTime",
 264                              load_time,
 265                              base::TimeDelta::FromMilliseconds(1),
 266                              base::TimeDelta::FromMinutes(1),
 267                              50);
 268   DVLOG(1) << "loaded " << channel_ids->size() << " in "
 269            << load_time.InMilliseconds() << " ms";
 270 }
 271
 272 bool SQLiteChannelIDStore::Backend::EnsureDatabaseVersion() {
 273   // Version check.
 274   if (!meta_table_.Init(
 275       db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) {
 276     return false;
 277   }
 278
 279   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
 280     LOG(WARNING) << "Server bound cert database is too new.";
 281     return false;
 282   }
 283
 284   int cur_version = meta_table_.GetVersionNumber();
 285   if (cur_version == 1) {
 286     sql::Transaction transaction(db_.get());
 287     if (!transaction.Begin())
 288       return false;
 289     if (!db_->Execute("ALTER TABLE origin_bound_certs ADD COLUMN cert_type "
 290                       "INTEGER")) {
 291       LOG(WARNING) << "Unable to update server bound cert database to "
 292                    << "version 2.";
 293       return false;
 294     }
 295     // All certs in version 1 database are rsa_sign, which are unsupported.
 296     // Just discard them all.
 297     if (!db_->Execute("DELETE from origin_bound_certs")) {
 298       LOG(WARNING) << "Unable to update server bound cert database to "
 299                    << "version 2.";
 300       return false;
 301     }
 302     ++cur_version;
 303     meta_table_.SetVersionNumber(cur_version);
 304     meta_table_.SetCompatibleVersionNumber(
 305         std::min(cur_version, kCompatibleVersionNumber));
 306     transaction.Commit();
 307   }
 308
 309   if (cur_version <= 3) {
 310     sql::Transaction transaction(db_.get());
 311     if (!transaction.Begin())
 312       return false;
 313
 314     if (cur_version == 2) {
 315       if (!db_->Execute("ALTER TABLE origin_bound_certs ADD COLUMN "
 316                         "expiration_time INTEGER")) {
 317         LOG(WARNING) << "Unable to update server bound cert database to "
 318                      << "version 4.";
 319         return false;
 320       }
 321     }
 322
 323     if (!db_->Execute("ALTER TABLE origin_bound_certs ADD COLUMN "
 324                       "creation_time INTEGER")) {
 325       LOG(WARNING) << "Unable to update server bound cert database to "
 326                    << "version 4.";
 327       return false;
 328     }
 329
 330     sql::Statement smt(db_->GetUniqueStatement(
 331         "SELECT origin, cert FROM origin_bound_certs"));
 332     sql::Statement update_expires_smt(db_->GetUniqueStatement(
 333         "UPDATE origin_bound_certs SET expiration_time = ? WHERE origin = ?"));
 334     sql::Statement update_creation_smt(db_->GetUniqueStatement(
 335         "UPDATE origin_bound_certs SET creation_time = ? WHERE origin = ?"));
 336     if (!smt.is_valid() ||
 337         !update_expires_smt.is_valid() ||
 338         !update_creation_smt.is_valid()) {
 339       LOG(WARNING) << "Unable to update server bound cert database to "
 340                    << "version 4.";
 341       return false;
 342     }
 343
 344     while (smt.Step()) {
 345       std::string origin = smt.ColumnString(0);
 346       std::string cert_from_db;
 347       smt.ColumnBlobAsString(1, &cert_from_db);
 348       // Parse the cert and extract the real value and then update the DB.
 349       scoped_refptr<net::X509Certificate> cert(
 350           net::X509Certificate::CreateFromBytes(
 351               cert_from_db.data(), cert_from_db.size()));
 352       if (cert.get()) {
 353         if (cur_version == 2) {
 354           update_expires_smt.Reset(true);
 355           update_expires_smt.BindInt64(0,
 356                                        cert->valid_expiry().ToInternalValue());
 357           update_expires_smt.BindString(1, origin);
 358           if (!update_expires_smt.Run()) {
 359             LOG(WARNING) << "Unable to update server bound cert database to "
 360                          << "version 4.";
 361             return false;
 362           }
 363         }
 364
 365         update_creation_smt.Reset(true);
 366         update_creation_smt.BindInt64(0, cert->valid_start().ToInternalValue());
 367         update_creation_smt.BindString(1, origin);
 368         if (!update_creation_smt.Run()) {
 369           LOG(WARNING) << "Unable to update server bound cert database to "
 370                        << "version 4.";
 371           return false;
 372         }
 373       } else {
 374         // If there's a cert we can't parse, just leave it.  It'll get replaced
 375         // with a new one if we ever try to use it.
 376         LOG(WARNING) << "Error parsing cert for database upgrade for origin "
 377                      << smt.ColumnString(0);
 378       }
 379     }
 380
 381     cur_version = 4;
 382     meta_table_.SetVersionNumber(cur_version);
 383     meta_table_.SetCompatibleVersionNumber(
 384         std::min(cur_version, kCompatibleVersionNumber));
 385     transaction.Commit();
 386   }
 387
 388   // Put future migration cases here.
 389
 390   // When the version is too old, we just try to continue anyway, there should
 391   // not be a released product that makes a database too old for us to handle.
 392   LOG_IF(WARNING, cur_version < kCurrentVersionNumber) <<
 393       "Server bound cert database version " << cur_version <<
 394       " is too old to handle.";
 395
 396   return true;
 397 }
 398
 399 void SQLiteChannelIDStore::Backend::DatabaseErrorCallback(
 400     int error,
 401     sql::Statement* stmt) {
 402   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 403
 404   if (!sql::IsErrorCatastrophic(error))
 405     return;
 406
 407   // TODO(shess): Running KillDatabase() multiple times should be
 408   // safe.
 409   if (corruption_detected_)
 410     return;
 411
 412   corruption_detected_ = true;
 413
 414   // TODO(shess): Consider just calling RazeAndClose() immediately.
 415   // db_ may not be safe to reset at this point, but RazeAndClose()
 416   // would cause the stack to unwind safely with errors.
 417   background_task_runner_->PostTask(FROM_HERE,
 418                                     base::Bind(&Backend::KillDatabase, this));
 419 }
 420
 421 void SQLiteChannelIDStore::Backend::KillDatabase() {
 422   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 423
 424   if (db_) {
 425     // This Backend will now be in-memory only. In a future run the database
 426     // will be recreated. Hopefully things go better then!
 427     bool success = db_->RazeAndClose();
 428     UMA_HISTOGRAM_BOOLEAN("DomainBoundCerts.KillDatabaseResult", success);
 429     meta_table_.Reset();
 430     db_.reset();
 431   }
 432 }
 433
 434 void SQLiteChannelIDStore::Backend::AddChannelID(
 435     const net::DefaultChannelIDStore::ChannelID& channel_id) {
 436   BatchOperation(PendingOperation::CHANNEL_ID_ADD, channel_id);
 437 }
 438
 439 void SQLiteChannelIDStore::Backend::DeleteChannelID(
 440     const net::DefaultChannelIDStore::ChannelID& channel_id) {
 441   BatchOperation(PendingOperation::CHANNEL_ID_DELETE, channel_id);
 442 }
 443
 444 void SQLiteChannelIDStore::Backend::BatchOperation(
 445     PendingOperation::OperationType op,
 446     const net::DefaultChannelIDStore::ChannelID& channel_id) {
 447   // Commit every 30 seconds.
 448   static const int kCommitIntervalMs = 30 * 1000;
 449   // Commit right away if we have more than 512 outstanding operations.
 450   static const size_t kCommitAfterBatchSize = 512;
 451
 452   // We do a full copy of the cert here, and hopefully just here.
 453   scoped_ptr<PendingOperation> po(new PendingOperation(op, channel_id));
 454
 455   PendingOperationsList::size_type num_pending;
 456   {
 457     base::AutoLock locked(lock_);
 458     pending_.push_back(po.release());
 459     num_pending = ++num_pending_;
 460   }
 461
 462   if (num_pending == 1) {
 463     // We've gotten our first entry for this batch, fire off the timer.
 464     background_task_runner_->PostDelayedTask(
 465         FROM_HERE,
 466         base::Bind(&Backend::Commit, this),
 467         base::TimeDelta::FromMilliseconds(kCommitIntervalMs));
 468   } else if (num_pending == kCommitAfterBatchSize) {
 469     // We've reached a big enough batch, fire off a commit now.
 470     background_task_runner_->PostTask(FROM_HERE,
 471                                       base::Bind(&Backend::Commit, this));
 472   }
 473 }
 474
 475 void SQLiteChannelIDStore::Backend::Commit() {
 476   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 477
 478   PendingOperationsList ops;
 479   {
 480     base::AutoLock locked(lock_);
 481     pending_.swap(ops);
 482     num_pending_ = 0;
 483   }
 484
 485   // Maybe an old timer fired or we are already Close()'ed.
 486   if (!db_.get() || ops.empty())
 487     return;
 488
 489   sql::Statement add_smt(db_->GetCachedStatement(SQL_FROM_HERE,
 490       "INSERT INTO origin_bound_certs (origin, private_key, cert, cert_type, "
 491       "expiration_time, creation_time) VALUES (?,?,?,?,?,?)"));
 492   if (!add_smt.is_valid())
 493     return;
 494
 495   sql::Statement del_smt(db_->GetCachedStatement(SQL_FROM_HERE,
 496                              "DELETE FROM origin_bound_certs WHERE origin=?"));
 497   if (!del_smt.is_valid())
 498     return;
 499
 500   sql::Transaction transaction(db_.get());
 501   if (!transaction.Begin())
 502     return;
 503
 504   for (PendingOperationsList::iterator it = ops.begin();
 505        it != ops.end(); ++it) {
 506     // Free the certs as we commit them to the database.
 507     scoped_ptr<PendingOperation> po(*it);
 508     switch (po->op()) {
 509       case PendingOperation::CHANNEL_ID_ADD: {
 510         channel_id_origins_.insert(po->channel_id().server_identifier());
 511         add_smt.Reset(true);
 512         add_smt.BindString(0, po->channel_id().server_identifier());
 513         const std::string& private_key = po->channel_id().private_key();
 514         add_smt.BindBlob(1, private_key.data(), private_key.size());
 515         const std::string& cert = po->channel_id().cert();
 516         add_smt.BindBlob(2, cert.data(), cert.size());
 517         add_smt.BindInt(3, net::CLIENT_CERT_ECDSA_SIGN);
 518         add_smt.BindInt64(4,
 519                           po->channel_id().expiration_time().ToInternalValue());
 520         add_smt.BindInt64(5,
 521                           po->channel_id().creation_time().ToInternalValue());
 522         if (!add_smt.Run())
 523           NOTREACHED() << "Could not add a server bound cert to the DB.";
 524         break;
 525       }
 526       case PendingOperation::CHANNEL_ID_DELETE:
 527         channel_id_origins_.erase(po->channel_id().server_identifier());
 528         del_smt.Reset(true);
 529         del_smt.BindString(0, po->channel_id().server_identifier());
 530         if (!del_smt.Run())
 531           NOTREACHED() << "Could not delete a server bound cert from the DB.";
 532         break;
 533
 534       default:
 535         NOTREACHED();
 536         break;
 537     }
 538   }
 539   transaction.Commit();
 540 }
 541
 542 // Fire off a close message to the background thread. We could still have a
 543 // pending commit timer that will be holding a reference on us, but if/when
 544 // this fires we will already have been cleaned up and it will be ignored.
 545 void SQLiteChannelIDStore::Backend::Close() {
 546   // Must close the backend on the background thread.
 547   background_task_runner_->PostTask(
 548       FROM_HERE, base::Bind(&Backend::InternalBackgroundClose, this));
 549 }
 550
 551 void SQLiteChannelIDStore::Backend::InternalBackgroundClose() {
 552   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 553   // Commit any pending operations
 554   Commit();
 555
 556   if (!force_keep_session_state_ &&
 557       special_storage_policy_.get() &&
 558       special_storage_policy_->HasSessionOnlyOrigins()) {
 559     DeleteCertificatesOnShutdown();
 560   }
 561
 562   db_.reset();
 563 }
 564
 565 void SQLiteChannelIDStore::Backend::DeleteCertificatesOnShutdown() {
 566   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 567
 568   if (!db_.get())
 569     return;
 570
 571   if (channel_id_origins_.empty())
 572     return;
 573
 574   if (!special_storage_policy_.get())
 575     return;
 576
 577   sql::Statement del_smt(db_->GetCachedStatement(
 578       SQL_FROM_HERE, "DELETE FROM origin_bound_certs WHERE origin=?"));
 579   if (!del_smt.is_valid()) {
 580     LOG(WARNING) << "Unable to delete certificates on shutdown.";
 581     return;
 582   }
 583
 584   sql::Transaction transaction(db_.get());
 585   if (!transaction.Begin()) {
 586     LOG(WARNING) << "Unable to delete certificates on shutdown.";
 587     return;
 588   }
 589
 590   for (std::set<std::string>::iterator it = channel_id_origins_.begin();
 591        it != channel_id_origins_.end(); ++it) {
 592     const GURL url(net::cookie_util::CookieOriginToURL(*it, true));
 593     if (!url.is_valid() || !special_storage_policy_->IsStorageSessionOnly(url))
 594       continue;
 595     del_smt.Reset(true);
 596     del_smt.BindString(0, *it);
 597     if (!del_smt.Run())
 598       NOTREACHED() << "Could not delete a certificate from the DB.";
 599   }
 600
 601   if (!transaction.Commit())
 602     LOG(WARNING) << "Unable to delete certificates on shutdown.";
 603 }
 604
 605 void SQLiteChannelIDStore::Backend::SetForceKeepSessionState() {
 606   base::AutoLock locked(lock_);
 607   force_keep_session_state_ = true;
 608 }
 609
 610 SQLiteChannelIDStore::SQLiteChannelIDStore(
 611     const base::FilePath& path,
 612     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
 613     quota::SpecialStoragePolicy* special_storage_policy)
 614     : backend_(new Backend(path,
 615                            background_task_runner,
 616                            special_storage_policy)) {}
 617
 618 void SQLiteChannelIDStore::Load(
 619     const LoadedCallback& loaded_callback) {
 620   backend_->Load(loaded_callback);
 621 }
 622
 623 void SQLiteChannelIDStore::AddChannelID(
 624     const net::DefaultChannelIDStore::ChannelID& channel_id) {
 625   backend_->AddChannelID(channel_id);
 626 }
 627
 628 void SQLiteChannelIDStore::DeleteChannelID(
 629     const net::DefaultChannelIDStore::ChannelID& channel_id) {
 630   backend_->DeleteChannelID(channel_id);
 631 }
 632
 633 void SQLiteChannelIDStore::SetForceKeepSessionState() {
 634   backend_->SetForceKeepSessionState();
 635 }
 636
 637 SQLiteChannelIDStore::~SQLiteChannelIDStore() {
 638   backend_->Close();
 639   // We release our reference to the Backend, though it will probably still have
 640   // a reference if the background thread has not run Close() yet.
 641 }