BrowsingDataRemover, (re)use StoragePartition deletion code.

chrome/browser/browsing_data/browsing_data_remover.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 60 matching lines @@
 #include "webkit/browser/quota/special_storage_policy.h"
 #include "webkit/common/quota/quota_types.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DOMStorageContext;
 using content::UserMetricsAction;
 
 bool BrowsingDataRemover::is_removing_ = false;
 
+// Helper to create callback for BrowsingDataRemover::DoesOriginMatchMask.
+// Static.
+bool DoesOriginMatchMask(int origin_set_mask,
+                         const GURL& origin,
+                         quota::SpecialStoragePolicy* special_storage_policy) {
+  return BrowsingDataHelper::DoesOriginMatchMask(
+      origin, origin_set_mask,
+      static_cast<ExtensionSpecialStoragePolicy*>(special_storage_policy));
+}
+
 BrowsingDataRemover::NotificationDetails::NotificationDetails()
     : removal_begin(base::Time()),
       removal_mask(-1),
       origin_set_mask(-1) {
 }
 
 BrowsingDataRemover::NotificationDetails::NotificationDetails(
     const BrowsingDataRemover::NotificationDetails& details)
     : removal_begin(details.removal_begin),
       removal_mask(details.removal_mask),
@@ skipping 50 matching lines @@
   }
   return new BrowsingDataRemover(profile,
       BrowsingDataRemover::CalculateBeginDeleteTime(period),
       base::Time::Max());
 }
 
 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
                                          base::Time delete_begin,
                                          base::Time delete_end)
     : profile_(profile),
-      quota_manager_(NULL),
-      dom_storage_context_(NULL),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetMediaRequestContext()),
       deauthorize_content_licenses_request_id_(0),
       waiting_for_clear_autofill_origin_urls_(false),
       waiting_for_clear_cache_(false),
       waiting_for_clear_content_licenses_(false),
       waiting_for_clear_cookies_count_(0),
       waiting_for_clear_form_(false),
       waiting_for_clear_history_(false),
       waiting_for_clear_hostname_resolution_cache_(false),
-      waiting_for_clear_local_storage_(false),
+      waiting_for_clear_keyword_data_(false),
       waiting_for_clear_logged_in_predictor_(false),
       waiting_for_clear_nacl_cache_(false),
       waiting_for_clear_network_predictor_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_plugin_data_(false),
       waiting_for_clear_pnacl_cache_(false),
       waiting_for_clear_quota_managed_data_(false),
       waiting_for_clear_server_bound_certs_(false),
-      waiting_for_clear_session_storage_(false),
-      waiting_for_clear_shader_cache_(false),
-      waiting_for_clear_webrtc_identity_store_(false),
-      waiting_for_clear_keyword_data_(false),
+      waiting_for_clear_storage_partition_data_(false),
       remove_mask_(0),
       remove_origin_(GURL()),
       origin_set_mask_(0) {
   DCHECK(profile);
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max(). Work around
   // it here. New code should use base::Time::Max().
   DCHECK(delete_end_ != base::Time());
   if (delete_end_ == base::Time())
     delete_end_ = base::Time::Max();
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   DCHECK(AllDone());
 }
 
 // Static.
 void BrowsingDataRemover::set_removing(bool is_removing) {
   DCHECK(is_removing_ != is_removing);
   is_removing_ = is_removing;
 }
 
-// Static.
-int BrowsingDataRemover::GenerateQuotaClientMask(int remove_mask) {
-  int quota_client_mask = 0;
-  if (remove_mask & BrowsingDataRemover::REMOVE_FILE_SYSTEMS)
-    quota_client_mask |= quota::QuotaClient::kFileSystem;
-  if (remove_mask & BrowsingDataRemover::REMOVE_WEBSQL)
-    quota_client_mask |= quota::QuotaClient::kDatabase;
-  if (remove_mask & BrowsingDataRemover::REMOVE_APPCACHE)
-    quota_client_mask |= quota::QuotaClient::kAppcache;
-  if (remove_mask & BrowsingDataRemover::REMOVE_INDEXEDDB)
-    quota_client_mask |= quota::QuotaClient::kIndexedDatabase;
-
-  return quota_client_mask;
-}
-
 void BrowsingDataRemover::Remove(int remove_mask, int origin_set_mask) {
   RemoveImpl(remove_mask, GURL(), origin_set_mask);
 }
 
 void BrowsingDataRemover::RemoveImpl(int remove_mask,
                                      const GURL& origin,
                                      int origin_set_mask) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   set_removing(true);
   remove_mask_ = remove_mask;
@@ skipping 148 matching lines @@
   if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
     content::DownloadManager* download_manager =
         BrowserContext::GetDownloadManager(profile_);
     download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
         download_manager);
     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
   }
 
+  uint32 storage_partition_remove_mask = 0;
+
   // We ignore the REMOVE_COOKIES request if UNPROTECTED_WEB is not set,
   // so that callers who request REMOVE_SITE_DATA with PROTECTED_WEB
   // don't accidentally remove the cookies that are associated with the
   // UNPROTECTED_WEB origin. This is necessary because cookies are not separated
   // between UNPROTECTED_WEB and PROTECTED_WEB.
   if (remove_mask & REMOVE_COOKIES &&
       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cookies"));
-    // Since we are running on the UI thread don't call GetURLRequestContext().
-    net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
-    if (rq_context) {
-      ++waiting_for_clear_cookies_count_;
-      BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          base::Bind(&BrowsingDataRemover::ClearCookiesOnIOThread,
-                     base::Unretained(this), base::Unretained(rq_context)));
-    }
+
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
+
     // Also delete the LoggedIn Predictor, which tries to keep track of which
     // sites a user is logged into.
     ClearLoggedInPredictor();
 
 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
     // Clear the safebrowsing cookies only if time period is for "all time".  It
     // doesn't make sense to apply the time period of deleting in the last X
     // hours/days to the safebrowsing cookies since they aren't the result of
     // any user action.
     if (delete_begin_ == base::Time()) {
       SafeBrowsingService* sb_service =
           g_browser_process->safe_browsing_service();
       if (sb_service) {
         net::URLRequestContextGetter* sb_context =
             sb_service->url_request_context();
         ++waiting_for_clear_cookies_count_;
         BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
             base::Bind(&BrowsingDataRemover::ClearCookiesOnIOThread,
                        base::Unretained(this), base::Unretained(sb_context)));

[Mike West, 2013/10/29 11:14:32]

Are these cookies not tied to a StoragePartition?

[lazyboy, 2013/10/30 00:33:23]

These are related to SafeBrowsingService, which is chrome/ concept, so
StoragePartition (which is content/ concept) cannot directly do this.
I'm not sure this should be somehow moved to content/ or not.

       }
     }
 #endif
   }
 
   // Server bound certs are not separated for protected and unprotected web
   // origins. We check the origin_set_mask_ to prevent unintended deletion.
   if (remove_mask & REMOVE_SERVER_BOUND_CERTS &&
       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_ServerBoundCerts"));
     // Since we are running on the UI thread don't call GetURLRequestContext().
     net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
     if (rq_context) {
       waiting_for_clear_server_bound_certs_ = true;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&BrowsingDataRemover::ClearServerBoundCertsOnIOThread,
                      base::Unretained(this), base::Unretained(rq_context)));
     }
   }
 
   if (remove_mask & REMOVE_LOCAL_STORAGE) {
-    waiting_for_clear_local_storage_ = true;
-    waiting_for_clear_session_storage_ = true;
-    if (!dom_storage_context_) {
-      dom_storage_context_ =
-          BrowserContext::GetDefaultStoragePartition(profile_)->
-              GetDOMStorageContext();
-    }
-    ClearLocalStorageOnUIThread();
-    ClearSessionStorageOnUIThread();
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
   }
 
-  if (remove_mask & REMOVE_INDEXEDDB || remove_mask & REMOVE_WEBSQL ||
-      remove_mask & REMOVE_APPCACHE || remove_mask & REMOVE_FILE_SYSTEMS) {
-    if (!quota_manager_) {
-      quota_manager_ =
-          BrowserContext::GetDefaultStoragePartition(profile_)->
-              GetQuotaManager();
-    }
-    waiting_for_clear_quota_managed_data_ = true;
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&BrowsingDataRemover::ClearQuotaManagedDataOnIOThread,
-                   base::Unretained(this)));
+  if (remove_mask & REMOVE_INDEXEDDB) {
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
+  }
+  if (remove_mask & REMOVE_WEBSQL) {
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
+  }
+  if (remove_mask & REMOVE_APPCACHE) {
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
+  }
+  if (remove_mask & REMOVE_FILE_SYSTEMS) {
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
   }
 
 #if defined(ENABLE_PLUGINS)
   // Plugin is data not separated for protected and unprotected web origins. We
   // check the origin_set_mask_ to prevent unintended deletion.
   if (remove_mask & REMOVE_PLUGIN_DATA &&
       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_LSOData"));
 
     waiting_for_clear_plugin_data_ = true;
@@ skipping 75 matching lines @@
     // The PrerenderManager may have a page actively being prerendered, which
     // is essentially a preemptively cached page.
     prerender::PrerenderManager* prerender_manager =
         prerender::PrerenderManagerFactory::GetForProfile(profile_);
     if (prerender_manager) {
       prerender_manager->ClearData(
           prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS);
     }
 
     // Tell the shader disk cache to clear.
-    waiting_for_clear_shader_cache_ = true;
     content::RecordAction(UserMetricsAction("ClearBrowsingData_ShaderCache"));
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
 
-    ClearShaderCacheOnUIThread();
+    storage_partition_remove_mask |=
+        content::StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY;
+  }
 
-    waiting_for_clear_webrtc_identity_store_ = true;
-    BrowserContext::GetDefaultStoragePartition(profile_)->ClearDataForRange(
-        content::StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY,
-        content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
+  if (storage_partition_remove_mask) {
+    waiting_for_clear_storage_partition_data_ = true;
+    content::StoragePartition* storage_partition =
+        BrowserContext::GetDefaultStoragePartition(profile_);
+
+    uint32 quota_storage_remove_mask =
+        ~content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
+
+    if (delete_begin_ == base::Time() ||
+        origin_set_mask_ &
+          (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
+      // If we're deleting since the beginning of time, or we're removing
+      // protected origins, then remove persistent quota data.
+      quota_storage_remove_mask |=
+          content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
+    }
+
+    storage_partition->ClearDataForOriginWithinRange(
+        storage_partition_remove_mask,
+        quota_storage_remove_mask,
+        remove_origin_,
+        base::Bind(&DoesOriginMatchMask, origin_set_mask_),
         delete_begin_,
         delete_end_,
-        base::Bind(&BrowsingDataRemover::OnClearWebRTCIdentityStore,
+        base::Bind(&BrowsingDataRemover::OnClearedStoragePartitionData,
                    base::Unretained(this)));
   }
 
 #if defined(ENABLE_PLUGINS)
   if (remove_mask & REMOVE_CONTENT_LICENSES) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 
     waiting_for_clear_content_licenses_ = true;
     if (!pepper_flash_settings_manager_.get()) {
@@ skipping 20 matching lines @@
 
 void BrowsingDataRemover::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void BrowsingDataRemover::OnHistoryDeletionDone() {
   waiting_for_clear_history_ = false;
   NotifyAndDeleteIfDone();
 }
 
-void BrowsingDataRemover::OverrideQuotaManagerForTesting(
-    quota::QuotaManager* quota_manager) {
-  quota_manager_ = quota_manager;
-}
-
 base::Time BrowsingDataRemover::CalculateBeginDeleteTime(
     TimePeriod time_period) {
   base::TimeDelta diff;
   base::Time delete_begin_time = base::Time::Now();
   switch (time_period) {
     case LAST_HOUR:
       diff = base::TimeDelta::FromHours(1);
       break;
     case LAST_DAY:
       diff = base::TimeDelta::FromHours(24);
@@ skipping 12 matching lines @@
       break;
   }
   return delete_begin_time - diff;
 }
 
 bool BrowsingDataRemover::AllDone() {
   return !waiting_for_clear_keyword_data_ &&
          !waiting_for_clear_autofill_origin_urls_ &&
          !waiting_for_clear_cache_ && !waiting_for_clear_nacl_cache_ &&
          !waiting_for_clear_cookies_count_ && !waiting_for_clear_history_ &&
-         !waiting_for_clear_local_storage_ &&
          !waiting_for_clear_logged_in_predictor_ &&
-         !waiting_for_clear_session_storage_ &&
          !waiting_for_clear_networking_history_ &&
          !waiting_for_clear_server_bound_certs_ &&
          !waiting_for_clear_plugin_data_ &&
          !waiting_for_clear_pnacl_cache_ &&
          !waiting_for_clear_quota_managed_data_ &&
          !waiting_for_clear_content_licenses_ && !waiting_for_clear_form_ &&
          !waiting_for_clear_hostname_resolution_cache_ &&
          !waiting_for_clear_network_predictor_ &&
-         !waiting_for_clear_shader_cache_ &&
-         !waiting_for_clear_webrtc_identity_store_;
+         !waiting_for_clear_storage_partition_data_;
 }
 
 void BrowsingDataRemover::OnKeywordsLoaded() {
   // Deletes the entries from the model, and if we're not waiting on anything
   // else notifies observers and deletes this BrowsingDataRemover.
   TemplateURLService* model =
       TemplateURLServiceFactory::GetForProfile(profile_);
   DCHECK_EQ(profile_, model->profile());
   model->RemoveAutoGeneratedBetween(delete_begin_, delete_end_);
   waiting_for_clear_keyword_data_ = false;
@@ skipping 185 matching lines @@
       }
       default: {
         NOTREACHED() << "bad state";
         next_cache_state_ = STATE_NONE;  // Stop looping.
         return;
       }
     }
   }
 }
 
-void BrowsingDataRemover::ClearedShaderCache() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  waiting_for_clear_shader_cache_ = false;
-  NotifyAndDeleteIfDone();
-}
-
-void BrowsingDataRemover::ClearShaderCacheOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  BrowserContext::GetDefaultStoragePartition(profile_)->ClearDataForRange(
-      content::StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE,
-      content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
-      delete_begin_, delete_end_,
-      base::Bind(&BrowsingDataRemover::ClearedShaderCache,
-                 base::Unretained(this)));
-}
-
 #if !defined(DISABLE_NACL)
 void BrowsingDataRemover::ClearedNaClCache() {
   // This function should be called on the UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   waiting_for_clear_nacl_cache_ = false;
 
   NotifyAndDeleteIfDone();
 }
 
@@ skipping 40 matching lines @@
                                                     base::Time end) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PnaclHost::GetInstance()->ClearTranslationCacheEntriesBetween(
       begin, end,
       base::Bind(&BrowsingDataRemover::ClearedPnaclCacheOnIOThread,
                  base::Unretained(this)));
 }
 #endif
 
-void BrowsingDataRemover::ClearLocalStorageOnUIThread() {
-  DCHECK(waiting_for_clear_local_storage_);
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  dom_storage_context_->GetLocalStorageUsage(
-      base::Bind(&BrowsingDataRemover::OnGotLocalStorageUsageInfo,
-                 base::Unretained(this)));
-}
-
-void BrowsingDataRemover::OnGotLocalStorageUsageInfo(
-    const std::vector<content::LocalStorageUsageInfo>& infos) {
-  DCHECK(waiting_for_clear_local_storage_);
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  for (size_t i = 0; i < infos.size(); ++i) {
-    if (!BrowsingDataHelper::DoesOriginMatchMask(
-            infos[i].origin, origin_set_mask_, special_storage_policy_.get()))
-      continue;
-
-    if (infos[i].last_modified >= delete_begin_ &&
-        infos[i].last_modified <= delete_end_) {
-      dom_storage_context_->DeleteLocalStorage(infos[i].origin);
-    }
-  }
-  waiting_for_clear_local_storage_ = false;
-  NotifyAndDeleteIfDone();
-}
-
-void BrowsingDataRemover::ClearSessionStorageOnUIThread() {
-  DCHECK(waiting_for_clear_session_storage_);
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  dom_storage_context_->GetSessionStorageUsage(
-      base::Bind(&BrowsingDataRemover::OnGotSessionStorageUsageInfo,
-                 base::Unretained(this)));
-}
-
-void BrowsingDataRemover::OnGotSessionStorageUsageInfo(
-    const std::vector<content::SessionStorageUsageInfo>& infos) {
-  DCHECK(waiting_for_clear_session_storage_);
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  for (size_t i = 0; i < infos.size(); ++i) {
-    if (!BrowsingDataHelper::DoesOriginMatchMask(
-            infos[i].origin, origin_set_mask_, special_storage_policy_.get()))
-      continue;
-
-    dom_storage_context_->DeleteSessionStorage(infos[i]);
-  }
-  waiting_for_clear_session_storage_ = false;
-  NotifyAndDeleteIfDone();
-}
-
-void BrowsingDataRemover::ClearQuotaManagedDataOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // Ask the QuotaManager for all origins with temporary quota modified within
-  // the user-specified timeframe, and deal with the resulting set in
-  // OnGotQuotaManagedOrigins().
-  quota_managed_origins_to_delete_count_ = 0;
-  quota_managed_storage_types_to_delete_count_ = 0;
-
-  if (delete_begin_ == base::Time() ||
-      origin_set_mask_ &
-          (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
-    // If we're deleting since the beginning of time, or we're removing
-    // protected origins, then ask the QuotaManager for all origins with
-    // persistent quota modified within the user-specified timeframe, and deal
-    // with the resulting set in OnGotQuotaManagedOrigins.
-    ++quota_managed_storage_types_to_delete_count_;
-    quota_manager_->GetOriginsModifiedSince(
-        quota::kStorageTypePersistent, delete_begin_,
-        base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
-                   base::Unretained(this)));
-  }
-
-  // Do the same for temporary quota.
-  ++quota_managed_storage_types_to_delete_count_;
-  quota_manager_->GetOriginsModifiedSince(
-      quota::kStorageTypeTemporary, delete_begin_,
-      base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
-                 base::Unretained(this)));
-
-  // Do the same for syncable quota.
-  ++quota_managed_storage_types_to_delete_count_;
-  quota_manager_->GetOriginsModifiedSince(
-      quota::kStorageTypeSyncable, delete_begin_,
-      base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
-                 base::Unretained(this)));
-}
-
-void BrowsingDataRemover::OnGotQuotaManagedOrigins(
-    const std::set<GURL>& origins, quota::StorageType type) {
-  DCHECK_GT(quota_managed_storage_types_to_delete_count_, 0);
-  // Walk through the origins passed in, delete quota of |type| from each that
-  // matches the |origin_set_mask_|.
-  std::set<GURL>::const_iterator origin;
-  for (origin = origins.begin(); origin != origins.end(); ++origin) {
-    // TODO(mkwst): Clean this up, it's slow. http://crbug.com/130746
-    if (!remove_origin_.is_empty() && remove_origin_ != origin->GetOrigin())
-      continue;
-
-    if (!BrowsingDataHelper::DoesOriginMatchMask(origin->GetOrigin(),
-                                                 origin_set_mask_,
-                                                 special_storage_policy_.get()))
-      continue;
-
-    ++quota_managed_origins_to_delete_count_;
-    quota_manager_->DeleteOriginData(
-        origin->GetOrigin(), type,
-        BrowsingDataRemover::GenerateQuotaClientMask(remove_mask_),
-        base::Bind(&BrowsingDataRemover::OnQuotaManagedOriginDeletion,
-                   base::Unretained(this), origin->GetOrigin(), type));
-  }
-
-  --quota_managed_storage_types_to_delete_count_;
-  CheckQuotaManagedDataDeletionStatus();
-}
-
-void BrowsingDataRemover::OnQuotaManagedOriginDeletion(
-    const GURL& origin,
-    quota::StorageType type,
-    quota::QuotaStatusCode status) {
-  DCHECK_GT(quota_managed_origins_to_delete_count_, 0);
-  if (status != quota::kQuotaStatusOk) {
-    DLOG(ERROR) << "Couldn't remove data of type " << type << " for origin "
-                << origin << ". Status: " << status;
-  }
-
-  --quota_managed_origins_to_delete_count_;
-  CheckQuotaManagedDataDeletionStatus();
-}
-
-void BrowsingDataRemover::CheckQuotaManagedDataDeletionStatus() {
-  if (quota_managed_storage_types_to_delete_count_ != 0 ||
-      quota_managed_origins_to_delete_count_ != 0) {
-    return;
-  }
-
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&BrowsingDataRemover::OnQuotaManagedDataDeleted,
-                 base::Unretained(this)));
-}
-
-void BrowsingDataRemover::OnQuotaManagedDataDeleted() {
-  DCHECK(waiting_for_clear_quota_managed_data_);
-  waiting_for_clear_quota_managed_data_ = false;
-  NotifyAndDeleteIfDone();
-}
-
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   waiting_for_clear_plugin_data_ = false;
   NotifyAndDeleteIfDone();
 }
 
 #if defined(ENABLE_PLUGINS)
 void BrowsingDataRemover::OnDeauthorizeContentLicensesCompleted(
     uint32 request_id,
     bool /* success */) {
@@ skipping 66 matching lines @@
   waiting_for_clear_form_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_autofill_origin_urls_ = false;
   NotifyAndDeleteIfDone();
 }
 
-void BrowsingDataRemover::OnClearWebRTCIdentityStore() {
+void BrowsingDataRemover::OnClearedStoragePartitionData() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  waiting_for_clear_webrtc_identity_store_ = false;
+  waiting_for_clear_storage_partition_data_ = false;
   NotifyAndDeleteIfDone();
 }