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
27namespace content {
28
29namespace {
30
31void 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
43void 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
65void 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
74void 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
90void 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
100void 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
109void 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
133void 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
152void 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
179void 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
195STATIC_CONST_MEMBER_DEFINITION const uint32
196    StoragePartition::REMOVE_DATA_MASK_APPCACHE;
197STATIC_CONST_MEMBER_DEFINITION const uint32
198    StoragePartition::REMOVE_DATA_MASK_COOKIES;
199STATIC_CONST_MEMBER_DEFINITION const uint32
200    StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
201STATIC_CONST_MEMBER_DEFINITION const uint32
202    StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
203STATIC_CONST_MEMBER_DEFINITION const uint32
204    StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
205STATIC_CONST_MEMBER_DEFINITION const uint32
206    StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
207STATIC_CONST_MEMBER_DEFINITION const uint32
208    StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
209STATIC_CONST_MEMBER_DEFINITION const uint32
210    StoragePartition::REMOVE_DATA_MASK_WEBSQL;
211STATIC_CONST_MEMBER_DEFINITION const uint32
212    StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY;
213STATIC_CONST_MEMBER_DEFINITION const uint32
214    StoragePartition::REMOVE_DATA_MASK_ALL;
215STATIC_CONST_MEMBER_DEFINITION const uint32
216    StoragePartition::QUOTA_MANAGED_STORAGE_MASK_TEMPORARY;
217STATIC_CONST_MEMBER_DEFINITION const uint32
218    StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
219STATIC_CONST_MEMBER_DEFINITION const uint32
220    StoragePartition::QUOTA_MANAGED_STORAGE_MASK_SYNCABLE;
221STATIC_CONST_MEMBER_DEFINITION const uint32
222    StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL;
223
224// Static.
225int 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.
244struct 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).
293struct 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
336void 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
355StoragePartitionImpl::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
378StoragePartitionImpl::~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.
400StoragePartitionImpl* 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
478base::FilePath StoragePartitionImpl::GetPath() {
479  return partition_path_;
480}
481
482net::URLRequestContextGetter* StoragePartitionImpl::GetURLRequestContext() {
483  return url_request_context_.get();
484}
485
486net::URLRequestContextGetter*
487StoragePartitionImpl::GetMediaURLRequestContext() {
488  return media_url_request_context_.get();
489}
490
491storage::QuotaManager* StoragePartitionImpl::GetQuotaManager() {
492  return quota_manager_.get();
493}
494
495ChromeAppCacheService* StoragePartitionImpl::GetAppCacheService() {
496  return appcache_service_.get();
497}
498
499storage::FileSystemContext* StoragePartitionImpl::GetFileSystemContext() {
500  return filesystem_context_.get();
501}
502
503storage::DatabaseTracker* StoragePartitionImpl::GetDatabaseTracker() {
504  return database_tracker_.get();
505}
506
507DOMStorageContextWrapper* StoragePartitionImpl::GetDOMStorageContext() {
508  return dom_storage_context_.get();
509}
510
511IndexedDBContextImpl* StoragePartitionImpl::GetIndexedDBContext() {
512  return indexed_db_context_.get();
513}
514
515ServiceWorkerContextWrapper* StoragePartitionImpl::GetServiceWorkerContext() {
516  return service_worker_context_.get();
517}
518
519void 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
546void StoragePartitionImpl::
547    QuotaManagedDataDeletionHelper::IncrementTaskCountOnIO() {
548  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
549  ++task_count;
550}
551
552void 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
564void 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
621void
622StoragePartitionImpl::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
664void StoragePartitionImpl::DataDeletionHelper::IncrementTaskCountOnUI() {
665  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
666  ++task_count;
667}
668
669void 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
685void 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
776void 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
793void 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
805WebRTCIdentityStore* StoragePartitionImpl::GetWebRTCIdentityStore() {
806  return webrtc_identity_store_.get();
807}
808
809void StoragePartitionImpl::OverrideQuotaManagerForTesting(
810    storage::QuotaManager* quota_manager) {
811  quota_manager_ = quota_manager;
812}
813
814void StoragePartitionImpl::OverrideSpecialStoragePolicyForTesting(
815    storage::SpecialStoragePolicy* special_storage_policy) {
816  special_storage_policy_ = special_storage_policy;
817}
818
819void StoragePartitionImpl::SetURLRequestContext(
820    net::URLRequestContextGetter* url_request_context) {
821  url_request_context_ = url_request_context;
822}
823
824void StoragePartitionImpl::SetMediaURLRequestContext(
825    net::URLRequestContextGetter* media_url_request_context) {
826  media_url_request_context_ = media_url_request_context;
827}
828
829}  // namespace content
830