content/browser/indexed_db/indexed_db_context_impl.cc

   1 // Copyright (c) 2012 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 "content/browser/indexed_db/indexed_db_context_impl.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "base/bind.h"
  11 #include "base/command_line.h"
  12 #include "base/file_util.h"
  13 #include "base/files/file_enumerator.h"
  14 #include "base/logging.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/sequenced_task_runner.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/threading/thread_restrictions.h"
  20 #include "base/time/time.h"
  21 #include "base/values.h"
  22 #include "content/browser/browser_main_loop.h"
  23 #include "content/browser/indexed_db/indexed_db_connection.h"
  24 #include "content/browser/indexed_db/indexed_db_database.h"
  25 #include "content/browser/indexed_db/indexed_db_dispatcher_host.h"
  26 #include "content/browser/indexed_db/indexed_db_factory_impl.h"
  27 #include "content/browser/indexed_db/indexed_db_quota_client.h"
  28 #include "content/browser/indexed_db/indexed_db_tracing.h"
  29 #include "content/browser/indexed_db/indexed_db_transaction.h"
  30 #include "content/public/browser/browser_thread.h"
  31 #include "content/public/browser/indexed_db_info.h"
  32 #include "content/public/common/content_switches.h"
  33 #include "ui/base/text/bytes_formatting.h"
  34 #include "webkit/browser/database/database_util.h"
  35 #include "webkit/browser/quota/quota_manager_proxy.h"
  36 #include "webkit/browser/quota/special_storage_policy.h"
  37 #include "webkit/common/database/database_identifier.h"
  38
  39 using base::DictionaryValue;
  40 using base::ListValue;
  41 using storage::DatabaseUtil;
  42
  43 namespace content {
  44 const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBDirectory[] =
  45     FILE_PATH_LITERAL("IndexedDB");
  46
  47 static const base::FilePath::CharType kIndexedDBExtension[] =
  48     FILE_PATH_LITERAL(".indexeddb");
  49
  50 static const base::FilePath::CharType kLevelDBExtension[] =
  51     FILE_PATH_LITERAL(".leveldb");
  52
  53 namespace {
  54
  55 // This may be called after the IndexedDBContext is destroyed.
  56 void GetAllOriginsAndPaths(const base::FilePath& indexeddb_path,
  57                            std::vector<GURL>* origins,
  58                            std::vector<base::FilePath>* file_paths) {
  59   // TODO(jsbell): DCHECK that this is running on an IndexedDB thread,
  60   // if a global handle to it is ever available.
  61   if (indexeddb_path.empty())
  62     return;
  63   base::FileEnumerator file_enumerator(
  64       indexeddb_path, false, base::FileEnumerator::DIRECTORIES);
  65   for (base::FilePath file_path = file_enumerator.Next(); !file_path.empty();
  66        file_path = file_enumerator.Next()) {
  67     if (file_path.Extension() == kLevelDBExtension &&
  68         file_path.RemoveExtension().Extension() == kIndexedDBExtension) {
  69       std::string origin_id = file_path.BaseName().RemoveExtension()
  70           .RemoveExtension().MaybeAsASCII();
  71       origins->push_back(storage::GetOriginFromIdentifier(origin_id));
  72       if (file_paths)
  73         file_paths->push_back(file_path);
  74     }
  75   }
  76 }
  77
  78 // This will be called after the IndexedDBContext is destroyed.
  79 void ClearSessionOnlyOrigins(
  80     const base::FilePath& indexeddb_path,
  81     scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy) {
  82   // TODO(jsbell): DCHECK that this is running on an IndexedDB thread,
  83   // if a global handle to it is ever available.
  84   std::vector<GURL> origins;
  85   std::vector<base::FilePath> file_paths;
  86   GetAllOriginsAndPaths(indexeddb_path, &origins, &file_paths);
  87   DCHECK_EQ(origins.size(), file_paths.size());
  88   std::vector<base::FilePath>::const_iterator file_path_iter =
  89       file_paths.begin();
  90   for (std::vector<GURL>::const_iterator iter = origins.begin();
  91        iter != origins.end();
  92        ++iter, ++file_path_iter) {
  93     if (!special_storage_policy->IsStorageSessionOnly(*iter))
  94       continue;
  95     if (special_storage_policy->IsStorageProtected(*iter))
  96       continue;
  97     base::DeleteFile(*file_path_iter, true);
  98   }
  99 }
 100
 101 }  // namespace
 102
 103 IndexedDBContextImpl::IndexedDBContextImpl(
 104     const base::FilePath& data_path,
 105     storage::SpecialStoragePolicy* special_storage_policy,
 106     storage::QuotaManagerProxy* quota_manager_proxy,
 107     base::SequencedTaskRunner* task_runner)
 108     : force_keep_session_state_(false),
 109       special_storage_policy_(special_storage_policy),
 110       quota_manager_proxy_(quota_manager_proxy),
 111       task_runner_(task_runner) {
 112   IDB_TRACE("init");
 113   if (!data_path.empty())
 114     data_path_ = data_path.Append(kIndexedDBDirectory);
 115   if (quota_manager_proxy) {
 116     quota_manager_proxy->RegisterClient(new IndexedDBQuotaClient(this));
 117   }
 118 }
 119
 120 IndexedDBFactory* IndexedDBContextImpl::GetIDBFactory() {
 121   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 122   if (!factory_.get()) {
 123     // Prime our cache of origins with existing databases so we can
 124     // detect when dbs are newly created.
 125     GetOriginSet();
 126     factory_ = new IndexedDBFactoryImpl(this);
 127   }
 128   return factory_.get();
 129 }
 130
 131 std::vector<GURL> IndexedDBContextImpl::GetAllOrigins() {
 132   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 133   std::vector<GURL> origins;
 134   std::set<GURL>* origins_set = GetOriginSet();
 135   for (std::set<GURL>::const_iterator iter = origins_set->begin();
 136        iter != origins_set->end();
 137        ++iter) {
 138     origins.push_back(*iter);
 139   }
 140   return origins;
 141 }
 142
 143 std::vector<IndexedDBInfo> IndexedDBContextImpl::GetAllOriginsInfo() {
 144   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 145   std::vector<GURL> origins = GetAllOrigins();
 146   std::vector<IndexedDBInfo> result;
 147   for (std::vector<GURL>::const_iterator iter = origins.begin();
 148        iter != origins.end();
 149        ++iter) {
 150     const GURL& origin_url = *iter;
 151
 152     base::FilePath idb_directory = GetFilePath(origin_url);
 153     size_t connection_count = GetConnectionCount(origin_url);
 154     result.push_back(IndexedDBInfo(origin_url,
 155                                    GetOriginDiskUsage(origin_url),
 156                                    GetOriginLastModified(origin_url),
 157                                    idb_directory,
 158                                    connection_count));
 159   }
 160   return result;
 161 }
 162
 163 static bool HostNameComparator(const GURL& i, const GURL& j) {
 164   return i.host() < j.host();
 165 }
 166
 167 base::ListValue* IndexedDBContextImpl::GetAllOriginsDetails() {
 168   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 169   std::vector<GURL> origins = GetAllOrigins();
 170
 171   std::sort(origins.begin(), origins.end(), HostNameComparator);
 172
 173   scoped_ptr<base::ListValue> list(new base::ListValue());
 174   for (std::vector<GURL>::const_iterator iter = origins.begin();
 175        iter != origins.end();
 176        ++iter) {
 177     const GURL& origin_url = *iter;
 178
 179     scoped_ptr<base::DictionaryValue> info(new base::DictionaryValue());
 180     info->SetString("url", origin_url.spec());
 181     info->SetString("size", ui::FormatBytes(GetOriginDiskUsage(origin_url)));
 182     info->SetDouble("last_modified",
 183                     GetOriginLastModified(origin_url).ToJsTime());
 184     if (!is_incognito())
 185       info->SetString("path", GetFilePath(origin_url).value());
 186     info->SetDouble("connection_count", GetConnectionCount(origin_url));
 187
 188     // This ends up being O(n^2) since we iterate over all open databases
 189     // to extract just those in the origin, and we're iterating over all
 190     // origins in the outer loop.
 191
 192     if (factory_.get()) {
 193       std::pair<IndexedDBFactory::OriginDBMapIterator,
 194                 IndexedDBFactory::OriginDBMapIterator> range =
 195           factory_->GetOpenDatabasesForOrigin(origin_url);
 196       // TODO(jsbell): Sort by name?
 197       scoped_ptr<base::ListValue> database_list(new base::ListValue());
 198
 199       for (IndexedDBFactory::OriginDBMapIterator it = range.first;
 200            it != range.second;
 201            ++it) {
 202         const IndexedDBDatabase* db = it->second;
 203         scoped_ptr<base::DictionaryValue> db_info(new base::DictionaryValue());
 204
 205         db_info->SetString("name", db->name());
 206         db_info->SetDouble("pending_opens", db->PendingOpenCount());
 207         db_info->SetDouble("pending_upgrades", db->PendingUpgradeCount());
 208         db_info->SetDouble("running_upgrades", db->RunningUpgradeCount());
 209         db_info->SetDouble("pending_deletes", db->PendingDeleteCount());
 210         db_info->SetDouble("connection_count",
 211                            db->ConnectionCount() - db->PendingUpgradeCount() -
 212                                db->RunningUpgradeCount());
 213
 214         scoped_ptr<base::ListValue> transaction_list(new base::ListValue());
 215         std::vector<const IndexedDBTransaction*> transactions =
 216             db->transaction_coordinator().GetTransactions();
 217         for (std::vector<const IndexedDBTransaction*>::iterator trans_it =
 218                  transactions.begin();
 219              trans_it != transactions.end();
 220              ++trans_it) {
 221           const IndexedDBTransaction* transaction = *trans_it;
 222           scoped_ptr<base::DictionaryValue> transaction_info(
 223               new base::DictionaryValue());
 224
 225           const char* kModes[] = { "readonly", "readwrite", "versionchange" };
 226           transaction_info->SetString("mode", kModes[transaction->mode()]);
 227           switch (transaction->state()) {
 228             case IndexedDBTransaction::CREATED:
 229               transaction_info->SetString("status", "blocked");
 230               break;
 231             case IndexedDBTransaction::STARTED:
 232               if (transaction->diagnostics().tasks_scheduled > 0)
 233                 transaction_info->SetString("status", "running");
 234               else
 235                 transaction_info->SetString("status", "started");
 236               break;
 237             case IndexedDBTransaction::COMMITTING:
 238               transaction_info->SetString("status", "committing");
 239               break;
 240             case IndexedDBTransaction::FINISHED:
 241               transaction_info->SetString("status", "finished");
 242               break;
 243           }
 244
 245           transaction_info->SetDouble(
 246               "pid",
 247               IndexedDBDispatcherHost::TransactionIdToProcessId(
 248                   transaction->id()));
 249           transaction_info->SetDouble(
 250               "tid",
 251               IndexedDBDispatcherHost::TransactionIdToRendererTransactionId(
 252                   transaction->id()));
 253           transaction_info->SetDouble(
 254               "age",
 255               (base::Time::Now() - transaction->diagnostics().creation_time)
 256                   .InMillisecondsF());
 257           transaction_info->SetDouble(
 258               "runtime",
 259               (base::Time::Now() - transaction->diagnostics().start_time)
 260                   .InMillisecondsF());
 261           transaction_info->SetDouble(
 262               "tasks_scheduled", transaction->diagnostics().tasks_scheduled);
 263           transaction_info->SetDouble(
 264               "tasks_completed", transaction->diagnostics().tasks_completed);
 265
 266           scoped_ptr<base::ListValue> scope(new base::ListValue());
 267           for (std::set<int64>::const_iterator scope_it =
 268                    transaction->scope().begin();
 269                scope_it != transaction->scope().end();
 270                ++scope_it) {
 271             IndexedDBDatabaseMetadata::ObjectStoreMap::const_iterator it =
 272                 db->metadata().object_stores.find(*scope_it);
 273             if (it != db->metadata().object_stores.end())
 274               scope->AppendString(it->second.name);
 275           }
 276
 277           transaction_info->Set("scope", scope.release());
 278           transaction_list->Append(transaction_info.release());
 279         }
 280         db_info->Set("transactions", transaction_list.release());
 281
 282         database_list->Append(db_info.release());
 283       }
 284       info->Set("databases", database_list.release());
 285     }
 286
 287     list->Append(info.release());
 288   }
 289   return list.release();
 290 }
 291
 292 int64 IndexedDBContextImpl::GetOriginDiskUsage(const GURL& origin_url) {
 293   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 294   if (data_path_.empty() || !IsInOriginSet(origin_url))
 295     return 0;
 296   EnsureDiskUsageCacheInitialized(origin_url);
 297   return origin_size_map_[origin_url];
 298 }
 299
 300 base::Time IndexedDBContextImpl::GetOriginLastModified(const GURL& origin_url) {
 301   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 302   if (data_path_.empty() || !IsInOriginSet(origin_url))
 303     return base::Time();
 304   base::FilePath idb_directory = GetFilePath(origin_url);
 305   base::File::Info file_info;
 306   if (!base::GetFileInfo(idb_directory, &file_info))
 307     return base::Time();
 308   return file_info.last_modified;
 309 }
 310
 311 void IndexedDBContextImpl::DeleteForOrigin(const GURL& origin_url) {
 312   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 313   ForceClose(origin_url, FORCE_CLOSE_DELETE_ORIGIN);
 314   if (data_path_.empty() || !IsInOriginSet(origin_url))
 315     return;
 316
 317   base::FilePath idb_directory = GetFilePath(origin_url);
 318   EnsureDiskUsageCacheInitialized(origin_url);
 319   leveldb::Status s = LevelDBDatabase::Destroy(idb_directory);
 320   if (!s.ok()) {
 321     LOG(WARNING) << "Failed to delete LevelDB database: "
 322                  << idb_directory.AsUTF8Unsafe();
 323   } else {
 324     // LevelDB does not delete empty directories; work around this.
 325     // TODO(jsbell): Remove when upstream bug is fixed.
 326     // https://code.google.com/p/leveldb/issues/detail?id=209
 327     const bool kNonRecursive = false;
 328     base::DeleteFile(idb_directory, kNonRecursive);
 329   }
 330
 331   QueryDiskAndUpdateQuotaUsage(origin_url);
 332   if (s.ok()) {
 333     RemoveFromOriginSet(origin_url);
 334     origin_size_map_.erase(origin_url);
 335     space_available_map_.erase(origin_url);
 336   }
 337 }
 338
 339 void IndexedDBContextImpl::ForceClose(const GURL origin_url,
 340                                       ForceCloseReason reason) {
 341   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 342   UMA_HISTOGRAM_ENUMERATION("WebCore.IndexedDB.Context.ForceCloseReason",
 343                             reason,
 344                             FORCE_CLOSE_REASON_MAX);
 345
 346   if (data_path_.empty() || !IsInOriginSet(origin_url))
 347     return;
 348
 349   if (factory_.get())
 350     factory_->ForceClose(origin_url);
 351   DCHECK_EQ(0UL, GetConnectionCount(origin_url));
 352 }
 353
 354 size_t IndexedDBContextImpl::GetConnectionCount(const GURL& origin_url) {
 355   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 356   if (data_path_.empty() || !IsInOriginSet(origin_url))
 357     return 0;
 358
 359   if (!factory_.get())
 360     return 0;
 361
 362   return factory_->GetConnectionCount(origin_url);
 363 }
 364
 365 base::FilePath IndexedDBContextImpl::GetFilePath(const GURL& origin_url) const {
 366   std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
 367   return GetIndexedDBFilePath(origin_id);
 368 }
 369
 370 base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
 371     const std::string& origin_id) const {
 372   return GetIndexedDBFilePath(origin_id);
 373 }
 374
 375 void IndexedDBContextImpl::SetTaskRunnerForTesting(
 376     base::SequencedTaskRunner* task_runner) {
 377   DCHECK(!task_runner_.get());
 378   task_runner_ = task_runner;
 379 }
 380
 381 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
 382                                             IndexedDBConnection* connection) {
 383   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 384   if (quota_manager_proxy()) {
 385     quota_manager_proxy()->NotifyStorageAccessed(
 386         storage::QuotaClient::kIndexedDatabase,
 387         origin_url,
 388         storage::kStorageTypeTemporary);
 389   }
 390   if (AddToOriginSet(origin_url)) {
 391     // A newly created db, notify the quota system.
 392     QueryDiskAndUpdateQuotaUsage(origin_url);
 393   } else {
 394     EnsureDiskUsageCacheInitialized(origin_url);
 395   }
 396   QueryAvailableQuota(origin_url);
 397 }
 398
 399 void IndexedDBContextImpl::ConnectionClosed(const GURL& origin_url,
 400                                             IndexedDBConnection* connection) {
 401   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 402   if (quota_manager_proxy()) {
 403     quota_manager_proxy()->NotifyStorageAccessed(
 404         storage::QuotaClient::kIndexedDatabase,
 405         origin_url,
 406         storage::kStorageTypeTemporary);
 407   }
 408   if (factory_.get() && factory_->GetConnectionCount(origin_url) == 0)
 409     QueryDiskAndUpdateQuotaUsage(origin_url);
 410 }
 411
 412 void IndexedDBContextImpl::TransactionComplete(const GURL& origin_url) {
 413   DCHECK(!factory_.get() || factory_->GetConnectionCount(origin_url) > 0);
 414   QueryDiskAndUpdateQuotaUsage(origin_url);
 415   QueryAvailableQuota(origin_url);
 416 }
 417
 418 void IndexedDBContextImpl::DatabaseDeleted(const GURL& origin_url) {
 419   AddToOriginSet(origin_url);
 420   QueryDiskAndUpdateQuotaUsage(origin_url);
 421   QueryAvailableQuota(origin_url);
 422 }
 423
 424 bool IndexedDBContextImpl::WouldBeOverQuota(const GURL& origin_url,
 425                                             int64 additional_bytes) {
 426   if (space_available_map_.find(origin_url) == space_available_map_.end()) {
 427     // We haven't heard back from the QuotaManager yet, just let it through.
 428     return false;
 429   }
 430   bool over_quota = additional_bytes > space_available_map_[origin_url];
 431   return over_quota;
 432 }
 433
 434 bool IndexedDBContextImpl::IsOverQuota(const GURL& origin_url) {
 435   const int kOneAdditionalByte = 1;
 436   return WouldBeOverQuota(origin_url, kOneAdditionalByte);
 437 }
 438
 439 storage::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
 440   return quota_manager_proxy_.get();
 441 }
 442
 443 IndexedDBContextImpl::~IndexedDBContextImpl() {
 444   if (factory_.get()) {
 445     TaskRunner()->PostTask(
 446         FROM_HERE, base::Bind(&IndexedDBFactory::ContextDestroyed, factory_));
 447     factory_ = NULL;
 448   }
 449
 450   if (data_path_.empty())
 451     return;
 452
 453   if (force_keep_session_state_)
 454     return;
 455
 456   bool has_session_only_databases =
 457       special_storage_policy_.get() &&
 458       special_storage_policy_->HasSessionOnlyOrigins();
 459
 460   // Clearing only session-only databases, and there are none.
 461   if (!has_session_only_databases)
 462     return;
 463
 464   TaskRunner()->PostTask(
 465       FROM_HERE,
 466       base::Bind(
 467           &ClearSessionOnlyOrigins, data_path_, special_storage_policy_));
 468 }
 469
 470 base::FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
 471     const std::string& origin_id) const {
 472   DCHECK(!data_path_.empty());
 473   return data_path_.AppendASCII(origin_id).AddExtension(kIndexedDBExtension)
 474       .AddExtension(kLevelDBExtension);
 475 }
 476
 477 int64 IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
 478   if (data_path_.empty())
 479     return 0;
 480   base::FilePath file_path = GetFilePath(origin_url);
 481   return base::ComputeDirectorySize(file_path);
 482 }
 483
 484 void IndexedDBContextImpl::EnsureDiskUsageCacheInitialized(
 485     const GURL& origin_url) {
 486   if (origin_size_map_.find(origin_url) == origin_size_map_.end())
 487     origin_size_map_[origin_url] = ReadUsageFromDisk(origin_url);
 488 }
 489
 490 void IndexedDBContextImpl::QueryDiskAndUpdateQuotaUsage(
 491     const GURL& origin_url) {
 492   int64 former_disk_usage = origin_size_map_[origin_url];
 493   int64 current_disk_usage = ReadUsageFromDisk(origin_url);
 494   int64 difference = current_disk_usage - former_disk_usage;
 495   if (difference) {
 496     origin_size_map_[origin_url] = current_disk_usage;
 497     // quota_manager_proxy() is NULL in unit tests.
 498     if (quota_manager_proxy()) {
 499       quota_manager_proxy()->NotifyStorageModified(
 500           storage::QuotaClient::kIndexedDatabase,
 501           origin_url,
 502           storage::kStorageTypeTemporary,
 503           difference);
 504     }
 505   }
 506 }
 507
 508 void IndexedDBContextImpl::GotUsageAndQuota(const GURL& origin_url,
 509                                             storage::QuotaStatusCode status,
 510                                             int64 usage,
 511                                             int64 quota) {
 512   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 513   DCHECK(status == storage::kQuotaStatusOk ||
 514          status == storage::kQuotaErrorAbort)
 515       << "status was " << status;
 516   if (status == storage::kQuotaErrorAbort) {
 517     // We seem to no longer care to wait around for the answer.
 518     return;
 519   }
 520   TaskRunner()->PostTask(FROM_HERE,
 521                          base::Bind(&IndexedDBContextImpl::GotUpdatedQuota,
 522                                     this,
 523                                     origin_url,
 524                                     usage,
 525                                     quota));
 526 }
 527
 528 void IndexedDBContextImpl::GotUpdatedQuota(const GURL& origin_url,
 529                                            int64 usage,
 530                                            int64 quota) {
 531   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 532   space_available_map_[origin_url] = quota - usage;
 533 }
 534
 535 void IndexedDBContextImpl::QueryAvailableQuota(const GURL& origin_url) {
 536   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
 537     DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 538     if (quota_manager_proxy()) {
 539       BrowserThread::PostTask(
 540           BrowserThread::IO,
 541           FROM_HERE,
 542           base::Bind(
 543               &IndexedDBContextImpl::QueryAvailableQuota, this, origin_url));
 544     }
 545     return;
 546   }
 547   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 548   if (!quota_manager_proxy() || !quota_manager_proxy()->quota_manager())
 549     return;
 550   quota_manager_proxy()->quota_manager()->GetUsageAndQuota(
 551       origin_url,
 552       storage::kStorageTypeTemporary,
 553       base::Bind(&IndexedDBContextImpl::GotUsageAndQuota, this, origin_url));
 554 }
 555
 556 std::set<GURL>* IndexedDBContextImpl::GetOriginSet() {
 557   if (!origin_set_) {
 558     origin_set_.reset(new std::set<GURL>);
 559     std::vector<GURL> origins;
 560     GetAllOriginsAndPaths(data_path_, &origins, NULL);
 561     for (std::vector<GURL>::const_iterator iter = origins.begin();
 562          iter != origins.end();
 563          ++iter) {
 564       origin_set_->insert(*iter);
 565     }
 566   }
 567   return origin_set_.get();
 568 }
 569
 570 void IndexedDBContextImpl::ResetCaches() {
 571   origin_set_.reset();
 572   origin_size_map_.clear();
 573   space_available_map_.clear();
 574 }
 575
 576 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
 577   return task_runner_.get();
 578 }
 579
 580 }  // namespace content