content/browser/appcache/appcache_storage_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/appcache/appcache_storage_impl.h"
   6
   7 #include <algorithm>
   8 #include <functional>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/files/file_util.h"
  15 #include "base/location.h"
  16 #include "base/logging.h"
  17 #include "base/profiler/scoped_tracker.h"
  18 #include "base/single_thread_task_runner.h"
  19 #include "base/stl_util.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/thread_task_runner_handle.h"
  22 #include "content/browser/appcache/appcache.h"
  23 #include "content/browser/appcache/appcache_database.h"
  24 #include "content/browser/appcache/appcache_entry.h"
  25 #include "content/browser/appcache/appcache_group.h"
  26 #include "content/browser/appcache/appcache_histograms.h"
  27 #include "content/browser/appcache/appcache_quota_client.h"
  28 #include "content/browser/appcache/appcache_response.h"
  29 #include "content/browser/appcache/appcache_service_impl.h"
  30 #include "net/base/cache_type.h"
  31 #include "net/base/net_errors.h"
  32 #include "sql/connection.h"
  33 #include "sql/transaction.h"
  34 #include "storage/browser/quota/quota_client.h"
  35 #include "storage/browser/quota/quota_manager.h"
  36 #include "storage/browser/quota/quota_manager_proxy.h"
  37 #include "storage/browser/quota/special_storage_policy.h"
  38
  39 namespace content {
  40
  41 // Hard coded default when not using quota management.
  42 static const int kDefaultQuota = 5 * 1024 * 1024;
  43
  44 static const int kMaxDiskCacheSize = 250 * 1024 * 1024;
  45 static const int kMaxMemDiskCacheSize = 10 * 1024 * 1024;
  46 static const base::FilePath::CharType kDiskCacheDirectoryName[] =
  47     FILE_PATH_LITERAL("Cache");
  48
  49 namespace {
  50
  51 // Helpers for clearing data from the AppCacheDatabase.
  52 bool DeleteGroupAndRelatedRecords(AppCacheDatabase* database,
  53                                   int64 group_id,
  54                                   std::vector<int64>* deletable_response_ids) {
  55   AppCacheDatabase::CacheRecord cache_record;
  56   bool success = false;
  57   if (database->FindCacheForGroup(group_id, &cache_record)) {
  58     database->FindResponseIdsForCacheAsVector(cache_record.cache_id,
  59                                               deletable_response_ids);
  60     success =
  61         database->DeleteGroup(group_id) &&
  62         database->DeleteCache(cache_record.cache_id) &&
  63         database->DeleteEntriesForCache(cache_record.cache_id) &&
  64         database->DeleteNamespacesForCache(cache_record.cache_id) &&
  65         database->DeleteOnlineWhiteListForCache(cache_record.cache_id) &&
  66         database->InsertDeletableResponseIds(*deletable_response_ids);
  67   } else {
  68     NOTREACHED() << "A existing group without a cache is unexpected";
  69     success = database->DeleteGroup(group_id);
  70   }
  71   return success;
  72 }
  73
  74 // Destroys |database|. If there is appcache data to be deleted
  75 // (|force_keep_session_state| is false), deletes session-only appcache data.
  76 void ClearSessionOnlyOrigins(
  77     AppCacheDatabase* database,
  78     scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,
  79     bool force_keep_session_state) {
  80   scoped_ptr<AppCacheDatabase> database_to_delete(database);
  81
  82   // If saving session state, only delete the database.
  83   if (force_keep_session_state)
  84     return;
  85
  86   bool has_session_only_appcaches =
  87       special_storage_policy.get() &&
  88       special_storage_policy->HasSessionOnlyOrigins();
  89
  90   // Clearning only session-only databases, and there are none.
  91   if (!has_session_only_appcaches)
  92     return;
  93
  94   std::set<GURL> origins;
  95   database->FindOriginsWithGroups(&origins);
  96   if (origins.empty())
  97     return;  // nothing to delete
  98
  99   sql::Connection* connection = database->db_connection();
 100   if (!connection) {
 101     NOTREACHED() << "Missing database connection.";
 102     return;
 103   }
 104
 105   std::set<GURL>::const_iterator origin;
 106   DCHECK(special_storage_policy.get());
 107   for (origin = origins.begin(); origin != origins.end(); ++origin) {
 108     if (!special_storage_policy->IsStorageSessionOnly(*origin))
 109       continue;
 110     if (special_storage_policy->IsStorageProtected(*origin))
 111       continue;
 112
 113     std::vector<AppCacheDatabase::GroupRecord> groups;
 114     database->FindGroupsForOrigin(*origin, &groups);
 115     std::vector<AppCacheDatabase::GroupRecord>::const_iterator group;
 116     for (group = groups.begin(); group != groups.end(); ++group) {
 117       sql::Transaction transaction(connection);
 118       if (!transaction.Begin()) {
 119         NOTREACHED() << "Failed to start transaction";
 120         return;
 121       }
 122       std::vector<int64> deletable_response_ids;
 123       bool success = DeleteGroupAndRelatedRecords(database,
 124                                                   group->group_id,
 125                                                   &deletable_response_ids);
 126       success = success && transaction.Commit();
 127       DCHECK(success);
 128     }  // for each group
 129   }  // for each origin
 130 }
 131
 132 }  // namespace
 133
 134 // DatabaseTask -----------------------------------------
 135
 136 class AppCacheStorageImpl::DatabaseTask
 137     : public base::RefCountedThreadSafe<DatabaseTask> {
 138  public:
 139   explicit DatabaseTask(AppCacheStorageImpl* storage)
 140       : storage_(storage),
 141         database_(storage->database_),
 142         io_thread_(base::ThreadTaskRunnerHandle::Get()) {
 143     DCHECK(io_thread_.get());
 144   }
 145
 146   void AddDelegate(DelegateReference* delegate_reference) {
 147     delegates_.push_back(make_scoped_refptr(delegate_reference));
 148   }
 149
 150   // Schedules a task to be Run() on the DB thread. Tasks
 151   // are run in the order in which they are scheduled.
 152   void Schedule();
 153
 154   // Called on the DB thread.
 155   virtual void Run() = 0;
 156
 157   // Called on the IO thread after Run() has completed.
 158   virtual void RunCompleted() {}
 159
 160   // Once scheduled a task cannot be cancelled, but the
 161   // call to RunCompleted may be. This method should only be
 162   // called on the IO thread. This is used by AppCacheStorageImpl
 163   // to cancel the completion calls when AppCacheStorageImpl is
 164   // destructed. This method may be overriden to release or delete
 165   // additional data associated with the task that is not DB thread
 166   // safe. If overriden, this base class method must be called from
 167   // within the override.
 168   virtual void CancelCompletion();
 169
 170  protected:
 171   friend class base::RefCountedThreadSafe<DatabaseTask>;
 172   virtual ~DatabaseTask() {}
 173
 174   AppCacheStorageImpl* storage_;
 175   AppCacheDatabase* database_;
 176   DelegateReferenceVector delegates_;
 177
 178  private:
 179   void CallRun(base::TimeTicks schedule_time);
 180   void CallRunCompleted(base::TimeTicks schedule_time);
 181   void OnFatalError();
 182
 183   scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
 184 };
 185
 186 void AppCacheStorageImpl::DatabaseTask::Schedule() {
 187   DCHECK(storage_);
 188   DCHECK(io_thread_->BelongsToCurrentThread());
 189   if (!storage_->database_)
 190     return;
 191
 192   if (storage_->db_thread_->PostTask(
 193           FROM_HERE,
 194           base::Bind(&DatabaseTask::CallRun, this, base::TimeTicks::Now()))) {
 195     storage_->scheduled_database_tasks_.push_back(this);
 196   } else {
 197     NOTREACHED() << "Thread for database tasks is not running.";
 198   }
 199 }
 200
 201 void AppCacheStorageImpl::DatabaseTask::CancelCompletion() {
 202   DCHECK(io_thread_->BelongsToCurrentThread());
 203   delegates_.clear();
 204   storage_ = NULL;
 205 }
 206
 207 void AppCacheStorageImpl::DatabaseTask::CallRun(
 208     base::TimeTicks schedule_time) {
 209   AppCacheHistograms::AddTaskQueueTimeSample(
 210       base::TimeTicks::Now() - schedule_time);
 211   if (!database_->is_disabled()) {
 212     base::TimeTicks run_time = base::TimeTicks::Now();
 213     Run();
 214     AppCacheHistograms::AddTaskRunTimeSample(
 215         base::TimeTicks::Now() - run_time);
 216
 217     if (database_->was_corruption_detected()) {
 218       AppCacheHistograms::CountCorruptionDetected();
 219       database_->Disable();
 220     }
 221     if (database_->is_disabled()) {
 222       io_thread_->PostTask(
 223           FROM_HERE,
 224           base::Bind(&DatabaseTask::OnFatalError, this));
 225     }
 226   }
 227   io_thread_->PostTask(
 228       FROM_HERE,
 229       base::Bind(&DatabaseTask::CallRunCompleted, this,
 230                  base::TimeTicks::Now()));
 231 }
 232
 233 void AppCacheStorageImpl::DatabaseTask::CallRunCompleted(
 234     base::TimeTicks schedule_time) {
 235   AppCacheHistograms::AddCompletionQueueTimeSample(
 236       base::TimeTicks::Now() - schedule_time);
 237   if (storage_) {
 238     DCHECK(io_thread_->BelongsToCurrentThread());
 239     DCHECK(storage_->scheduled_database_tasks_.front() == this);
 240     storage_->scheduled_database_tasks_.pop_front();
 241     base::TimeTicks run_time = base::TimeTicks::Now();
 242     RunCompleted();
 243     AppCacheHistograms::AddCompletionRunTimeSample(
 244         base::TimeTicks::Now() - run_time);
 245     delegates_.clear();
 246   }
 247 }
 248
 249 void AppCacheStorageImpl::DatabaseTask::OnFatalError() {
 250   if (storage_) {
 251     DCHECK(io_thread_->BelongsToCurrentThread());
 252     storage_->Disable();
 253     storage_->DeleteAndStartOver();
 254   }
 255 }
 256
 257 // InitTask -------
 258
 259 class AppCacheStorageImpl::InitTask : public DatabaseTask {
 260  public:
 261   explicit InitTask(AppCacheStorageImpl* storage)
 262       : DatabaseTask(storage), last_group_id_(0),
 263         last_cache_id_(0), last_response_id_(0),
 264         last_deletable_response_rowid_(0) {
 265     if (!storage->is_incognito_) {
 266       db_file_path_ =
 267           storage->cache_directory_.Append(kAppCacheDatabaseName);
 268       disk_cache_directory_ =
 269           storage->cache_directory_.Append(kDiskCacheDirectoryName);
 270     }
 271   }
 272
 273   // DatabaseTask:
 274   void Run() override;
 275   void RunCompleted() override;
 276
 277  protected:
 278   ~InitTask() override {}
 279
 280  private:
 281   base::FilePath db_file_path_;
 282   base::FilePath disk_cache_directory_;
 283   int64 last_group_id_;
 284   int64 last_cache_id_;
 285   int64 last_response_id_;
 286   int64 last_deletable_response_rowid_;
 287   std::map<GURL, int64> usage_map_;
 288 };
 289
 290 void AppCacheStorageImpl::InitTask::Run() {
 291   tracked_objects::ScopedTracker tracking_profile(
 292       FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::InitTask"));
 293   // If there is no sql database, ensure there is no disk cache either.
 294   if (!db_file_path_.empty() &&
 295       !base::PathExists(db_file_path_) &&
 296       base::DirectoryExists(disk_cache_directory_)) {
 297     base::DeleteFile(disk_cache_directory_, true);
 298     if (base::DirectoryExists(disk_cache_directory_)) {
 299       database_->Disable();  // This triggers OnFatalError handling.
 300       return;
 301     }
 302   }
 303
 304   database_->FindLastStorageIds(
 305       &last_group_id_, &last_cache_id_, &last_response_id_,
 306       &last_deletable_response_rowid_);
 307   database_->GetAllOriginUsage(&usage_map_);
 308 }
 309
 310 void AppCacheStorageImpl::InitTask::RunCompleted() {
 311   storage_->last_group_id_ = last_group_id_;
 312   storage_->last_cache_id_ = last_cache_id_;
 313   storage_->last_response_id_ = last_response_id_;
 314   storage_->last_deletable_response_rowid_ = last_deletable_response_rowid_;
 315
 316   if (!storage_->is_disabled()) {
 317     storage_->usage_map_.swap(usage_map_);
 318     const base::TimeDelta kDelay = base::TimeDelta::FromMinutes(5);
 319     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 320         FROM_HERE,
 321         base::Bind(&AppCacheStorageImpl::DelayedStartDeletingUnusedResponses,
 322                    storage_->weak_factory_.GetWeakPtr()),
 323         kDelay);
 324   }
 325
 326   if (storage_->service()->quota_client())
 327     storage_->service()->quota_client()->NotifyAppCacheReady();
 328 }
 329
 330 // DisableDatabaseTask -------
 331
 332 class AppCacheStorageImpl::DisableDatabaseTask : public DatabaseTask {
 333  public:
 334   explicit DisableDatabaseTask(AppCacheStorageImpl* storage)
 335       : DatabaseTask(storage) {}
 336
 337   // DatabaseTask:
 338   void Run() override { database_->Disable(); }
 339
 340  protected:
 341   ~DisableDatabaseTask() override {}
 342 };
 343
 344 // GetAllInfoTask -------
 345
 346 class AppCacheStorageImpl::GetAllInfoTask : public DatabaseTask {
 347  public:
 348   explicit GetAllInfoTask(AppCacheStorageImpl* storage)
 349       : DatabaseTask(storage),
 350         info_collection_(new AppCacheInfoCollection()) {
 351   }
 352
 353   // DatabaseTask:
 354   void Run() override;
 355   void RunCompleted() override;
 356
 357  protected:
 358   ~GetAllInfoTask() override {}
 359
 360  private:
 361   scoped_refptr<AppCacheInfoCollection> info_collection_;
 362 };
 363
 364 void AppCacheStorageImpl::GetAllInfoTask::Run() {
 365   std::set<GURL> origins;
 366   database_->FindOriginsWithGroups(&origins);
 367   for (std::set<GURL>::const_iterator origin = origins.begin();
 368        origin != origins.end(); ++origin) {
 369     AppCacheInfoVector& infos =
 370         info_collection_->infos_by_origin[*origin];
 371     std::vector<AppCacheDatabase::GroupRecord> groups;
 372     database_->FindGroupsForOrigin(*origin, &groups);
 373     for (std::vector<AppCacheDatabase::GroupRecord>::const_iterator
 374          group = groups.begin();
 375          group != groups.end(); ++group) {
 376       AppCacheDatabase::CacheRecord cache_record;
 377       database_->FindCacheForGroup(group->group_id, &cache_record);
 378       AppCacheInfo info;
 379       info.manifest_url = group->manifest_url;
 380       info.creation_time = group->creation_time;
 381       info.size = cache_record.cache_size;
 382       info.last_access_time = group->last_access_time;
 383       info.last_update_time = cache_record.update_time;
 384       info.cache_id = cache_record.cache_id;
 385       info.group_id = group->group_id;
 386       info.is_complete = true;
 387       infos.push_back(info);
 388     }
 389   }
 390 }
 391
 392 void AppCacheStorageImpl::GetAllInfoTask::RunCompleted() {
 393   DCHECK_EQ(1U, delegates_.size());
 394   FOR_EACH_DELEGATE(delegates_, OnAllInfo(info_collection_.get()));
 395 }
 396
 397 // StoreOrLoadTask -------
 398
 399 class AppCacheStorageImpl::StoreOrLoadTask : public DatabaseTask {
 400  protected:
 401   explicit StoreOrLoadTask(AppCacheStorageImpl* storage)
 402       : DatabaseTask(storage) {}
 403   ~StoreOrLoadTask() override {}
 404
 405   bool FindRelatedCacheRecords(int64 cache_id);
 406   void CreateCacheAndGroupFromRecords(
 407       scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group);
 408
 409   AppCacheDatabase::GroupRecord group_record_;
 410   AppCacheDatabase::CacheRecord cache_record_;
 411   std::vector<AppCacheDatabase::EntryRecord> entry_records_;
 412   std::vector<AppCacheDatabase::NamespaceRecord>
 413       intercept_namespace_records_;
 414   std::vector<AppCacheDatabase::NamespaceRecord>
 415       fallback_namespace_records_;
 416   std::vector<AppCacheDatabase::OnlineWhiteListRecord>
 417       online_whitelist_records_;
 418 };
 419
 420 bool AppCacheStorageImpl::StoreOrLoadTask::FindRelatedCacheRecords(
 421     int64 cache_id) {
 422   return database_->FindEntriesForCache(cache_id, &entry_records_) &&
 423          database_->FindNamespacesForCache(
 424              cache_id, &intercept_namespace_records_,
 425              &fallback_namespace_records_) &&
 426          database_->FindOnlineWhiteListForCache(
 427              cache_id, &online_whitelist_records_);
 428 }
 429
 430 void AppCacheStorageImpl::StoreOrLoadTask::CreateCacheAndGroupFromRecords(
 431     scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group) {
 432   DCHECK(storage_ && cache && group);
 433
 434   (*cache) = storage_->working_set_.GetCache(cache_record_.cache_id);
 435   if (cache->get()) {
 436     (*group) = cache->get()->owning_group();
 437     DCHECK(group->get());
 438     DCHECK_EQ(group_record_.group_id, group->get()->group_id());
 439
 440     // TODO(michaeln): histogram is fishing for clues to crbug/95101
 441     if (!cache->get()->GetEntry(group_record_.manifest_url)) {
 442       AppCacheHistograms::AddMissingManifestDetectedAtCallsite(
 443           AppCacheHistograms::CALLSITE_0);
 444     }
 445
 446     storage_->NotifyStorageAccessed(group_record_.origin);
 447     return;
 448   }
 449
 450   (*cache) = new AppCache(storage_, cache_record_.cache_id);
 451   cache->get()->InitializeWithDatabaseRecords(
 452       cache_record_, entry_records_,
 453       intercept_namespace_records_,
 454       fallback_namespace_records_,
 455       online_whitelist_records_);
 456   cache->get()->set_complete(true);
 457
 458   (*group) = storage_->working_set_.GetGroup(group_record_.manifest_url);
 459   if (group->get()) {
 460     DCHECK(group_record_.group_id == group->get()->group_id());
 461     group->get()->AddCache(cache->get());
 462
 463     // TODO(michaeln): histogram is fishing for clues to crbug/95101
 464     if (!cache->get()->GetEntry(group_record_.manifest_url)) {
 465       AppCacheHistograms::AddMissingManifestDetectedAtCallsite(
 466           AppCacheHistograms::CALLSITE_1);
 467     }
 468   } else {
 469     (*group) = new AppCacheGroup(
 470         storage_, group_record_.manifest_url,
 471         group_record_.group_id);
 472     group->get()->set_creation_time(group_record_.creation_time);
 473     group->get()->AddCache(cache->get());
 474
 475     // TODO(michaeln): histogram is fishing for clues to crbug/95101
 476     if (!cache->get()->GetEntry(group_record_.manifest_url)) {
 477       AppCacheHistograms::AddMissingManifestDetectedAtCallsite(
 478           AppCacheHistograms::CALLSITE_2);
 479     }
 480   }
 481   DCHECK(group->get()->newest_complete_cache() == cache->get());
 482
 483   // We have to update foriegn entries if MarkEntryAsForeignTasks
 484   // are in flight.
 485   std::vector<GURL> urls;
 486   storage_->GetPendingForeignMarkingsForCache(cache->get()->cache_id(), &urls);
 487   for (std::vector<GURL>::iterator iter = urls.begin();
 488        iter != urls.end(); ++iter) {
 489     DCHECK(cache->get()->GetEntry(*iter));
 490     cache->get()->GetEntry(*iter)->add_types(AppCacheEntry::FOREIGN);
 491   }
 492
 493   storage_->NotifyStorageAccessed(group_record_.origin);
 494
 495   // TODO(michaeln): Maybe verify that the responses we expect to exist
 496   // do actually exist in the disk_cache (and if not then what?)
 497 }
 498
 499 // CacheLoadTask -------
 500
 501 class AppCacheStorageImpl::CacheLoadTask : public StoreOrLoadTask {
 502  public:
 503   CacheLoadTask(int64 cache_id, AppCacheStorageImpl* storage)
 504       : StoreOrLoadTask(storage), cache_id_(cache_id),
 505         success_(false) {}
 506
 507   // DatabaseTask:
 508   void Run() override;
 509   void RunCompleted() override;
 510
 511  protected:
 512   ~CacheLoadTask() override {}
 513
 514  private:
 515   int64 cache_id_;
 516   bool success_;
 517 };
 518
 519 void AppCacheStorageImpl::CacheLoadTask::Run() {
 520   tracked_objects::ScopedTracker tracking_profile(
 521       FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::CacheLoadTask"));
 522   success_ =
 523       database_->FindCache(cache_id_, &cache_record_) &&
 524       database_->FindGroup(cache_record_.group_id, &group_record_) &&
 525       FindRelatedCacheRecords(cache_id_);
 526
 527   if (success_)
 528     database_->LazyUpdateLastAccessTime(group_record_.group_id,
 529                                         base::Time::Now());
 530 }
 531
 532 void AppCacheStorageImpl::CacheLoadTask::RunCompleted() {
 533   storage_->pending_cache_loads_.erase(cache_id_);
 534   scoped_refptr<AppCache> cache;
 535   scoped_refptr<AppCacheGroup> group;
 536   if (success_ && !storage_->is_disabled()) {
 537     storage_->LazilyCommitLastAccessTimes();
 538     DCHECK(cache_record_.cache_id == cache_id_);
 539     CreateCacheAndGroupFromRecords(&cache, &group);
 540   }
 541   FOR_EACH_DELEGATE(delegates_, OnCacheLoaded(cache.get(), cache_id_));
 542 }
 543
 544 // GroupLoadTask -------
 545
 546 class AppCacheStorageImpl::GroupLoadTask : public StoreOrLoadTask {
 547  public:
 548   GroupLoadTask(GURL manifest_url, AppCacheStorageImpl* storage)
 549       : StoreOrLoadTask(storage), manifest_url_(manifest_url),
 550         success_(false) {}
 551
 552   // DatabaseTask:
 553   void Run() override;
 554   void RunCompleted() override;
 555
 556  protected:
 557   ~GroupLoadTask() override {}
 558
 559  private:
 560   GURL manifest_url_;
 561   bool success_;
 562 };
 563
 564 void AppCacheStorageImpl::GroupLoadTask::Run() {
 565   tracked_objects::ScopedTracker tracking_profile(
 566       FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::GroupLoadTask"));
 567   success_ =
 568       database_->FindGroupForManifestUrl(manifest_url_, &group_record_) &&
 569       database_->FindCacheForGroup(group_record_.group_id, &cache_record_) &&
 570       FindRelatedCacheRecords(cache_record_.cache_id);
 571
 572   if (success_)
 573     database_->LazyUpdateLastAccessTime(group_record_.group_id,
 574                                         base::Time::Now());
 575 }
 576
 577 void AppCacheStorageImpl::GroupLoadTask::RunCompleted() {
 578   storage_->pending_group_loads_.erase(manifest_url_);
 579   scoped_refptr<AppCacheGroup> group;
 580   scoped_refptr<AppCache> cache;
 581   if (!storage_->is_disabled()) {
 582     if (success_) {
 583       storage_->LazilyCommitLastAccessTimes();
 584       DCHECK(group_record_.manifest_url == manifest_url_);
 585       CreateCacheAndGroupFromRecords(&cache, &group);
 586     } else {
 587       group = storage_->working_set_.GetGroup(manifest_url_);
 588       if (!group.get()) {
 589         group =
 590             new AppCacheGroup(storage_, manifest_url_, storage_->NewGroupId());
 591       }
 592     }
 593   }
 594   FOR_EACH_DELEGATE(delegates_, OnGroupLoaded(group.get(), manifest_url_));
 595 }
 596
 597 // StoreGroupAndCacheTask -------
 598
 599 class AppCacheStorageImpl::StoreGroupAndCacheTask : public StoreOrLoadTask {
 600  public:
 601   StoreGroupAndCacheTask(AppCacheStorageImpl* storage, AppCacheGroup* group,
 602                          AppCache* newest_cache);
 603
 604   void GetQuotaThenSchedule();
 605   void OnQuotaCallback(storage::QuotaStatusCode status,
 606                        int64 usage,
 607                        int64 quota);
 608
 609   // DatabaseTask:
 610   void Run() override;
 611   void RunCompleted() override;
 612   void CancelCompletion() override;
 613
 614  protected:
 615   ~StoreGroupAndCacheTask() override {}
 616
 617  private:
 618   scoped_refptr<AppCacheGroup> group_;
 619   scoped_refptr<AppCache> cache_;
 620   bool success_;
 621   bool would_exceed_quota_;
 622   int64 space_available_;
 623   int64 new_origin_usage_;
 624   std::vector<int64> newly_deletable_response_ids_;
 625 };
 626
 627 AppCacheStorageImpl::StoreGroupAndCacheTask::StoreGroupAndCacheTask(
 628     AppCacheStorageImpl* storage, AppCacheGroup* group, AppCache* newest_cache)
 629     : StoreOrLoadTask(storage), group_(group), cache_(newest_cache),
 630       success_(false), would_exceed_quota_(false),
 631       space_available_(-1), new_origin_usage_(-1) {
 632   group_record_.group_id = group->group_id();
 633   group_record_.manifest_url = group->manifest_url();
 634   group_record_.origin = group_record_.manifest_url.GetOrigin();
 635   newest_cache->ToDatabaseRecords(
 636       group,
 637       &cache_record_, &entry_records_,
 638       &intercept_namespace_records_,
 639       &fallback_namespace_records_,
 640       &online_whitelist_records_);
 641 }
 642
 643 void AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule() {
 644   storage::QuotaManager* quota_manager = NULL;
 645   if (storage_->service()->quota_manager_proxy()) {
 646     quota_manager =
 647         storage_->service()->quota_manager_proxy()->quota_manager();
 648   }
 649
 650   if (!quota_manager) {
 651     if (storage_->service()->special_storage_policy() &&
 652         storage_->service()->special_storage_policy()->IsStorageUnlimited(
 653             group_record_.origin))
 654       space_available_ = kint64max;
 655     Schedule();
 656     return;
 657   }
 658
 659   // We have to ask the quota manager for the value.
 660   storage_->pending_quota_queries_.insert(this);
 661   quota_manager->GetUsageAndQuota(
 662       group_record_.origin,
 663       storage::kStorageTypeTemporary,
 664       base::Bind(&StoreGroupAndCacheTask::OnQuotaCallback, this));
 665 }
 666
 667 void AppCacheStorageImpl::StoreGroupAndCacheTask::OnQuotaCallback(
 668     storage::QuotaStatusCode status,
 669     int64 usage,
 670     int64 quota) {
 671   if (storage_) {
 672     if (status == storage::kQuotaStatusOk)
 673       space_available_ = std::max(static_cast<int64>(0), quota - usage);
 674     else
 675       space_available_ = 0;
 676     storage_->pending_quota_queries_.erase(this);
 677     Schedule();
 678   }
 679 }
 680
 681 void AppCacheStorageImpl::StoreGroupAndCacheTask::Run() {
 682   DCHECK(!success_);
 683   sql::Connection* connection = database_->db_connection();
 684   if (!connection)
 685     return;
 686
 687   sql::Transaction transaction(connection);
 688   if (!transaction.Begin())
 689     return;
 690
 691   int64 old_origin_usage = database_->GetOriginUsage(group_record_.origin);
 692
 693   AppCacheDatabase::GroupRecord existing_group;
 694   success_ = database_->FindGroup(group_record_.group_id, &existing_group);
 695   if (!success_) {
 696     group_record_.creation_time = base::Time::Now();
 697     group_record_.last_access_time = base::Time::Now();
 698     success_ = database_->InsertGroup(&group_record_);
 699   } else {
 700     DCHECK(group_record_.group_id == existing_group.group_id);
 701     DCHECK(group_record_.manifest_url == existing_group.manifest_url);
 702     DCHECK(group_record_.origin == existing_group.origin);
 703
 704     database_->UpdateLastAccessTime(group_record_.group_id,
 705                                     base::Time::Now());
 706
 707     AppCacheDatabase::CacheRecord cache;
 708     if (database_->FindCacheForGroup(group_record_.group_id, &cache)) {
 709       // Get the set of response ids in the old cache.
 710       std::set<int64> existing_response_ids;
 711       database_->FindResponseIdsForCacheAsSet(cache.cache_id,
 712                                               &existing_response_ids);
 713
 714       // Remove those that remain in the new cache.
 715       std::vector<AppCacheDatabase::EntryRecord>::const_iterator entry_iter =
 716           entry_records_.begin();
 717       while (entry_iter != entry_records_.end()) {
 718         existing_response_ids.erase(entry_iter->response_id);
 719         ++entry_iter;
 720       }
 721
 722       // The rest are deletable.
 723       std::set<int64>::const_iterator id_iter = existing_response_ids.begin();
 724       while (id_iter != existing_response_ids.end()) {
 725         newly_deletable_response_ids_.push_back(*id_iter);
 726         ++id_iter;
 727       }
 728
 729       success_ =
 730           database_->DeleteCache(cache.cache_id) &&
 731           database_->DeleteEntriesForCache(cache.cache_id) &&
 732           database_->DeleteNamespacesForCache(cache.cache_id) &&
 733           database_->DeleteOnlineWhiteListForCache(cache.cache_id) &&
 734           database_->InsertDeletableResponseIds(newly_deletable_response_ids_);
 735           // TODO(michaeln): store group_id too with deletable ids
 736     } else {
 737       NOTREACHED() << "A existing group without a cache is unexpected";
 738     }
 739   }
 740
 741   success_ =
 742       success_ &&
 743       database_->InsertCache(&cache_record_) &&
 744       database_->InsertEntryRecords(entry_records_) &&
 745       database_->InsertNamespaceRecords(intercept_namespace_records_) &&
 746       database_->InsertNamespaceRecords(fallback_namespace_records_) &&
 747       database_->InsertOnlineWhiteListRecords(online_whitelist_records_);
 748
 749   if (!success_)
 750     return;
 751
 752   new_origin_usage_ = database_->GetOriginUsage(group_record_.origin);
 753
 754   // Only check quota when the new usage exceeds the old usage.
 755   if (new_origin_usage_ <= old_origin_usage) {
 756     success_ = transaction.Commit();
 757     return;
 758   }
 759
 760   // Use a simple hard-coded value when not using quota management.
 761   if (space_available_ == -1) {
 762     if (new_origin_usage_ > kDefaultQuota) {
 763       would_exceed_quota_ = true;
 764       success_ = false;
 765       return;
 766     }
 767     success_ = transaction.Commit();
 768     return;
 769   }
 770
 771   // Check limits based on the space availbable given to us via the
 772   // quota system.
 773   int64 delta = new_origin_usage_ - old_origin_usage;
 774   if (delta > space_available_) {
 775     would_exceed_quota_ = true;
 776     success_ = false;
 777     return;
 778   }
 779
 780   success_ = transaction.Commit();
 781 }
 782
 783 void AppCacheStorageImpl::StoreGroupAndCacheTask::RunCompleted() {
 784   if (success_) {
 785     storage_->UpdateUsageMapAndNotify(
 786         group_->manifest_url().GetOrigin(), new_origin_usage_);
 787     if (cache_.get() != group_->newest_complete_cache()) {
 788       cache_->set_complete(true);
 789       group_->AddCache(cache_.get());
 790     }
 791     if (group_->creation_time().is_null())
 792       group_->set_creation_time(group_record_.creation_time);
 793     group_->AddNewlyDeletableResponseIds(&newly_deletable_response_ids_);
 794   }
 795   FOR_EACH_DELEGATE(
 796       delegates_,
 797       OnGroupAndNewestCacheStored(
 798           group_.get(), cache_.get(), success_, would_exceed_quota_));
 799   group_ = NULL;
 800   cache_ = NULL;
 801
 802   // TODO(michaeln): if (would_exceed_quota_) what if the current usage
 803   // also exceeds the quota? http://crbug.com/83968
 804 }
 805
 806 void AppCacheStorageImpl::StoreGroupAndCacheTask::CancelCompletion() {
 807   // Overriden to safely drop our reference to the group and cache
 808   // which are not thread safe refcounted.
 809   DatabaseTask::CancelCompletion();
 810   group_ = NULL;
 811   cache_ = NULL;
 812 }
 813
 814 // FindMainResponseTask -------
 815
 816 // Helpers for FindMainResponseTask::Run()
 817 namespace {
 818 class SortByCachePreference
 819     : public std::binary_function<
 820         AppCacheDatabase::EntryRecord,
 821         AppCacheDatabase::EntryRecord,
 822         bool> {
 823  public:
 824   SortByCachePreference(int64 preferred_id, const std::set<int64>& in_use_ids)
 825       : preferred_id_(preferred_id), in_use_ids_(in_use_ids) {
 826   }
 827   bool operator()(
 828       const AppCacheDatabase::EntryRecord& lhs,
 829       const AppCacheDatabase::EntryRecord& rhs) {
 830     return compute_value(lhs) > compute_value(rhs);
 831   }
 832  private:
 833   int compute_value(const AppCacheDatabase::EntryRecord& entry) {
 834     if (entry.cache_id == preferred_id_)
 835       return 100;
 836     else if (in_use_ids_.find(entry.cache_id) != in_use_ids_.end())
 837       return 50;
 838     return 0;
 839   }
 840   int64 preferred_id_;
 841   const std::set<int64>& in_use_ids_;
 842 };
 843
 844 bool SortByLength(
 845     const AppCacheDatabase::NamespaceRecord& lhs,
 846     const AppCacheDatabase::NamespaceRecord& rhs) {
 847   return lhs.namespace_.namespace_url.spec().length() >
 848          rhs.namespace_.namespace_url.spec().length();
 849 }
 850
 851 class NetworkNamespaceHelper {
 852  public:
 853   explicit NetworkNamespaceHelper(AppCacheDatabase* database)
 854       : database_(database) {
 855   }
 856
 857   bool IsInNetworkNamespace(const GURL& url, int64 cache_id) {
 858     typedef std::pair<WhiteListMap::iterator, bool> InsertResult;
 859     InsertResult result = namespaces_map_.insert(
 860         WhiteListMap::value_type(cache_id, AppCacheNamespaceVector()));
 861     if (result.second)
 862       GetOnlineWhiteListForCache(cache_id, &result.first->second);
 863     return AppCache::FindNamespace(result.first->second, url) != NULL;
 864   }
 865
 866  private:
 867   void GetOnlineWhiteListForCache(
 868       int64 cache_id, AppCacheNamespaceVector* namespaces) {
 869     DCHECK(namespaces && namespaces->empty());
 870     typedef std::vector<AppCacheDatabase::OnlineWhiteListRecord>
 871         WhiteListVector;
 872     WhiteListVector records;
 873     if (!database_->FindOnlineWhiteListForCache(cache_id, &records))
 874       return;
 875     WhiteListVector::const_iterator iter = records.begin();
 876     while (iter != records.end()) {
 877       namespaces->push_back(
 878             AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, iter->namespace_url,
 879                 GURL(), iter->is_pattern));
 880       ++iter;
 881     }
 882   }
 883
 884   // Key is cache id
 885   typedef std::map<int64, AppCacheNamespaceVector> WhiteListMap;
 886   WhiteListMap namespaces_map_;
 887   AppCacheDatabase* database_;
 888 };
 889
 890 }  // namespace
 891
 892 class AppCacheStorageImpl::FindMainResponseTask : public DatabaseTask {
 893  public:
 894   FindMainResponseTask(AppCacheStorageImpl* storage,
 895                        const GURL& url,
 896                        const GURL& preferred_manifest_url,
 897                        const AppCacheWorkingSet::GroupMap* groups_in_use)
 898       : DatabaseTask(storage), url_(url),
 899         preferred_manifest_url_(preferred_manifest_url),
 900         cache_id_(kAppCacheNoCacheId), group_id_(0) {
 901     if (groups_in_use) {
 902       for (AppCacheWorkingSet::GroupMap::const_iterator it =
 903                groups_in_use->begin();
 904            it != groups_in_use->end(); ++it) {
 905         AppCacheGroup* group = it->second;
 906         AppCache* cache = group->newest_complete_cache();
 907         if (group->is_obsolete() || !cache)
 908           continue;
 909         cache_ids_in_use_.insert(cache->cache_id());
 910       }
 911     }
 912   }
 913
 914   // DatabaseTask:
 915   void Run() override;
 916   void RunCompleted() override;
 917
 918  protected:
 919   ~FindMainResponseTask() override {}
 920
 921  private:
 922   typedef std::vector<AppCacheDatabase::NamespaceRecord*>
 923       NamespaceRecordPtrVector;
 924
 925   bool FindExactMatch(int64 preferred_id);
 926   bool FindNamespaceMatch(int64 preferred_id);
 927   bool FindNamespaceHelper(
 928       int64 preferred_cache_id,
 929       AppCacheDatabase::NamespaceRecordVector* namespaces,
 930       NetworkNamespaceHelper* network_namespace_helper);
 931   bool FindFirstValidNamespace(const NamespaceRecordPtrVector& namespaces);
 932
 933   GURL url_;
 934   GURL preferred_manifest_url_;
 935   std::set<int64> cache_ids_in_use_;
 936   AppCacheEntry entry_;
 937   AppCacheEntry fallback_entry_;
 938   GURL namespace_entry_url_;
 939   int64 cache_id_;
 940   int64 group_id_;
 941   GURL manifest_url_;
 942 };
 943
 944 void AppCacheStorageImpl::FindMainResponseTask::Run() {
 945   tracked_objects::ScopedTracker tracking_profile(
 946       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 947           "AppCacheStorageImpl::FindMainResponseTask"));
 948   // NOTE: The heuristics around choosing amoungst multiple candidates
 949   // is underspecified, and just plain not fully understood. This needs
 950   // to be refined.
 951
 952   // The 'preferred_manifest_url' is the url of the manifest associated
 953   // with the page that opened or embedded the page being loaded now.
 954   // We have a strong preference to use resources from that cache.
 955   // We also have a lesser bias to use resources from caches that are currently
 956   // being used by other unrelated pages.
 957   // TODO(michaeln): come up with a 'preferred_manifest_url' in more cases
 958   // - when navigating a frame whose current contents are from an appcache
 959   // - when clicking an href in a frame that is appcached
 960   int64 preferred_cache_id = kAppCacheNoCacheId;
 961   if (!preferred_manifest_url_.is_empty()) {
 962     AppCacheDatabase::GroupRecord preferred_group;
 963     AppCacheDatabase::CacheRecord preferred_cache;
 964     if (database_->FindGroupForManifestUrl(
 965             preferred_manifest_url_, &preferred_group) &&
 966         database_->FindCacheForGroup(
 967             preferred_group.group_id, &preferred_cache)) {
 968       preferred_cache_id = preferred_cache.cache_id;
 969     }
 970   }
 971
 972   if (FindExactMatch(preferred_cache_id) ||
 973       FindNamespaceMatch(preferred_cache_id)) {
 974     // We found something.
 975     DCHECK(cache_id_ != kAppCacheNoCacheId && !manifest_url_.is_empty() &&
 976            group_id_ != 0);
 977     return;
 978   }
 979
 980   // We didn't find anything.
 981   DCHECK(cache_id_ == kAppCacheNoCacheId && manifest_url_.is_empty() &&
 982          group_id_ == 0);
 983 }
 984
 985 bool AppCacheStorageImpl::
 986 FindMainResponseTask::FindExactMatch(int64 preferred_cache_id) {
 987   std::vector<AppCacheDatabase::EntryRecord> entries;
 988   if (database_->FindEntriesForUrl(url_, &entries) && !entries.empty()) {
 989     // Sort them in order of preference, from the preferred_cache first,
 990     // followed by hits from caches that are 'in use', then the rest.
 991     std::sort(entries.begin(), entries.end(),
 992               SortByCachePreference(preferred_cache_id, cache_ids_in_use_));
 993
 994     // Take the first with a valid, non-foreign entry.
 995     std::vector<AppCacheDatabase::EntryRecord>::iterator iter;
 996     for (iter = entries.begin(); iter < entries.end(); ++iter) {
 997       AppCacheDatabase::GroupRecord group_record;
 998       if ((iter->flags & AppCacheEntry::FOREIGN) ||
 999           !database_->FindGroupForCache(iter->cache_id, &group_record)) {
1000         continue;
1001       }
1002       manifest_url_ = group_record.manifest_url;
1003       group_id_ = group_record.group_id;
1004       entry_ = AppCacheEntry(iter->flags, iter->response_id);
1005       cache_id_ = iter->cache_id;
1006       return true;  // We found an exact match.
1007     }
1008   }
1009   return false;
1010 }
1011
1012 bool AppCacheStorageImpl::
1013 FindMainResponseTask::FindNamespaceMatch(int64 preferred_cache_id) {
1014   AppCacheDatabase::NamespaceRecordVector all_intercepts;
1015   AppCacheDatabase::NamespaceRecordVector all_fallbacks;
1016   if (!database_->FindNamespacesForOrigin(
1017           url_.GetOrigin(), &all_intercepts, &all_fallbacks)
1018       || (all_intercepts.empty() && all_fallbacks.empty())) {
1019     return false;
1020   }
1021
1022   NetworkNamespaceHelper network_namespace_helper(database_);
1023   if (FindNamespaceHelper(preferred_cache_id,
1024                           &all_intercepts,
1025                           &network_namespace_helper) ||
1026       FindNamespaceHelper(preferred_cache_id,
1027                           &all_fallbacks,
1028                           &network_namespace_helper)) {
1029     return true;
1030   }
1031   return false;
1032 }
1033
1034 bool AppCacheStorageImpl::
1035 FindMainResponseTask::FindNamespaceHelper(
1036     int64 preferred_cache_id,
1037     AppCacheDatabase::NamespaceRecordVector* namespaces,
1038     NetworkNamespaceHelper* network_namespace_helper) {
1039   // Sort them by length, longer matches within the same cache/bucket take
1040   // precedence.
1041   std::sort(namespaces->begin(), namespaces->end(), SortByLength);
1042
1043   NamespaceRecordPtrVector preferred_namespaces;
1044   NamespaceRecordPtrVector inuse_namespaces;
1045   NamespaceRecordPtrVector other_namespaces;
1046   std::vector<AppCacheDatabase::NamespaceRecord>::iterator iter;
1047   for (iter = namespaces->begin(); iter < namespaces->end(); ++iter) {
1048     // Skip those that aren't a match.
1049     if (!iter->namespace_.IsMatch(url_))
1050       continue;
1051
1052     // Skip namespaces where the requested url falls into a network
1053     // namespace of its containing appcache.
1054     if (network_namespace_helper->IsInNetworkNamespace(url_, iter->cache_id))
1055       continue;
1056
1057     // Bin them into one of our three buckets.
1058     if (iter->cache_id == preferred_cache_id)
1059       preferred_namespaces.push_back(&(*iter));
1060     else if (cache_ids_in_use_.find(iter->cache_id) != cache_ids_in_use_.end())
1061       inuse_namespaces.push_back(&(*iter));
1062     else
1063       other_namespaces.push_back(&(*iter));
1064   }
1065
1066   if (FindFirstValidNamespace(preferred_namespaces) ||
1067       FindFirstValidNamespace(inuse_namespaces) ||
1068       FindFirstValidNamespace(other_namespaces))
1069     return true;  // We found one.
1070
1071   // We didn't find anything.
1072   return false;
1073 }
1074
1075 bool AppCacheStorageImpl::
1076 FindMainResponseTask::FindFirstValidNamespace(
1077     const NamespaceRecordPtrVector& namespaces) {
1078   // Take the first with a valid, non-foreign entry.
1079   NamespaceRecordPtrVector::const_iterator iter;
1080   for (iter = namespaces.begin(); iter < namespaces.end();  ++iter) {
1081     AppCacheDatabase::EntryRecord entry_record;
1082     if (database_->FindEntry((*iter)->cache_id, (*iter)->namespace_.target_url,
1083                              &entry_record)) {
1084       AppCacheDatabase::GroupRecord group_record;
1085       if ((entry_record.flags & AppCacheEntry::FOREIGN) ||
1086           !database_->FindGroupForCache(entry_record.cache_id, &group_record)) {
1087         continue;
1088       }
1089       manifest_url_ = group_record.manifest_url;
1090       group_id_ = group_record.group_id;
1091       cache_id_ = (*iter)->cache_id;
1092       namespace_entry_url_ = (*iter)->namespace_.target_url;
1093       if ((*iter)->namespace_.type == APPCACHE_FALLBACK_NAMESPACE)
1094         fallback_entry_ = AppCacheEntry(entry_record.flags,
1095                                         entry_record.response_id);
1096       else
1097         entry_ = AppCacheEntry(entry_record.flags, entry_record.response_id);
1098       return true;  // We found one.
1099     }
1100   }
1101   return false;  // We didn't find a match.
1102 }
1103
1104 void AppCacheStorageImpl::FindMainResponseTask::RunCompleted() {
1105   storage_->CallOnMainResponseFound(
1106       &delegates_, url_, entry_, namespace_entry_url_, fallback_entry_,
1107       cache_id_, group_id_, manifest_url_);
1108 }
1109
1110 // MarkEntryAsForeignTask -------
1111
1112 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
1113  public:
1114   MarkEntryAsForeignTask(
1115       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
1116       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
1117
1118   // DatabaseTask:
1119   void Run() override;
1120   void RunCompleted() override;
1121
1122  protected:
1123   ~MarkEntryAsForeignTask() override {}
1124
1125  private:
1126   int64 cache_id_;
1127   GURL entry_url_;
1128 };
1129
1130 void AppCacheStorageImpl::MarkEntryAsForeignTask::Run() {
1131   database_->AddEntryFlags(entry_url_, cache_id_, AppCacheEntry::FOREIGN);
1132 }
1133
1134 void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
1135   DCHECK(storage_->pending_foreign_markings_.front().first == entry_url_ &&
1136          storage_->pending_foreign_markings_.front().second == cache_id_);
1137   storage_->pending_foreign_markings_.pop_front();
1138 }
1139
1140 // MakeGroupObsoleteTask -------
1141
1142 class AppCacheStorageImpl::MakeGroupObsoleteTask : public DatabaseTask {
1143  public:
1144   MakeGroupObsoleteTask(AppCacheStorageImpl* storage,
1145                         AppCacheGroup* group,
1146                         int response_code);
1147
1148   // DatabaseTask:
1149   void Run() override;
1150   void RunCompleted() override;
1151   void CancelCompletion() override;
1152
1153  protected:
1154   ~MakeGroupObsoleteTask() override {}
1155
1156  private:
1157   scoped_refptr<AppCacheGroup> group_;
1158   int64 group_id_;
1159   GURL origin_;
1160   bool success_;
1161   int response_code_;
1162   int64 new_origin_usage_;
1163   std::vector<int64> newly_deletable_response_ids_;
1164 };
1165
1166 AppCacheStorageImpl::MakeGroupObsoleteTask::MakeGroupObsoleteTask(
1167     AppCacheStorageImpl* storage,
1168     AppCacheGroup* group,
1169     int response_code)
1170     : DatabaseTask(storage),
1171       group_(group),
1172       group_id_(group->group_id()),
1173       origin_(group->manifest_url().GetOrigin()),
1174       success_(false),
1175       response_code_(response_code),
1176       new_origin_usage_(-1) {}
1177
1178 void AppCacheStorageImpl::MakeGroupObsoleteTask::Run() {
1179   DCHECK(!success_);
1180   sql::Connection* connection = database_->db_connection();
1181   if (!connection)
1182     return;
1183
1184   sql::Transaction transaction(connection);
1185   if (!transaction.Begin())
1186     return;
1187
1188   AppCacheDatabase::GroupRecord group_record;
1189   if (!database_->FindGroup(group_id_, &group_record)) {
1190     // This group doesn't exists in the database, nothing todo here.
1191     new_origin_usage_ = database_->GetOriginUsage(origin_);
1192     success_ = true;
1193     return;
1194   }
1195
1196   DCHECK_EQ(group_record.origin, origin_);
1197   success_ = DeleteGroupAndRelatedRecords(database_,
1198                                           group_id_,
1199                                           &newly_deletable_response_ids_);
1200
1201   new_origin_usage_ = database_->GetOriginUsage(origin_);
1202   success_ = success_ && transaction.Commit();
1203 }
1204
1205 void AppCacheStorageImpl::MakeGroupObsoleteTask::RunCompleted() {
1206   if (success_) {
1207     group_->set_obsolete(true);
1208     if (!storage_->is_disabled()) {
1209       storage_->UpdateUsageMapAndNotify(origin_, new_origin_usage_);
1210       group_->AddNewlyDeletableResponseIds(&newly_deletable_response_ids_);
1211
1212       // Also remove from the working set, caches for an 'obsolete' group
1213       // may linger in use, but the group itself cannot be looked up by
1214       // 'manifest_url' in the working set any longer.
1215       storage_->working_set()->RemoveGroup(group_.get());
1216     }
1217   }
1218   FOR_EACH_DELEGATE(
1219       delegates_, OnGroupMadeObsolete(group_.get(), success_, response_code_));
1220   group_ = NULL;
1221 }
1222
1223 void AppCacheStorageImpl::MakeGroupObsoleteTask::CancelCompletion() {
1224   // Overriden to safely drop our reference to the group
1225   // which is not thread safe refcounted.
1226   DatabaseTask::CancelCompletion();
1227   group_ = NULL;
1228 }
1229
1230 // GetDeletableResponseIdsTask -------
1231
1232 class AppCacheStorageImpl::GetDeletableResponseIdsTask : public DatabaseTask {
1233  public:
1234   GetDeletableResponseIdsTask(AppCacheStorageImpl* storage, int64 max_rowid)
1235       : DatabaseTask(storage), max_rowid_(max_rowid) {}
1236
1237   // DatabaseTask:
1238   void Run() override;
1239   void RunCompleted() override;
1240
1241  protected:
1242   ~GetDeletableResponseIdsTask() override {}
1243
1244  private:
1245   int64 max_rowid_;
1246   std::vector<int64> response_ids_;
1247 };
1248
1249 void AppCacheStorageImpl::GetDeletableResponseIdsTask::Run() {
1250   const int kSqlLimit = 1000;
1251   database_->GetDeletableResponseIds(&response_ids_, max_rowid_, kSqlLimit);
1252   // TODO(michaeln): retrieve group_ids too
1253 }
1254
1255 void AppCacheStorageImpl::GetDeletableResponseIdsTask::RunCompleted() {
1256   if (!response_ids_.empty())
1257     storage_->StartDeletingResponses(response_ids_);
1258 }
1259
1260 // InsertDeletableResponseIdsTask -------
1261
1262 class AppCacheStorageImpl::InsertDeletableResponseIdsTask
1263     : public DatabaseTask {
1264  public:
1265   explicit InsertDeletableResponseIdsTask(AppCacheStorageImpl* storage)
1266       : DatabaseTask(storage) {}
1267
1268   // DatabaseTask:
1269   void Run() override;
1270
1271   std::vector<int64> response_ids_;
1272
1273  protected:
1274   ~InsertDeletableResponseIdsTask() override {}
1275 };
1276
1277 void AppCacheStorageImpl::InsertDeletableResponseIdsTask::Run() {
1278   database_->InsertDeletableResponseIds(response_ids_);
1279   // TODO(michaeln): store group_ids too
1280 }
1281
1282 // DeleteDeletableResponseIdsTask -------
1283
1284 class AppCacheStorageImpl::DeleteDeletableResponseIdsTask
1285     : public DatabaseTask {
1286  public:
1287   explicit DeleteDeletableResponseIdsTask(AppCacheStorageImpl* storage)
1288       : DatabaseTask(storage) {}
1289
1290   // DatabaseTask:
1291   void Run() override;
1292
1293   std::vector<int64> response_ids_;
1294
1295  protected:
1296   ~DeleteDeletableResponseIdsTask() override {}
1297 };
1298
1299 void AppCacheStorageImpl::DeleteDeletableResponseIdsTask::Run() {
1300   database_->DeleteDeletableResponseIds(response_ids_);
1301 }
1302
1303 // LazyUpdateLastAccessTimeTask -------
1304
1305 class AppCacheStorageImpl::LazyUpdateLastAccessTimeTask
1306     : public DatabaseTask {
1307  public:
1308   LazyUpdateLastAccessTimeTask(
1309       AppCacheStorageImpl* storage, AppCacheGroup* group, base::Time time)
1310       : DatabaseTask(storage), group_id_(group->group_id()),
1311         last_access_time_(time) {
1312     storage->NotifyStorageAccessed(group->manifest_url().GetOrigin());
1313   }
1314
1315   // DatabaseTask:
1316   void Run() override;
1317   void RunCompleted() override;
1318
1319  protected:
1320   ~LazyUpdateLastAccessTimeTask() override {}
1321
1322  private:
1323   int64 group_id_;
1324   base::Time last_access_time_;
1325 };
1326
1327 void AppCacheStorageImpl::LazyUpdateLastAccessTimeTask::Run() {
1328   tracked_objects::ScopedTracker tracking_profile(
1329       FROM_HERE_WITH_EXPLICIT_FUNCTION(
1330           "AppCacheStorageImpl::LazyUpdateLastAccessTimeTask"));
1331   database_->LazyUpdateLastAccessTime(group_id_, last_access_time_);
1332 }
1333
1334 void AppCacheStorageImpl::LazyUpdateLastAccessTimeTask::RunCompleted() {
1335   storage_->LazilyCommitLastAccessTimes();
1336 }
1337
1338 // CommitLastAccessTimesTask -------
1339
1340 class AppCacheStorageImpl::CommitLastAccessTimesTask
1341     : public DatabaseTask {
1342  public:
1343   CommitLastAccessTimesTask(AppCacheStorageImpl* storage)
1344       : DatabaseTask(storage) {}
1345
1346   // DatabaseTask:
1347   void Run() override {
1348     tracked_objects::ScopedTracker tracking_profile(
1349         FROM_HERE_WITH_EXPLICIT_FUNCTION(
1350             "AppCacheStorageImpl::CommitLastAccessTimesTask"));
1351     database_->CommitLazyLastAccessTimes();
1352   }
1353
1354  protected:
1355   ~CommitLastAccessTimesTask() override {}
1356 };
1357
1358 // AppCacheStorageImpl ---------------------------------------------------
1359
1360 AppCacheStorageImpl::AppCacheStorageImpl(AppCacheServiceImpl* service)
1361     : AppCacheStorage(service),
1362       is_incognito_(false),
1363       is_response_deletion_scheduled_(false),
1364       did_start_deleting_responses_(false),
1365       last_deletable_response_rowid_(0),
1366       database_(NULL),
1367       is_disabled_(false),
1368       weak_factory_(this) {
1369 }
1370
1371 AppCacheStorageImpl::~AppCacheStorageImpl() {
1372   std::for_each(pending_quota_queries_.begin(),
1373                 pending_quota_queries_.end(),
1374                 std::mem_fun(&DatabaseTask::CancelCompletion));
1375   std::for_each(scheduled_database_tasks_.begin(),
1376                 scheduled_database_tasks_.end(),
1377                 std::mem_fun(&DatabaseTask::CancelCompletion));
1378
1379   if (database_ &&
1380       !db_thread_->PostTask(
1381           FROM_HERE,
1382           base::Bind(&ClearSessionOnlyOrigins,
1383                      database_,
1384                      make_scoped_refptr(service_->special_storage_policy()),
1385                      service()->force_keep_session_state()))) {
1386     delete database_;
1387   }
1388   database_ = NULL;  // So no further database tasks can be scheduled.
1389 }
1390
1391 void AppCacheStorageImpl::Initialize(
1392     const base::FilePath& cache_directory,
1393     const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
1394     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread) {
1395   DCHECK(db_thread.get());
1396
1397   cache_directory_ = cache_directory;
1398   is_incognito_ = cache_directory_.empty();
1399
1400   base::FilePath db_file_path;
1401   if (!is_incognito_)
1402     db_file_path = cache_directory_.Append(kAppCacheDatabaseName);
1403   database_ = new AppCacheDatabase(db_file_path);
1404
1405   db_thread_ = db_thread;
1406   cache_thread_ = cache_thread;
1407
1408   scoped_refptr<InitTask> task(new InitTask(this));
1409   task->Schedule();
1410 }
1411
1412 void AppCacheStorageImpl::Disable() {
1413   if (is_disabled_)
1414     return;
1415   VLOG(1) << "Disabling appcache storage.";
1416   is_disabled_ = true;
1417   ClearUsageMapAndNotify();
1418   working_set()->Disable();
1419   if (disk_cache_)
1420     disk_cache_->Disable();
1421   scoped_refptr<DisableDatabaseTask> task(new DisableDatabaseTask(this));
1422   task->Schedule();
1423 }
1424
1425 void AppCacheStorageImpl::GetAllInfo(Delegate* delegate) {
1426   DCHECK(delegate);
1427   scoped_refptr<GetAllInfoTask> task(new GetAllInfoTask(this));
1428   task->AddDelegate(GetOrCreateDelegateReference(delegate));
1429   task->Schedule();
1430 }
1431
1432 void AppCacheStorageImpl::LoadCache(int64 id, Delegate* delegate) {
1433   DCHECK(delegate);
1434   if (is_disabled_) {
1435     delegate->OnCacheLoaded(NULL, id);
1436     return;
1437   }
1438
1439   AppCache* cache = working_set_.GetCache(id);
1440   if (cache) {
1441     delegate->OnCacheLoaded(cache, id);
1442     if (cache->owning_group()) {
1443       scoped_refptr<DatabaseTask> update_task(
1444           new LazyUpdateLastAccessTimeTask(
1445               this, cache->owning_group(), base::Time::Now()));
1446       update_task->Schedule();
1447     }
1448     return;
1449   }
1450   scoped_refptr<CacheLoadTask> task(GetPendingCacheLoadTask(id));
1451   if (task.get()) {
1452     task->AddDelegate(GetOrCreateDelegateReference(delegate));
1453     return;
1454   }
1455   task = new CacheLoadTask(id, this);
1456   task->AddDelegate(GetOrCreateDelegateReference(delegate));
1457   task->Schedule();
1458   pending_cache_loads_[id] = task.get();
1459 }
1460
1461 void AppCacheStorageImpl::LoadOrCreateGroup(
1462     const GURL& manifest_url, Delegate* delegate) {
1463   DCHECK(delegate);
1464   if (is_disabled_) {
1465     delegate->OnGroupLoaded(NULL, manifest_url);
1466     return;
1467   }
1468
1469   AppCacheGroup* group = working_set_.GetGroup(manifest_url);
1470   if (group) {
1471     delegate->OnGroupLoaded(group, manifest_url);
1472     scoped_refptr<DatabaseTask> update_task(
1473         new LazyUpdateLastAccessTimeTask(
1474             this, group, base::Time::Now()));
1475     update_task->Schedule();
1476     return;
1477   }
1478
1479   scoped_refptr<GroupLoadTask> task(GetPendingGroupLoadTask(manifest_url));
1480   if (task.get()) {
1481     task->AddDelegate(GetOrCreateDelegateReference(delegate));
1482     return;
1483   }
1484
1485   if (usage_map_.find(manifest_url.GetOrigin()) == usage_map_.end()) {
1486     // No need to query the database, return a new group immediately.
1487     scoped_refptr<AppCacheGroup> group(new AppCacheGroup(
1488         this, manifest_url, NewGroupId()));
1489     delegate->OnGroupLoaded(group.get(), manifest_url);
1490     return;
1491   }
1492
1493   task = new GroupLoadTask(manifest_url, this);
1494   task->AddDelegate(GetOrCreateDelegateReference(delegate));
1495   task->Schedule();
1496   pending_group_loads_[manifest_url] = task.get();
1497 }
1498
1499 void AppCacheStorageImpl::StoreGroupAndNewestCache(
1500     AppCacheGroup* group, AppCache* newest_cache, Delegate* delegate) {
1501   // TODO(michaeln): distinguish between a simple update of an existing
1502   // cache that just adds new master entry(s), and the insertion of a
1503   // whole new cache. The StoreGroupAndCacheTask as written will handle
1504   // the simple update case in a very heavy weight way (delete all and
1505   // the reinsert all over again).
1506   DCHECK(group && delegate && newest_cache);
1507   scoped_refptr<StoreGroupAndCacheTask> task(
1508       new StoreGroupAndCacheTask(this, group, newest_cache));
1509   task->AddDelegate(GetOrCreateDelegateReference(delegate));
1510   task->GetQuotaThenSchedule();
1511
1512   // TODO(michaeln): histogram is fishing for clues to crbug/95101
1513   if (!newest_cache->GetEntry(group->manifest_url())) {
1514     AppCacheHistograms::AddMissingManifestDetectedAtCallsite(
1515         AppCacheHistograms::CALLSITE_3);
1516   }
1517 }
1518
1519 void AppCacheStorageImpl::FindResponseForMainRequest(
1520     const GURL& url, const GURL& preferred_manifest_url,
1521     Delegate* delegate) {
1522   DCHECK(delegate);
1523
1524   const GURL* url_ptr = &url;
1525   GURL url_no_ref;
1526   if (url.has_ref()) {
1527     GURL::Replacements replacements;
1528     replacements.ClearRef();
1529     url_no_ref = url.ReplaceComponents(replacements);
1530     url_ptr = &url_no_ref;
1531   }
1532
1533   const GURL origin = url.GetOrigin();
1534
1535   // First look in our working set for a direct hit without having to query
1536   // the database.
1537   const AppCacheWorkingSet::GroupMap* groups_in_use =
1538       working_set()->GetGroupsInOrigin(origin);
1539   if (groups_in_use) {
1540     if (!preferred_manifest_url.is_empty()) {
1541       AppCacheWorkingSet::GroupMap::const_iterator found =
1542           groups_in_use->find(preferred_manifest_url);
1543       if (found != groups_in_use->end() &&
1544           FindResponseForMainRequestInGroup(
1545               found->second, *url_ptr, delegate)) {
1546           return;
1547       }
1548     } else {
1549       for (AppCacheWorkingSet::GroupMap::const_iterator it =
1550               groups_in_use->begin();
1551            it != groups_in_use->end(); ++it) {
1552         if (FindResponseForMainRequestInGroup(
1553                 it->second, *url_ptr, delegate)) {
1554           return;
1555         }
1556       }
1557     }
1558   }
1559
1560   if (IsInitTaskComplete() &&  usage_map_.find(origin) == usage_map_.end()) {
1561     // No need to query the database, return async'ly but without going thru
1562     // the DB thread.
1563     scoped_refptr<AppCacheGroup> no_group;
1564     scoped_refptr<AppCache> no_cache;
1565     ScheduleSimpleTask(
1566         base::Bind(&AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse,
1567                    weak_factory_.GetWeakPtr(), url, AppCacheEntry(), no_group,
1568                    no_cache,
1569                    make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
1570     return;
1571   }
1572
1573   // We have to query the database, schedule a database task to do so.
1574   scoped_refptr<FindMainResponseTask> task(
1575       new FindMainResponseTask(this, *url_ptr, preferred_manifest_url,
1576                                groups_in_use));
1577   task->AddDelegate(GetOrCreateDelegateReference(delegate));
1578   task->Schedule();
1579 }
1580
1581 bool AppCacheStorageImpl::FindResponseForMainRequestInGroup(
1582     AppCacheGroup* group,  const GURL& url, Delegate* delegate) {
1583   AppCache* cache = group->newest_complete_cache();
1584   if (group->is_obsolete() || !cache)
1585     return false;
1586
1587   AppCacheEntry* entry = cache->GetEntry(url);
1588   if (!entry || entry->IsForeign())
1589     return false;
1590
1591   ScheduleSimpleTask(
1592       base::Bind(&AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse,
1593                  weak_factory_.GetWeakPtr(), url, *entry,
1594                  make_scoped_refptr(group), make_scoped_refptr(cache),
1595                  make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
1596   return true;
1597 }
1598
1599 void AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse(
1600     const GURL& url,
1601     const AppCacheEntry& found_entry,
1602     scoped_refptr<AppCacheGroup> group,
1603     scoped_refptr<AppCache> cache,
1604     scoped_refptr<DelegateReference> delegate_ref) {
1605   if (delegate_ref->delegate) {
1606     DelegateReferenceVector delegates(1, delegate_ref);
1607     CallOnMainResponseFound(
1608         &delegates, url, found_entry,
1609         GURL(), AppCacheEntry(),
1610         cache.get() ? cache->cache_id() : kAppCacheNoCacheId,
1611         group.get() ? group->group_id() : kAppCacheNoCacheId,
1612         group.get() ? group->manifest_url() : GURL());
1613   }
1614 }
1615
1616 void AppCacheStorageImpl::CallOnMainResponseFound(
1617     DelegateReferenceVector* delegates,
1618     const GURL& url, const AppCacheEntry& entry,
1619     const GURL& namespace_entry_url, const AppCacheEntry& fallback_entry,
1620     int64 cache_id, int64 group_id, const GURL& manifest_url) {
1621   FOR_EACH_DELEGATE(
1622       (*delegates),
1623       OnMainResponseFound(url, entry,
1624                           namespace_entry_url, fallback_entry,
1625                           cache_id, group_id, manifest_url));
1626 }
1627
1628 void AppCacheStorageImpl::FindResponseForSubRequest(
1629     AppCache* cache, const GURL& url,
1630     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
1631     bool* found_network_namespace) {
1632   DCHECK(cache && cache->is_complete());
1633
1634   // When a group is forcibly deleted, all subresource loads for pages
1635   // using caches in the group will result in a synthesized network errors.
1636   // Forcible deletion is not a function that is covered by the HTML5 spec.
1637   if (cache->owning_group()->is_being_deleted()) {
1638     *found_entry = AppCacheEntry();
1639     *found_fallback_entry = AppCacheEntry();
1640     *found_network_namespace = false;
1641     return;
1642   }
1643
1644   GURL fallback_namespace_not_used;
1645   GURL intercept_namespace_not_used;
1646   cache->FindResponseForRequest(
1647       url, found_entry, &intercept_namespace_not_used,
1648       found_fallback_entry, &fallback_namespace_not_used,
1649       found_network_namespace);
1650 }
1651
1652 void AppCacheStorageImpl::MarkEntryAsForeign(
1653     const GURL& entry_url, int64 cache_id) {
1654   AppCache* cache = working_set_.GetCache(cache_id);
1655   if (cache) {
1656     AppCacheEntry* entry = cache->GetEntry(entry_url);
1657     DCHECK(entry);
1658     if (entry)
1659       entry->add_types(AppCacheEntry::FOREIGN);
1660   }
1661   scoped_refptr<MarkEntryAsForeignTask> task(
1662       new MarkEntryAsForeignTask(this, entry_url, cache_id));
1663   task->Schedule();
1664   pending_foreign_markings_.push_back(std::make_pair(entry_url, cache_id));
1665 }
1666
1667 void AppCacheStorageImpl::MakeGroupObsolete(AppCacheGroup* group,
1668                                             Delegate* delegate,
1669                                             int response_code) {
1670   DCHECK(group && delegate);
1671   scoped_refptr<MakeGroupObsoleteTask> task(
1672       new MakeGroupObsoleteTask(this, group, response_code));
1673   task->AddDelegate(GetOrCreateDelegateReference(delegate));
1674   task->Schedule();
1675 }
1676
1677 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
1678     const GURL& manifest_url, int64 group_id, int64 response_id) {
1679   return new AppCacheResponseReader(response_id, group_id, disk_cache());
1680 }
1681
1682 AppCacheResponseWriter* AppCacheStorageImpl::CreateResponseWriter(
1683     const GURL& manifest_url, int64 group_id) {
1684   return new AppCacheResponseWriter(NewResponseId(), group_id, disk_cache());
1685 }
1686
1687 AppCacheResponseMetadataWriter*
1688 AppCacheStorageImpl::CreateResponseMetadataWriter(int64 group_id,
1689                                                   int64 response_id) {
1690   return new AppCacheResponseMetadataWriter(response_id, group_id,
1691                                             disk_cache());
1692 }
1693
1694 void AppCacheStorageImpl::DoomResponses(
1695     const GURL& manifest_url, const std::vector<int64>& response_ids) {
1696   if (response_ids.empty())
1697     return;
1698
1699   // Start deleting them from the disk cache lazily.
1700   StartDeletingResponses(response_ids);
1701
1702   // Also schedule a database task to record these ids in the
1703   // deletable responses table.
1704   // TODO(michaeln): There is a race here. If the browser crashes
1705   // prior to committing these rows to the database and prior to us
1706   // having deleted them from the disk cache, we'll never delete them.
1707   scoped_refptr<InsertDeletableResponseIdsTask> task(
1708       new InsertDeletableResponseIdsTask(this));
1709   task->response_ids_ = response_ids;
1710   task->Schedule();
1711 }
1712
1713 void AppCacheStorageImpl::DeleteResponses(
1714     const GURL& manifest_url, const std::vector<int64>& response_ids) {
1715   if (response_ids.empty())
1716     return;
1717   StartDeletingResponses(response_ids);
1718 }
1719
1720 void AppCacheStorageImpl::DelayedStartDeletingUnusedResponses() {
1721   // Only if we haven't already begun.
1722   if (!did_start_deleting_responses_) {
1723     scoped_refptr<GetDeletableResponseIdsTask> task(
1724         new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_));
1725     task->Schedule();
1726   }
1727 }
1728
1729 void AppCacheStorageImpl::StartDeletingResponses(
1730     const std::vector<int64>& response_ids) {
1731   DCHECK(!response_ids.empty());
1732   did_start_deleting_responses_ = true;
1733   deletable_response_ids_.insert(
1734       deletable_response_ids_.end(),
1735       response_ids.begin(), response_ids.end());
1736   if (!is_response_deletion_scheduled_)
1737     ScheduleDeleteOneResponse();
1738 }
1739
1740 void AppCacheStorageImpl::ScheduleDeleteOneResponse() {
1741   DCHECK(!is_response_deletion_scheduled_);
1742   const base::TimeDelta kBriefDelay = base::TimeDelta::FromMilliseconds(10);
1743   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
1744       FROM_HERE, base::Bind(&AppCacheStorageImpl::DeleteOneResponse,
1745                             weak_factory_.GetWeakPtr()),
1746       kBriefDelay);
1747   is_response_deletion_scheduled_ = true;
1748 }
1749
1750 void AppCacheStorageImpl::DeleteOneResponse() {
1751   DCHECK(is_response_deletion_scheduled_);
1752   DCHECK(!deletable_response_ids_.empty());
1753
1754   if (!disk_cache()) {
1755     DCHECK(is_disabled_);
1756     deletable_response_ids_.clear();
1757     deleted_response_ids_.clear();
1758     is_response_deletion_scheduled_ = false;
1759     return;
1760   }
1761
1762   // TODO(michaeln): add group_id to DoomEntry args
1763   int64 id = deletable_response_ids_.front();
1764   int rv = disk_cache_->DoomEntry(
1765       id, base::Bind(&AppCacheStorageImpl::OnDeletedOneResponse,
1766                      base::Unretained(this)));
1767   if (rv != net::ERR_IO_PENDING)
1768     OnDeletedOneResponse(rv);
1769 }
1770
1771 void AppCacheStorageImpl::OnDeletedOneResponse(int rv) {
1772   is_response_deletion_scheduled_ = false;
1773   if (is_disabled_)
1774     return;
1775
1776   int64 id = deletable_response_ids_.front();
1777   deletable_response_ids_.pop_front();
1778   if (rv != net::ERR_ABORTED)
1779     deleted_response_ids_.push_back(id);
1780
1781   const size_t kBatchSize = 50U;
1782   if (deleted_response_ids_.size() >= kBatchSize ||
1783       deletable_response_ids_.empty()) {
1784     scoped_refptr<DeleteDeletableResponseIdsTask> task(
1785         new DeleteDeletableResponseIdsTask(this));
1786     task->response_ids_.swap(deleted_response_ids_);
1787     task->Schedule();
1788   }
1789
1790   if (deletable_response_ids_.empty()) {
1791     scoped_refptr<GetDeletableResponseIdsTask> task(
1792         new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_));
1793     task->Schedule();
1794     return;
1795   }
1796
1797   ScheduleDeleteOneResponse();
1798 }
1799
1800 AppCacheStorageImpl::CacheLoadTask*
1801 AppCacheStorageImpl::GetPendingCacheLoadTask(int64 cache_id) {
1802   PendingCacheLoads::iterator found = pending_cache_loads_.find(cache_id);
1803   if (found != pending_cache_loads_.end())
1804     return found->second;
1805   return NULL;
1806 }
1807
1808 AppCacheStorageImpl::GroupLoadTask*
1809 AppCacheStorageImpl::GetPendingGroupLoadTask(const GURL& manifest_url) {
1810   PendingGroupLoads::iterator found = pending_group_loads_.find(manifest_url);
1811   if (found != pending_group_loads_.end())
1812     return found->second;
1813   return NULL;
1814 }
1815
1816 void AppCacheStorageImpl::GetPendingForeignMarkingsForCache(
1817     int64 cache_id, std::vector<GURL>* urls) {
1818   PendingForeignMarkings::iterator iter = pending_foreign_markings_.begin();
1819   while (iter != pending_foreign_markings_.end()) {
1820     if (iter->second == cache_id)
1821       urls->push_back(iter->first);
1822     ++iter;
1823   }
1824 }
1825
1826 void AppCacheStorageImpl::ScheduleSimpleTask(const base::Closure& task) {
1827   pending_simple_tasks_.push_back(task);
1828   base::ThreadTaskRunnerHandle::Get()->PostTask(
1829       FROM_HERE, base::Bind(&AppCacheStorageImpl::RunOnePendingSimpleTask,
1830                             weak_factory_.GetWeakPtr()));
1831 }
1832
1833 void AppCacheStorageImpl::RunOnePendingSimpleTask() {
1834   DCHECK(!pending_simple_tasks_.empty());
1835   base::Closure task = pending_simple_tasks_.front();
1836   pending_simple_tasks_.pop_front();
1837   task.Run();
1838 }
1839
1840 AppCacheDiskCache* AppCacheStorageImpl::disk_cache() {
1841   DCHECK(IsInitTaskComplete());
1842
1843   if (is_disabled_)
1844     return NULL;
1845
1846   if (!disk_cache_) {
1847     int rv = net::OK;
1848     disk_cache_.reset(new AppCacheDiskCache);
1849     if (is_incognito_) {
1850       rv = disk_cache_->InitWithMemBackend(
1851           kMaxMemDiskCacheSize,
1852           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
1853                      base::Unretained(this)));
1854     } else {
1855       rv = disk_cache_->InitWithDiskBackend(
1856           cache_directory_.Append(kDiskCacheDirectoryName),
1857           kMaxDiskCacheSize,
1858           false,
1859           cache_thread_.get(),
1860           base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
1861                      base::Unretained(this)));
1862     }
1863
1864     if (rv != net::ERR_IO_PENDING)
1865       OnDiskCacheInitialized(rv);
1866   }
1867   return disk_cache_.get();
1868 }
1869
1870 void AppCacheStorageImpl::OnDiskCacheInitialized(int rv) {
1871   if (rv != net::OK) {
1872     LOG(ERROR) << "Failed to open the appcache diskcache.";
1873     AppCacheHistograms::CountInitResult(AppCacheHistograms::DISK_CACHE_ERROR);
1874
1875     // We're unable to open the disk cache, this is a fatal error that we can't
1876     // really recover from. We handle it by temporarily disabling the appcache
1877     // deleting the directory on disk and reinitializing the appcache system.
1878     Disable();
1879     if (rv != net::ERR_ABORTED)
1880       DeleteAndStartOver();
1881   }
1882 }
1883
1884 void AppCacheStorageImpl::DeleteAndStartOver() {
1885   DCHECK(is_disabled_);
1886   if (!is_incognito_) {
1887     VLOG(1) << "Deleting existing appcache data and starting over.";
1888     // We can have tasks in flight to close file handles on both the db
1889     // and cache threads, we need to allow those tasks to cycle thru
1890     // prior to deleting the files and calling reinit.
1891     cache_thread_->PostTaskAndReply(
1892         FROM_HERE,
1893         base::Bind(&base::DoNothing),
1894         base::Bind(&AppCacheStorageImpl::DeleteAndStartOverPart2,
1895                    weak_factory_.GetWeakPtr()));
1896   }
1897 }
1898
1899 void AppCacheStorageImpl::DeleteAndStartOverPart2() {
1900   db_thread_->PostTaskAndReply(
1901       FROM_HERE,
1902       base::Bind(base::IgnoreResult(&base::DeleteFile), cache_directory_, true),
1903       base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
1904                  weak_factory_.GetWeakPtr()));
1905 }
1906
1907 void AppCacheStorageImpl::CallScheduleReinitialize() {
1908   service_->ScheduleReinitialize();
1909   // note: 'this' may be deleted at this point.
1910 }
1911
1912 void AppCacheStorageImpl::LazilyCommitLastAccessTimes() {
1913   if (lazy_commit_timer_.IsRunning())
1914     return;
1915   const base::TimeDelta kDelay = base::TimeDelta::FromMinutes(5);
1916   lazy_commit_timer_.Start(
1917       FROM_HERE, kDelay,
1918       base::Bind(&AppCacheStorageImpl::OnLazyCommitTimer,
1919                  weak_factory_.GetWeakPtr()));
1920 }
1921
1922 void AppCacheStorageImpl::OnLazyCommitTimer() {
1923   lazy_commit_timer_.Stop();
1924   if (is_disabled())
1925     return;
1926   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
1927   task->Schedule();
1928 }
1929
1930 }  // namespace content