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