Move BrowsingDataRemover to content/

chrome/browser/extensions/api/browsing_data/browsing_data_api.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.
 
 // Defines the Chrome Extensions BrowsingData API functions, which entail
 // clearing browsing data, and clearing the browser's cache (which, let's be
 // honest, are the same thing), as specified in the extension API JSON.
 
 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
 
 #include <string>
 #include <utility>
 
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
-#include "chrome/browser/browsing_data/browsing_data_remover.h"
-#include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
+
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 #include "chrome/browser/plugins/plugin_data_remover_helper.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/browsing_data_remover.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 
 using content::BrowserThread;
 
 namespace extension_browsing_data_api_constants {
 
 // Parameter name keys.
 const char kDataRemovalPermittedKey[] = "dataRemovalPermitted";
 const char kDataToRemoveKey[] = "dataToRemove";
@@ skipping 28 matching lines @@
 // "history").
 const char kBadDataTypeDetails[] = "Invalid value for data type '%s'.";
 const char kDeleteProhibitedError[] = "Browsing history and downloads are not "
                                       "permitted to be removed.";
 
 }  // namespace extension_browsing_data_api_constants
 
 namespace {
 int MaskForKey(const char* key) {
   if (strcmp(key, extension_browsing_data_api_constants::kAppCacheKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_APP_CACHE;
+    return content::BrowsingDataRemover::DATA_TYPE_APP_CACHE;
   if (strcmp(key, extension_browsing_data_api_constants::kCacheKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_CACHE;
+    return content::BrowsingDataRemover::DATA_TYPE_CACHE;
   if (strcmp(key, extension_browsing_data_api_constants::kCookiesKey) == 0) {
-    return BrowsingDataRemover::DATA_TYPE_COOKIES;
+    return content::BrowsingDataRemover::DATA_TYPE_COOKIES;
   }
   if (strcmp(key, extension_browsing_data_api_constants::kDownloadsKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_DOWNLOADS;
+    return content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS;
   if (strcmp(key, extension_browsing_data_api_constants::kFileSystemsKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS;
+    return content::BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS;
   if (strcmp(key, extension_browsing_data_api_constants::kFormDataKey) == 0)
     return ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA;
   if (strcmp(key, extension_browsing_data_api_constants::kHistoryKey) == 0)
     return ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY;
   if (strcmp(key, extension_browsing_data_api_constants::kIndexedDBKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_INDEXED_DB;
+    return content::BrowsingDataRemover::DATA_TYPE_INDEXED_DB;
   if (strcmp(key, extension_browsing_data_api_constants::kLocalStorageKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE;
+    return content::BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE;
   if (strcmp(key,
              extension_browsing_data_api_constants::kChannelIDsKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS;
+    return content::BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS;
   if (strcmp(key, extension_browsing_data_api_constants::kPasswordsKey) == 0)
     return ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS;
   if (strcmp(key, extension_browsing_data_api_constants::kPluginDataKey) == 0)
     return ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA;
   if (strcmp(key, extension_browsing_data_api_constants::kServiceWorkersKey) ==
       0)
-    return BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS;
+    return content::BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS;
   if (strcmp(key, extension_browsing_data_api_constants::kCacheStorageKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE;
+    return content::BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE;
   if (strcmp(key, extension_browsing_data_api_constants::kWebSQLKey) == 0)
-    return BrowsingDataRemover::DATA_TYPE_WEB_SQL;
+    return content::BrowsingDataRemover::DATA_TYPE_WEB_SQL;
 
   return 0;
 }
 
 // Returns false if any of the selected data types are not allowed to be
 // deleted.
 bool IsRemovalPermitted(int removal_mask, PrefService* prefs) {
   // Enterprise policy or user preference might prohibit deleting browser or
   // download history.
   if ((removal_mask & ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY) ||
-      (removal_mask & BrowsingDataRemover::DATA_TYPE_DOWNLOADS)) {
+      (removal_mask & content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS)) {
     return prefs->GetBoolean(prefs::kAllowDeletingBrowserHistory);
   }
   return true;
 }
 
 }  // namespace
 
 ExtensionFunction::ResponseAction BrowsingDataSettingsFunction::Run() {
   prefs_ = Profile::FromBrowserContext(browser_context())->GetPrefs();
 
@@ skipping 174 matching lines @@
     scoped_refptr<PluginPrefs> plugin_prefs) {
   if (!PluginDataRemoverHelper::IsSupported(plugin_prefs.get()))
     removal_mask_ &= ~ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(&BrowsingDataRemoverFunction::StartRemoving, this));
 }
 
 void BrowsingDataRemoverFunction::StartRemoving() {
-  BrowsingDataRemover* remover =
-      BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile());
+  content::BrowsingDataRemover* remover =
+      content::BrowserContext::GetBrowsingDataRemover(GetProfile());
   // Add a ref (Balanced in OnBrowsingDataRemoverDone)
   AddRef();
 
   // Create a BrowsingDataRemover, set the current object as an observer (so
   // that we're notified after removal) and call remove() with the arguments
   // we've generated above. We can use a raw pointer here, as the browsing data
   // remover is responsible for deleting itself once data removal is complete.
   observer_.Add(remover);
   remover->RemoveAndReply(
       remove_since_, base::Time::Max(),
       removal_mask_, origin_type_mask_, this);
 }
 
 bool BrowsingDataRemoverFunction::ParseOriginTypeMask(
     const base::DictionaryValue& options,
     int* origin_type_mask) {
   // Parse the |options| dictionary to generate the origin set mask. Default to
   // UNPROTECTED_WEB if the developer doesn't specify anything.
-  *origin_type_mask = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
+  *origin_type_mask = content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB;
 
   const base::DictionaryValue* d = NULL;
   if (options.HasKey(extension_browsing_data_api_constants::kOriginTypesKey)) {
     if (!options.GetDictionary(
             extension_browsing_data_api_constants::kOriginTypesKey, &d)) {
       return false;
     }
     bool value;
 
     // The developer specified something! Reset to 0 and parse the dictionary.
     *origin_type_mask = 0;
 
     // Unprotected web.
     if (d->HasKey(extension_browsing_data_api_constants::kUnprotectedWebKey)) {
       if (!d->GetBoolean(
               extension_browsing_data_api_constants::kUnprotectedWebKey,
               &value)) {
         return false;
       }
       *origin_type_mask |=
-          value ? BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB : 0;
+          value ? content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB : 0;
     }
 
     // Protected web.
     if (d->HasKey(extension_browsing_data_api_constants::kProtectedWebKey)) {
       if (!d->GetBoolean(
               extension_browsing_data_api_constants::kProtectedWebKey,
               &value)) {
         return false;
       }
       *origin_type_mask |=
-          value ? BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB : 0;
+          value ? content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB : 0;
     }
 
     // Extensions.
     if (d->HasKey(extension_browsing_data_api_constants::kExtensionsKey)) {
       if (!d->GetBoolean(extension_browsing_data_api_constants::kExtensionsKey,
                          &value)) {
         return false;
       }
       *origin_type_mask |=
           value ? ChromeBrowsingDataRemoverDelegate::ORIGIN_TYPE_EXTENSION : 0;
@@ skipping 19 matching lines @@
     if (!i.value().GetAsBoolean(&selected))
       return false;
     if (selected)
       *removal_mask |= MaskForKey(i.key().c_str());
   }
 
   return true;
 }
 
 bool BrowsingDataRemoveAppcacheFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_APP_CACHE;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_APP_CACHE;
   return true;
 }
 
 bool BrowsingDataRemoveCacheFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_CACHE;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_CACHE;
   return true;
 }
 
 bool BrowsingDataRemoveCookiesFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_COOKIES |
-                  BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_COOKIES |
+                  content::BrowsingDataRemover::DATA_TYPE_CHANNEL_IDS;
   return true;
 }
 
 bool BrowsingDataRemoveDownloadsFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_DOWNLOADS;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS;
   return true;
 }
 
 bool BrowsingDataRemoveFileSystemsFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_FILE_SYSTEMS;
   return true;
 }
 
 bool BrowsingDataRemoveFormDataFunction::GetRemovalMask(int* removal_mask) {
   *removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA;
   return true;
 }
 
 bool BrowsingDataRemoveHistoryFunction::GetRemovalMask(int* removal_mask) {
   *removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY;
   return true;
 }
 
 bool BrowsingDataRemoveIndexedDBFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_INDEXED_DB;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_INDEXED_DB;
   return true;
 }
 
 bool BrowsingDataRemoveLocalStorageFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_LOCAL_STORAGE;
   return true;
 }
 
 bool BrowsingDataRemovePluginDataFunction::GetRemovalMask(int* removal_mask) {
   *removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA;
   return true;
 }
 
 bool BrowsingDataRemovePasswordsFunction::GetRemovalMask(int* removal_mask) {
   *removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS;
   return true;
 }
 
 bool BrowsingDataRemoveServiceWorkersFunction::GetRemovalMask(
     int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_SERVICE_WORKERS;
   return true;
 }
 
 bool BrowsingDataRemoveCacheStorageFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_CACHE_STORAGE;
   return true;
 }
 
 bool BrowsingDataRemoveWebSQLFunction::GetRemovalMask(int* removal_mask) {
-  *removal_mask = BrowsingDataRemover::DATA_TYPE_WEB_SQL;
+  *removal_mask = content::BrowsingDataRemover::DATA_TYPE_WEB_SQL;
   return true;
 }