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