1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "content/browser/storage_partition_impl.h" 6 7 #include "base/sequenced_task_runner.h" 8 #include "base/strings/utf_string_conversions.h" 9 #include "content/browser/browser_main_loop.h" 10 #include "content/browser/fileapi/browser_file_system_helper.h" 11 #include "content/browser/gpu/shader_disk_cache.h" 12 #include "content/common/dom_storage/dom_storage_types.h" 13 #include "content/public/browser/browser_context.h" 14 #include "content/public/browser/browser_thread.h" 15 #include "content/public/browser/dom_storage_context.h" 16 #include "content/public/browser/indexed_db_context.h" 17 #include "content/public/browser/local_storage_usage_info.h" 18 #include "content/public/browser/session_storage_usage_info.h" 19 #include "net/base/completion_callback.h" 20 #include "net/base/net_errors.h" 21 #include "net/cookies/cookie_monster.h" 22 #include "net/url_request/url_request_context.h" 23 #include "net/url_request/url_request_context_getter.h" 24 #include "storage/browser/database/database_tracker.h" 25 #include "storage/browser/quota/quota_manager.h" 26 27 namespace content { 28 29 namespace { 30 31 void OnClearedCookies(const base::Closure& callback, int num_deleted) { 32 // The final callback needs to happen from UI thread. 33 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { 34 BrowserThread::PostTask( 35 BrowserThread::UI, FROM_HERE, 36 base::Bind(&OnClearedCookies, callback, num_deleted)); 37 return; 38 } 39 40 callback.Run(); 41 } 42 43 void ClearCookiesOnIOThread( 44 const scoped_refptr<net::URLRequestContextGetter>& rq_context, 45 const base::Time begin, 46 const base::Time end, 47 const GURL& storage_origin, 48 const base::Closure& callback) { 49 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 50 net::CookieStore* cookie_store = rq_context-> 51 GetURLRequestContext()->cookie_store(); 52 if (storage_origin.is_empty()) { 53 cookie_store->DeleteAllCreatedBetweenAsync( 54 begin, 55 end, 56 base::Bind(&OnClearedCookies, callback)); 57 } else { 58 cookie_store->DeleteAllCreatedBetweenForHostAsync( 59 begin, 60 end, 61 storage_origin, base::Bind(&OnClearedCookies, callback)); 62 } 63 } 64 65 void CheckQuotaManagedDataDeletionStatus(size_t* deletion_task_count, 66 const base::Closure& callback) { 67 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 68 if (*deletion_task_count == 0) { 69 delete deletion_task_count; 70 callback.Run(); 71 } 72 } 73 74 void OnQuotaManagedOriginDeleted(const GURL& origin, 75 storage::StorageType type, 76 size_t* deletion_task_count, 77 const base::Closure& callback, 78 storage::QuotaStatusCode status) { 79 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 80 DCHECK_GT(*deletion_task_count, 0u); 81 if (status != storage::kQuotaStatusOk) { 82 DLOG(ERROR) << "Couldn't remove data of type " << type << " for origin " 83 << origin << ". Status: " << status; 84 } 85 86 (*deletion_task_count)--; 87 CheckQuotaManagedDataDeletionStatus(deletion_task_count, callback); 88 } 89 90 void ClearedShaderCache(const base::Closure& callback) { 91 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { 92 BrowserThread::PostTask( 93 BrowserThread::UI, FROM_HERE, 94 base::Bind(&ClearedShaderCache, callback)); 95 return; 96 } 97 callback.Run(); 98 } 99 100 void ClearShaderCacheOnIOThread(const base::FilePath& path, 101 const base::Time begin, 102 const base::Time end, 103 const base::Closure& callback) { 104 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 105 ShaderCacheFactory::GetInstance()->ClearByPath( 106 path, begin, end, base::Bind(&ClearedShaderCache, callback)); 107 } 108 109 void OnLocalStorageUsageInfo( 110 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context, 111 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 112 const StoragePartition::OriginMatcherFunction& origin_matcher, 113 const base::Time delete_begin, 114 const base::Time delete_end, 115 const base::Closure& callback, 116 const std::vector<LocalStorageUsageInfo>& infos) { 117 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 118 119 for (size_t i = 0; i < infos.size(); ++i) { 120 if (!origin_matcher.is_null() && 121 !origin_matcher.Run(infos[i].origin, special_storage_policy.get())) { 122 continue; 123 } 124 125 if (infos[i].last_modified >= delete_begin && 126 infos[i].last_modified <= delete_end) { 127 dom_storage_context->DeleteLocalStorage(infos[i].origin); 128 } 129 } 130 callback.Run(); 131 } 132 133 void OnSessionStorageUsageInfo( 134 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context, 135 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 136 const StoragePartition::OriginMatcherFunction& origin_matcher, 137 const base::Closure& callback, 138 const std::vector<SessionStorageUsageInfo>& infos) { 139 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 140 141 for (size_t i = 0; i < infos.size(); ++i) { 142 if (!origin_matcher.is_null() && 143 !origin_matcher.Run(infos[i].origin, special_storage_policy.get())) { 144 continue; 145 } 146 dom_storage_context->DeleteSessionStorage(infos[i]); 147 } 148 149 callback.Run(); 150 } 151 152 void ClearLocalStorageOnUIThread( 153 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context, 154 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 155 const StoragePartition::OriginMatcherFunction& origin_matcher, 156 const GURL& storage_origin, 157 const base::Time begin, 158 const base::Time end, 159 const base::Closure& callback) { 160 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 161 162 if (!storage_origin.is_empty()) { 163 bool can_delete = origin_matcher.is_null() || 164 origin_matcher.Run(storage_origin, 165 special_storage_policy.get()); 166 if (can_delete) 167 dom_storage_context->DeleteLocalStorage(storage_origin); 168 169 callback.Run(); 170 return; 171 } 172 173 dom_storage_context->GetLocalStorageUsage( 174 base::Bind(&OnLocalStorageUsageInfo, 175 dom_storage_context, special_storage_policy, origin_matcher, 176 begin, end, callback)); 177 } 178 179 void ClearSessionStorageOnUIThread( 180 const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context, 181 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 182 const StoragePartition::OriginMatcherFunction& origin_matcher, 183 const base::Closure& callback) { 184 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 185 186 dom_storage_context->GetSessionStorageUsage( 187 base::Bind(&OnSessionStorageUsageInfo, dom_storage_context, 188 special_storage_policy, origin_matcher, 189 callback)); 190 } 191 192 } // namespace 193 194 // static 195 STATIC_CONST_MEMBER_DEFINITION const uint32 196 StoragePartition::REMOVE_DATA_MASK_APPCACHE; 197 STATIC_CONST_MEMBER_DEFINITION const uint32 198 StoragePartition::REMOVE_DATA_MASK_COOKIES; 199 STATIC_CONST_MEMBER_DEFINITION const uint32 200 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS; 201 STATIC_CONST_MEMBER_DEFINITION const uint32 202 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB; 203 STATIC_CONST_MEMBER_DEFINITION const uint32 204 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE; 205 STATIC_CONST_MEMBER_DEFINITION const uint32 206 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS; 207 STATIC_CONST_MEMBER_DEFINITION const uint32 208 StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE; 209 STATIC_CONST_MEMBER_DEFINITION const uint32 210 StoragePartition::REMOVE_DATA_MASK_WEBSQL; 211 STATIC_CONST_MEMBER_DEFINITION const uint32 212 StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY; 213 STATIC_CONST_MEMBER_DEFINITION const uint32 214 StoragePartition::REMOVE_DATA_MASK_ALL; 215 STATIC_CONST_MEMBER_DEFINITION const uint32 216 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_TEMPORARY; 217 STATIC_CONST_MEMBER_DEFINITION const uint32 218 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT; 219 STATIC_CONST_MEMBER_DEFINITION const uint32 220 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_SYNCABLE; 221 STATIC_CONST_MEMBER_DEFINITION const uint32 222 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL; 223 224 // Static. 225 int StoragePartitionImpl::GenerateQuotaClientMask(uint32 remove_mask) { 226 int quota_client_mask = 0; 227 228 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS) 229 quota_client_mask |= storage::QuotaClient::kFileSystem; 230 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_WEBSQL) 231 quota_client_mask |= storage::QuotaClient::kDatabase; 232 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_APPCACHE) 233 quota_client_mask |= storage::QuotaClient::kAppcache; 234 if (remove_mask & StoragePartition::REMOVE_DATA_MASK_INDEXEDDB) 235 quota_client_mask |= storage::QuotaClient::kIndexedDatabase; 236 // TODO(jsbell): StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS) 237 238 return quota_client_mask; 239 } 240 241 // Helper for deleting quota managed data from a partition. 242 // 243 // Most of the operations in this class are done on IO thread. 244 struct StoragePartitionImpl::QuotaManagedDataDeletionHelper { 245 QuotaManagedDataDeletionHelper(uint32 remove_mask, 246 uint32 quota_storage_remove_mask, 247 const GURL& storage_origin, 248 const base::Closure& callback) 249 : remove_mask(remove_mask), 250 quota_storage_remove_mask(quota_storage_remove_mask), 251 storage_origin(storage_origin), 252 callback(callback), 253 task_count(0) { 254 } 255 256 void IncrementTaskCountOnIO(); 257 void DecrementTaskCountOnIO(); 258 259 void ClearDataOnIOThread( 260 const scoped_refptr<storage::QuotaManager>& quota_manager, 261 const base::Time begin, 262 const scoped_refptr<storage::SpecialStoragePolicy>& 263 special_storage_policy, 264 const StoragePartition::OriginMatcherFunction& origin_matcher); 265 266 void ClearOriginsOnIOThread( 267 storage::QuotaManager* quota_manager, 268 const scoped_refptr<storage::SpecialStoragePolicy>& 269 special_storage_policy, 270 const StoragePartition::OriginMatcherFunction& origin_matcher, 271 const base::Closure& callback, 272 const std::set<GURL>& origins, 273 storage::StorageType quota_storage_type); 274 275 // All of these data are accessed on IO thread. 276 uint32 remove_mask; 277 uint32 quota_storage_remove_mask; 278 GURL storage_origin; 279 const base::Closure callback; 280 int task_count; 281 }; 282 283 // Helper for deleting all sorts of data from a partition, keeps track of 284 // deletion status. 285 // 286 // StoragePartitionImpl creates an instance of this class to keep track of 287 // data deletion progress. Deletion requires deleting multiple bits of data 288 // (e.g. cookies, local storage, session storage etc.) and hopping between UI 289 // and IO thread. An instance of this class is created in the beginning of 290 // deletion process (StoragePartitionImpl::ClearDataImpl) and the instance is 291 // forwarded and updated on each (sub) deletion's callback. The instance is 292 // finally destroyed when deletion completes (and |callback| is invoked). 293 struct StoragePartitionImpl::DataDeletionHelper { 294 DataDeletionHelper(uint32 remove_mask, 295 uint32 quota_storage_remove_mask, 296 const base::Closure& callback) 297 : remove_mask(remove_mask), 298 quota_storage_remove_mask(quota_storage_remove_mask), 299 callback(callback), 300 task_count(0) { 301 } 302 303 void IncrementTaskCountOnUI(); 304 void DecrementTaskCountOnUI(); 305 306 void ClearDataOnUIThread( 307 const GURL& storage_origin, 308 const OriginMatcherFunction& origin_matcher, 309 const base::FilePath& path, 310 net::URLRequestContextGetter* rq_context, 311 DOMStorageContextWrapper* dom_storage_context, 312 storage::QuotaManager* quota_manager, 313 storage::SpecialStoragePolicy* special_storage_policy, 314 WebRTCIdentityStore* webrtc_identity_store, 315 const base::Time begin, 316 const base::Time end); 317 318 void ClearQuotaManagedDataOnIOThread( 319 const scoped_refptr<storage::QuotaManager>& quota_manager, 320 const base::Time begin, 321 const GURL& storage_origin, 322 const scoped_refptr<storage::SpecialStoragePolicy>& 323 special_storage_policy, 324 const StoragePartition::OriginMatcherFunction& origin_matcher, 325 const base::Closure& callback); 326 327 uint32 remove_mask; 328 uint32 quota_storage_remove_mask; 329 330 // Accessed on UI thread. 331 const base::Closure callback; 332 // Accessed on UI thread. 333 int task_count; 334 }; 335 336 void StoragePartitionImpl::DataDeletionHelper::ClearQuotaManagedDataOnIOThread( 337 const scoped_refptr<storage::QuotaManager>& quota_manager, 338 const base::Time begin, 339 const GURL& storage_origin, 340 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 341 const StoragePartition::OriginMatcherFunction& origin_matcher, 342 const base::Closure& callback) { 343 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 344 345 StoragePartitionImpl::QuotaManagedDataDeletionHelper* helper = 346 new StoragePartitionImpl::QuotaManagedDataDeletionHelper( 347 remove_mask, 348 quota_storage_remove_mask, 349 storage_origin, 350 callback); 351 helper->ClearDataOnIOThread(quota_manager, begin, special_storage_policy, 352 origin_matcher); 353 } 354 355 StoragePartitionImpl::StoragePartitionImpl( 356 const base::FilePath& partition_path, 357 storage::QuotaManager* quota_manager, 358 ChromeAppCacheService* appcache_service, 359 storage::FileSystemContext* filesystem_context, 360 storage::DatabaseTracker* database_tracker, 361 DOMStorageContextWrapper* dom_storage_context, 362 IndexedDBContextImpl* indexed_db_context, 363 ServiceWorkerContextWrapper* service_worker_context, 364 WebRTCIdentityStore* webrtc_identity_store, 365 storage::SpecialStoragePolicy* special_storage_policy) 366 : partition_path_(partition_path), 367 quota_manager_(quota_manager), 368 appcache_service_(appcache_service), 369 filesystem_context_(filesystem_context), 370 database_tracker_(database_tracker), 371 dom_storage_context_(dom_storage_context), 372 indexed_db_context_(indexed_db_context), 373 service_worker_context_(service_worker_context), 374 webrtc_identity_store_(webrtc_identity_store), 375 special_storage_policy_(special_storage_policy) { 376 } 377 378 StoragePartitionImpl::~StoragePartitionImpl() { 379 // These message loop checks are just to avoid leaks in unittests. 380 if (GetDatabaseTracker() && 381 BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) { 382 BrowserThread::PostTask( 383 BrowserThread::FILE, 384 FROM_HERE, 385 base::Bind(&storage::DatabaseTracker::Shutdown, GetDatabaseTracker())); 386 } 387 388 if (GetFileSystemContext()) 389 GetFileSystemContext()->Shutdown(); 390 391 if (GetDOMStorageContext()) 392 GetDOMStorageContext()->Shutdown(); 393 394 if (GetServiceWorkerContext()) 395 GetServiceWorkerContext()->Shutdown(); 396 } 397 398 // TODO(ajwong): Break the direct dependency on |context|. We only 399 // need 3 pieces of info from it. 400 StoragePartitionImpl* StoragePartitionImpl::Create( 401 BrowserContext* context, 402 bool in_memory, 403 const base::FilePath& partition_path) { 404 // Ensure that these methods are called on the UI thread, except for 405 // unittests where a UI thread might not have been created. 406 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) || 407 !BrowserThread::IsMessageLoopValid(BrowserThread::UI)); 408 409 // All of the clients have to be created and registered with the 410 // QuotaManager prior to the QuotaManger being used. We do them 411 // all together here prior to handing out a reference to anything 412 // that utilizes the QuotaManager. 413 scoped_refptr<storage::QuotaManager> quota_manager = 414 new storage::QuotaManager( 415 in_memory, 416 partition_path, 417 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(), 418 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB).get(), 419 context->GetSpecialStoragePolicy()); 420 421 // Each consumer is responsible for registering its QuotaClient during 422 // its construction. 423 scoped_refptr<storage::FileSystemContext> filesystem_context = 424 CreateFileSystemContext( 425 context, partition_path, in_memory, quota_manager->proxy()); 426 427 scoped_refptr<storage::DatabaseTracker> database_tracker = 428 new storage::DatabaseTracker(partition_path, 429 in_memory, 430 context->GetSpecialStoragePolicy(), 431 quota_manager->proxy(), 432 BrowserThread::GetMessageLoopProxyForThread( 433 BrowserThread::FILE).get()); 434 435 base::FilePath path = in_memory ? base::FilePath() : partition_path; 436 scoped_refptr<DOMStorageContextWrapper> dom_storage_context = 437 new DOMStorageContextWrapper(path, context->GetSpecialStoragePolicy()); 438 439 // BrowserMainLoop may not be initialized in unit tests. Tests will 440 // need to inject their own task runner into the IndexedDBContext. 441 base::SequencedTaskRunner* idb_task_runner = 442 BrowserThread::CurrentlyOn(BrowserThread::UI) && 443 BrowserMainLoop::GetInstance() 444 ? BrowserMainLoop::GetInstance()->indexed_db_thread() 445 ->message_loop_proxy().get() 446 : NULL; 447 scoped_refptr<IndexedDBContextImpl> indexed_db_context = 448 new IndexedDBContextImpl(path, 449 context->GetSpecialStoragePolicy(), 450 quota_manager->proxy(), 451 idb_task_runner); 452 453 scoped_refptr<ServiceWorkerContextWrapper> service_worker_context = 454 new ServiceWorkerContextWrapper(context); 455 service_worker_context->Init(path, quota_manager->proxy()); 456 457 scoped_refptr<ChromeAppCacheService> appcache_service = 458 new ChromeAppCacheService(quota_manager->proxy()); 459 460 scoped_refptr<WebRTCIdentityStore> webrtc_identity_store( 461 new WebRTCIdentityStore(path, context->GetSpecialStoragePolicy())); 462 463 scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy( 464 context->GetSpecialStoragePolicy()); 465 466 return new StoragePartitionImpl(partition_path, 467 quota_manager.get(), 468 appcache_service.get(), 469 filesystem_context.get(), 470 database_tracker.get(), 471 dom_storage_context.get(), 472 indexed_db_context.get(), 473 service_worker_context.get(), 474 webrtc_identity_store.get(), 475 special_storage_policy.get()); 476 } 477 478 base::FilePath StoragePartitionImpl::GetPath() { 479 return partition_path_; 480 } 481 482 net::URLRequestContextGetter* StoragePartitionImpl::GetURLRequestContext() { 483 return url_request_context_.get(); 484 } 485 486 net::URLRequestContextGetter* 487 StoragePartitionImpl::GetMediaURLRequestContext() { 488 return media_url_request_context_.get(); 489 } 490 491 storage::QuotaManager* StoragePartitionImpl::GetQuotaManager() { 492 return quota_manager_.get(); 493 } 494 495 ChromeAppCacheService* StoragePartitionImpl::GetAppCacheService() { 496 return appcache_service_.get(); 497 } 498 499 storage::FileSystemContext* StoragePartitionImpl::GetFileSystemContext() { 500 return filesystem_context_.get(); 501 } 502 503 storage::DatabaseTracker* StoragePartitionImpl::GetDatabaseTracker() { 504 return database_tracker_.get(); 505 } 506 507 DOMStorageContextWrapper* StoragePartitionImpl::GetDOMStorageContext() { 508 return dom_storage_context_.get(); 509 } 510 511 IndexedDBContextImpl* StoragePartitionImpl::GetIndexedDBContext() { 512 return indexed_db_context_.get(); 513 } 514 515 ServiceWorkerContextWrapper* StoragePartitionImpl::GetServiceWorkerContext() { 516 return service_worker_context_.get(); 517 } 518 519 void StoragePartitionImpl::ClearDataImpl( 520 uint32 remove_mask, 521 uint32 quota_storage_remove_mask, 522 const GURL& storage_origin, 523 const OriginMatcherFunction& origin_matcher, 524 net::URLRequestContextGetter* rq_context, 525 const base::Time begin, 526 const base::Time end, 527 const base::Closure& callback) { 528 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 529 DataDeletionHelper* helper = new DataDeletionHelper(remove_mask, 530 quota_storage_remove_mask, 531 callback); 532 // |helper| deletes itself when done in 533 // DataDeletionHelper::DecrementTaskCountOnUI(). 534 helper->ClearDataOnUIThread(storage_origin, 535 origin_matcher, 536 GetPath(), 537 rq_context, 538 dom_storage_context_.get(), 539 quota_manager_.get(), 540 special_storage_policy_.get(), 541 webrtc_identity_store_.get(), 542 begin, 543 end); 544 } 545 546 void StoragePartitionImpl:: 547 QuotaManagedDataDeletionHelper::IncrementTaskCountOnIO() { 548 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 549 ++task_count; 550 } 551 552 void StoragePartitionImpl:: 553 QuotaManagedDataDeletionHelper::DecrementTaskCountOnIO() { 554 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 555 DCHECK_GT(task_count, 0); 556 --task_count; 557 if (task_count) 558 return; 559 560 callback.Run(); 561 delete this; 562 } 563 564 void StoragePartitionImpl::QuotaManagedDataDeletionHelper::ClearDataOnIOThread( 565 const scoped_refptr<storage::QuotaManager>& quota_manager, 566 const base::Time begin, 567 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 568 const StoragePartition::OriginMatcherFunction& origin_matcher) { 569 IncrementTaskCountOnIO(); 570 base::Closure decrement_callback = base::Bind( 571 &QuotaManagedDataDeletionHelper::DecrementTaskCountOnIO, 572 base::Unretained(this)); 573 574 if (quota_storage_remove_mask & QUOTA_MANAGED_STORAGE_MASK_PERSISTENT) { 575 IncrementTaskCountOnIO(); 576 // Ask the QuotaManager for all origins with persistent quota modified 577 // within the user-specified timeframe, and deal with the resulting set in 578 // ClearQuotaManagedOriginsOnIOThread(). 579 quota_manager->GetOriginsModifiedSince( 580 storage::kStorageTypePersistent, 581 begin, 582 base::Bind(&QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread, 583 base::Unretained(this), 584 quota_manager, 585 special_storage_policy, 586 origin_matcher, 587 decrement_callback)); 588 } 589 590 // Do the same for temporary quota. 591 if (quota_storage_remove_mask & QUOTA_MANAGED_STORAGE_MASK_TEMPORARY) { 592 IncrementTaskCountOnIO(); 593 quota_manager->GetOriginsModifiedSince( 594 storage::kStorageTypeTemporary, 595 begin, 596 base::Bind(&QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread, 597 base::Unretained(this), 598 quota_manager, 599 special_storage_policy, 600 origin_matcher, 601 decrement_callback)); 602 } 603 604 // Do the same for syncable quota. 605 if (quota_storage_remove_mask & QUOTA_MANAGED_STORAGE_MASK_SYNCABLE) { 606 IncrementTaskCountOnIO(); 607 quota_manager->GetOriginsModifiedSince( 608 storage::kStorageTypeSyncable, 609 begin, 610 base::Bind(&QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread, 611 base::Unretained(this), 612 quota_manager, 613 special_storage_policy, 614 origin_matcher, 615 decrement_callback)); 616 } 617 618 DecrementTaskCountOnIO(); 619 } 620 621 void 622 StoragePartitionImpl::QuotaManagedDataDeletionHelper::ClearOriginsOnIOThread( 623 storage::QuotaManager* quota_manager, 624 const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy, 625 const StoragePartition::OriginMatcherFunction& origin_matcher, 626 const base::Closure& callback, 627 const std::set<GURL>& origins, 628 storage::StorageType quota_storage_type) { 629 // The QuotaManager manages all storage other than cookies, LocalStorage, 630 // and SessionStorage. This loop wipes out most HTML5 storage for the given 631 // origins. 632 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 633 if (!origins.size()) { 634 callback.Run(); 635 return; 636 } 637 638 size_t* deletion_task_count = new size_t(0u); 639 (*deletion_task_count)++; 640 for (std::set<GURL>::const_iterator origin = origins.begin(); 641 origin != origins.end(); ++origin) { 642 // TODO(mkwst): Clean this up, it's slow. http://crbug.com/130746 643 if (!storage_origin.is_empty() && origin->GetOrigin() != storage_origin) 644 continue; 645 646 if (!origin_matcher.is_null() && 647 !origin_matcher.Run(*origin, special_storage_policy.get())) { 648 continue; 649 } 650 651 (*deletion_task_count)++; 652 quota_manager->DeleteOriginData( 653 *origin, quota_storage_type, 654 StoragePartitionImpl::GenerateQuotaClientMask(remove_mask), 655 base::Bind(&OnQuotaManagedOriginDeleted, 656 origin->GetOrigin(), quota_storage_type, 657 deletion_task_count, callback)); 658 } 659 (*deletion_task_count)--; 660 661 CheckQuotaManagedDataDeletionStatus(deletion_task_count, callback); 662 } 663 664 void StoragePartitionImpl::DataDeletionHelper::IncrementTaskCountOnUI() { 665 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 666 ++task_count; 667 } 668 669 void StoragePartitionImpl::DataDeletionHelper::DecrementTaskCountOnUI() { 670 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { 671 BrowserThread::PostTask( 672 BrowserThread::UI, FROM_HERE, 673 base::Bind(&DataDeletionHelper::DecrementTaskCountOnUI, 674 base::Unretained(this))); 675 return; 676 } 677 DCHECK_GT(task_count, 0); 678 --task_count; 679 if (!task_count) { 680 callback.Run(); 681 delete this; 682 } 683 } 684 685 void StoragePartitionImpl::DataDeletionHelper::ClearDataOnUIThread( 686 const GURL& storage_origin, 687 const OriginMatcherFunction& origin_matcher, 688 const base::FilePath& path, 689 net::URLRequestContextGetter* rq_context, 690 DOMStorageContextWrapper* dom_storage_context, 691 storage::QuotaManager* quota_manager, 692 storage::SpecialStoragePolicy* special_storage_policy, 693 WebRTCIdentityStore* webrtc_identity_store, 694 const base::Time begin, 695 const base::Time end) { 696 DCHECK_NE(remove_mask, 0u); 697 DCHECK(!callback.is_null()); 698 699 IncrementTaskCountOnUI(); 700 base::Closure decrement_callback = base::Bind( 701 &DataDeletionHelper::DecrementTaskCountOnUI, base::Unretained(this)); 702 703 if (remove_mask & REMOVE_DATA_MASK_COOKIES) { 704 // Handle the cookies. 705 IncrementTaskCountOnUI(); 706 BrowserThread::PostTask( 707 BrowserThread::IO, FROM_HERE, 708 base::Bind(&ClearCookiesOnIOThread, 709 make_scoped_refptr(rq_context), begin, end, storage_origin, 710 decrement_callback)); 711 } 712 713 if (remove_mask & REMOVE_DATA_MASK_INDEXEDDB || 714 remove_mask & REMOVE_DATA_MASK_WEBSQL || 715 remove_mask & REMOVE_DATA_MASK_APPCACHE || 716 remove_mask & REMOVE_DATA_MASK_FILE_SYSTEMS || 717 remove_mask & REMOVE_DATA_MASK_SERVICE_WORKERS) { 718 IncrementTaskCountOnUI(); 719 BrowserThread::PostTask( 720 BrowserThread::IO, FROM_HERE, 721 base::Bind(&DataDeletionHelper::ClearQuotaManagedDataOnIOThread, 722 base::Unretained(this), 723 make_scoped_refptr(quota_manager), 724 begin, 725 storage_origin, 726 make_scoped_refptr(special_storage_policy), 727 origin_matcher, 728 decrement_callback)); 729 } 730 731 if (remove_mask & REMOVE_DATA_MASK_LOCAL_STORAGE) { 732 IncrementTaskCountOnUI(); 733 ClearLocalStorageOnUIThread( 734 make_scoped_refptr(dom_storage_context), 735 make_scoped_refptr(special_storage_policy), 736 origin_matcher, 737 storage_origin, begin, end, 738 decrement_callback); 739 740 // ClearDataImpl cannot clear session storage data when a particular origin 741 // is specified. Therefore we ignore clearing session storage in this case. 742 // TODO(lazyboy): Fix. 743 if (storage_origin.is_empty()) { 744 IncrementTaskCountOnUI(); 745 ClearSessionStorageOnUIThread( 746 make_scoped_refptr(dom_storage_context), 747 make_scoped_refptr(special_storage_policy), 748 origin_matcher, 749 decrement_callback); 750 } 751 } 752 753 if (remove_mask & REMOVE_DATA_MASK_SHADER_CACHE) { 754 IncrementTaskCountOnUI(); 755 BrowserThread::PostTask( 756 BrowserThread::IO, FROM_HERE, 757 base::Bind(&ClearShaderCacheOnIOThread, 758 path, begin, end, decrement_callback)); 759 } 760 761 if (remove_mask & REMOVE_DATA_MASK_WEBRTC_IDENTITY) { 762 IncrementTaskCountOnUI(); 763 BrowserThread::PostTask( 764 BrowserThread::IO, 765 FROM_HERE, 766 base::Bind(&WebRTCIdentityStore::DeleteBetween, 767 webrtc_identity_store, 768 begin, 769 end, 770 decrement_callback)); 771 } 772 773 DecrementTaskCountOnUI(); 774 } 775 776 void StoragePartitionImpl::ClearDataForOrigin( 777 uint32 remove_mask, 778 uint32 quota_storage_remove_mask, 779 const GURL& storage_origin, 780 net::URLRequestContextGetter* request_context_getter, 781 const base::Closure& callback) { 782 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 783 ClearDataImpl(remove_mask, 784 quota_storage_remove_mask, 785 storage_origin, 786 OriginMatcherFunction(), 787 request_context_getter, 788 base::Time(), 789 base::Time::Max(), 790 callback); 791 } 792 793 void StoragePartitionImpl::ClearData( 794 uint32 remove_mask, 795 uint32 quota_storage_remove_mask, 796 const GURL& storage_origin, 797 const OriginMatcherFunction& origin_matcher, 798 const base::Time begin, 799 const base::Time end, 800 const base::Closure& callback) { 801 ClearDataImpl(remove_mask, quota_storage_remove_mask, storage_origin, 802 origin_matcher, GetURLRequestContext(), begin, end, callback); 803 } 804 805 WebRTCIdentityStore* StoragePartitionImpl::GetWebRTCIdentityStore() { 806 return webrtc_identity_store_.get(); 807 } 808 809 void StoragePartitionImpl::OverrideQuotaManagerForTesting( 810 storage::QuotaManager* quota_manager) { 811 quota_manager_ = quota_manager; 812 } 813 814 void StoragePartitionImpl::OverrideSpecialStoragePolicyForTesting( 815 storage::SpecialStoragePolicy* special_storage_policy) { 816 special_storage_policy_ = special_storage_policy; 817 } 818 819 void StoragePartitionImpl::SetURLRequestContext( 820 net::URLRequestContextGetter* url_request_context) { 821 url_request_context_ = url_request_context; 822 } 823 824 void StoragePartitionImpl::SetMediaURLRequestContext( 825 net::URLRequestContextGetter* media_url_request_context) { 826 media_url_request_context_ = media_url_request_context; 827 } 828 829 } // namespace content 830
