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