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