chrome/browser/extensions/api/browsing_data/browsing_data_test.cc

   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 <string>
   6
   7 #include "base/json/json_string_value_serializer.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/pattern.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  16 #include "chrome/browser/browsing_data/browsing_data_remover.h"
  17 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
  18 #include "chrome/browser/extensions/extension_function_test_utils.h"
  19 #include "chrome/browser/profiles/profile.h"
  20 #include "chrome/browser/ui/browser.h"
  21 #include "chrome/common/pref_names.h"
  22 #include "chrome/test/base/in_process_browser_test.h"
  23
  24 using extension_function_test_utils::RunFunctionAndReturnError;
  25 using extension_function_test_utils::RunFunctionAndReturnSingleResult;
  26
  27 namespace {
  28
  29 enum OriginTypeMask {
  30   UNPROTECTED_WEB = BrowsingDataHelper::UNPROTECTED_WEB,
  31   PROTECTED_WEB = BrowsingDataHelper::PROTECTED_WEB,
  32   EXTENSION = BrowsingDataHelper::EXTENSION
  33 };
  34
  35 const char kRemoveEverythingArguments[] = "[{\"since\": 1000}, {"
  36     "\"appcache\": true, \"cache\": true, \"cookies\": true, "
  37     "\"downloads\": true, \"fileSystems\": true, \"formData\": true, "
  38     "\"history\": true, \"indexedDB\": true, \"localStorage\": true, "
  39     "\"serverBoundCertificates\": true, \"passwords\": true, "
  40     "\"pluginData\": true, \"serviceWorkers\": true, \"webSQL\": true"
  41     "}]";
  42
  43
  44 class ExtensionBrowsingDataTest : public InProcessBrowserTest {
  45  public:
  46   base::Time GetBeginTime() {
  47     return called_with_details_->removal_begin;
  48   }
  49
  50   int GetRemovalMask() {
  51     return called_with_details_->removal_mask;
  52   }
  53
  54   int GetOriginTypeMask() {
  55     return called_with_details_->origin_type_mask;
  56   }
  57
  58  protected:
  59   void SetUpOnMainThread() override {
  60     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
  61     callback_subscription_ =
  62         BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
  63             base::Bind(&ExtensionBrowsingDataTest::NotifyWithDetails,
  64                        base::Unretained(this)));
  65   }
  66
  67   // Callback for browsing data removal events.
  68   void NotifyWithDetails(
  69       const BrowsingDataRemover::NotificationDetails& details) {
  70     // We're not taking ownership of the details object, but storing a copy of
  71     // it locally.
  72     called_with_details_.reset(
  73         new BrowsingDataRemover::NotificationDetails(details));
  74   }
  75
  76   int GetAsMask(const base::DictionaryValue* dict, std::string path,
  77                 int mask_value) {
  78     bool result;
  79     EXPECT_TRUE(dict->GetBoolean(path, &result)) << "for " << path;
  80     return result ? mask_value : 0;
  81   }
  82
  83   void RunBrowsingDataRemoveFunctionAndCompareRemovalMask(
  84       const std::string& data_types,
  85       int expected_mask) {
  86     scoped_refptr<BrowsingDataRemoveFunction> function =
  87         new BrowsingDataRemoveFunction();
  88     SCOPED_TRACE(data_types);
  89     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
  90         function.get(),
  91         std::string("[{\"since\": 1},") + data_types + "]",
  92         browser()));
  93     EXPECT_EQ(expected_mask, GetRemovalMask());
  94     EXPECT_EQ(UNPROTECTED_WEB, GetOriginTypeMask());
  95   }
  96
  97   void RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
  98       const std::string& key,
  99       int expected_mask) {
 100     RunBrowsingDataRemoveFunctionAndCompareRemovalMask(
 101         std::string("{\"") + key + "\": true}", expected_mask);
 102   }
 103
 104   void RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 105       const std::string& protectedStr,
 106       int expected_mask) {
 107     scoped_refptr<BrowsingDataRemoveFunction> function =
 108         new BrowsingDataRemoveFunction();
 109     SCOPED_TRACE(protectedStr);
 110     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
 111         function.get(),
 112         "[{\"originTypes\": " + protectedStr + "}, {\"cookies\": true}]",
 113         browser()));
 114     EXPECT_EQ(expected_mask, GetOriginTypeMask());
 115   }
 116
 117   template<class ShortcutFunction>
 118   void RunAndCompareRemovalMask(int expected_mask) {
 119     scoped_refptr<ShortcutFunction> function =
 120         new ShortcutFunction();
 121     SCOPED_TRACE(ShortcutFunction::function_name());
 122     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
 123         function.get(),
 124         std::string("[{\"since\": 1}]"),
 125         browser()));
 126     EXPECT_EQ(expected_mask, GetRemovalMask());
 127     EXPECT_EQ(UNPROTECTED_WEB, GetOriginTypeMask());
 128   }
 129
 130   void SetSinceAndVerify(BrowsingDataRemover::TimePeriod since_pref) {
 131     PrefService* prefs = browser()->profile()->GetPrefs();
 132     prefs->SetInteger(prefs::kDeleteTimePeriod, since_pref);
 133
 134     scoped_refptr<BrowsingDataSettingsFunction> function =
 135         new BrowsingDataSettingsFunction();
 136     SCOPED_TRACE("settings");
 137     scoped_ptr<base::Value> result_value(RunFunctionAndReturnSingleResult(
 138         function.get(), std::string("[]"), browser()));
 139
 140     base::DictionaryValue* result;
 141     EXPECT_TRUE(result_value->GetAsDictionary(&result));
 142     base::DictionaryValue* options;
 143     EXPECT_TRUE(result->GetDictionary("options", &options));
 144     double since;
 145     EXPECT_TRUE(options->GetDouble("since", &since));
 146
 147     double expected_since = 0;
 148     if (since_pref != BrowsingDataRemover::EVERYTHING) {
 149       base::Time time =
 150           BrowsingDataRemover::CalculateBeginDeleteTime(since_pref);
 151       expected_since = time.ToJsTime();
 152     }
 153     // Even a synchronous function takes nonzero time, but the difference
 154     // between when the function was called and now should be well under a
 155     // second, so we'll make sure the requested start time is within 10 seconds.
 156     // Since the smallest selectable period is an hour, that should be
 157     // sufficient.
 158     EXPECT_LE(expected_since, since + 10.0 * 1000.0);
 159   }
 160
 161   void SetPrefsAndVerifySettings(int data_type_flags,
 162                                  int expected_origin_type_mask,
 163                                  int expected_removal_mask) {
 164     PrefService* prefs = browser()->profile()->GetPrefs();
 165     prefs->SetBoolean(prefs::kDeleteCache,
 166         !!(data_type_flags & BrowsingDataRemover::REMOVE_CACHE));
 167     prefs->SetBoolean(prefs::kDeleteCookies,
 168         !!(data_type_flags & BrowsingDataRemover::REMOVE_COOKIES));
 169     prefs->SetBoolean(prefs::kDeleteBrowsingHistory,
 170         !!(data_type_flags & BrowsingDataRemover::REMOVE_HISTORY));
 171     prefs->SetBoolean(prefs::kDeleteFormData,
 172         !!(data_type_flags & BrowsingDataRemover::REMOVE_FORM_DATA));
 173     prefs->SetBoolean(prefs::kDeleteDownloadHistory,
 174         !!(data_type_flags & BrowsingDataRemover::REMOVE_DOWNLOADS));
 175     prefs->SetBoolean(prefs::kDeleteHostedAppsData,
 176         !!(data_type_flags &
 177            BrowsingDataRemover::REMOVE_HOSTED_APP_DATA_TESTONLY));
 178     prefs->SetBoolean(prefs::kDeletePasswords,
 179         !!(data_type_flags & BrowsingDataRemover::REMOVE_PASSWORDS));
 180     prefs->SetBoolean(prefs::kClearPluginLSODataEnabled,
 181         !!(data_type_flags & BrowsingDataRemover::REMOVE_PLUGIN_DATA));
 182
 183     scoped_refptr<BrowsingDataSettingsFunction> function =
 184         new BrowsingDataSettingsFunction();
 185     SCOPED_TRACE("settings");
 186     scoped_ptr<base::Value> result_value(RunFunctionAndReturnSingleResult(
 187         function.get(), std::string("[]"), browser()));
 188
 189     base::DictionaryValue* result;
 190     EXPECT_TRUE(result_value->GetAsDictionary(&result));
 191
 192     base::DictionaryValue* options;
 193     EXPECT_TRUE(result->GetDictionary("options", &options));
 194     base::DictionaryValue* origin_types;
 195     EXPECT_TRUE(options->GetDictionary("originTypes", &origin_types));
 196     int origin_type_mask = GetAsMask(origin_types, "unprotectedWeb",
 197                                     UNPROTECTED_WEB) |
 198                           GetAsMask(origin_types, "protectedWeb",
 199                                     PROTECTED_WEB) |
 200                           GetAsMask(origin_types, "extension", EXTENSION);
 201     EXPECT_EQ(expected_origin_type_mask, origin_type_mask);
 202
 203     base::DictionaryValue* data_to_remove;
 204     EXPECT_TRUE(result->GetDictionary("dataToRemove", &data_to_remove));
 205     int removal_mask = GetAsMask(data_to_remove, "appcache",
 206                                  BrowsingDataRemover::REMOVE_APPCACHE) |
 207                        GetAsMask(data_to_remove, "cache",
 208                                  BrowsingDataRemover::REMOVE_CACHE) |
 209                        GetAsMask(data_to_remove, "cookies",
 210                                  BrowsingDataRemover::REMOVE_COOKIES) |
 211                        GetAsMask(data_to_remove, "downloads",
 212                                  BrowsingDataRemover::REMOVE_DOWNLOADS) |
 213                        GetAsMask(data_to_remove, "fileSystems",
 214                                  BrowsingDataRemover::REMOVE_FILE_SYSTEMS) |
 215                        GetAsMask(data_to_remove, "formData",
 216                                  BrowsingDataRemover::REMOVE_FORM_DATA) |
 217                        GetAsMask(data_to_remove, "history",
 218                                  BrowsingDataRemover::REMOVE_HISTORY) |
 219                        GetAsMask(data_to_remove, "indexedDB",
 220                                  BrowsingDataRemover::REMOVE_INDEXEDDB) |
 221                        GetAsMask(data_to_remove, "localStorage",
 222                                  BrowsingDataRemover::REMOVE_LOCAL_STORAGE) |
 223                        GetAsMask(data_to_remove, "pluginData",
 224                                  BrowsingDataRemover::REMOVE_PLUGIN_DATA) |
 225                        GetAsMask(data_to_remove, "passwords",
 226                                  BrowsingDataRemover::REMOVE_PASSWORDS) |
 227                        GetAsMask(data_to_remove, "serviceWorkers",
 228                                  BrowsingDataRemover::REMOVE_SERVICE_WORKERS) |
 229                        GetAsMask(data_to_remove, "webSQL",
 230                                  BrowsingDataRemover::REMOVE_WEBSQL) |
 231                        GetAsMask(data_to_remove, "serverBoundCertificates",
 232                            BrowsingDataRemover::REMOVE_CHANNEL_IDS);
 233     EXPECT_EQ(expected_removal_mask, removal_mask);
 234   }
 235
 236   // The kAllowDeletingBrowserHistory pref must be set to false before this
 237   // is called.
 238   void CheckRemovalPermitted(const std::string& data_types, bool permitted) {
 239     scoped_refptr<BrowsingDataRemoveFunction> function =
 240         new BrowsingDataRemoveFunction();
 241     std::string args = "[{\"since\": 1}," + data_types + "]";
 242
 243     if (permitted) {
 244       EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
 245         function.get(), args, browser())) << " for " << args;
 246     } else {
 247       EXPECT_TRUE(base::MatchPattern(
 248           RunFunctionAndReturnError(function.get(), args, browser()),
 249           extension_browsing_data_api_constants::kDeleteProhibitedError))
 250           << " for " << args;
 251     }
 252   }
 253
 254  private:
 255   scoped_ptr<BrowsingDataRemover::NotificationDetails> called_with_details_;
 256
 257   BrowsingDataRemover::CallbackSubscription callback_subscription_;
 258
 259 };
 260
 261 }  // namespace
 262
 263 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, OneAtATime) {
 264   BrowsingDataRemover::set_removing(true);
 265   scoped_refptr<BrowsingDataRemoveFunction> function =
 266       new BrowsingDataRemoveFunction();
 267   EXPECT_TRUE(base::MatchPattern(
 268       RunFunctionAndReturnError(function.get(), kRemoveEverythingArguments,
 269                                 browser()),
 270       extension_browsing_data_api_constants::kOneAtATimeError));
 271   BrowsingDataRemover::set_removing(false);
 272
 273   EXPECT_EQ(base::Time(), GetBeginTime());
 274   EXPECT_EQ(-1, GetRemovalMask());
 275 }
 276
 277 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, RemovalProhibited) {
 278   PrefService* prefs = browser()->profile()->GetPrefs();
 279   prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
 280
 281   CheckRemovalPermitted("{\"appcache\": true}", true);
 282   CheckRemovalPermitted("{\"cache\": true}", true);
 283   CheckRemovalPermitted("{\"cookies\": true}", true);
 284   CheckRemovalPermitted("{\"downloads\": true}", false);
 285   CheckRemovalPermitted("{\"fileSystems\": true}", true);
 286   CheckRemovalPermitted("{\"formData\": true}", true);
 287   CheckRemovalPermitted("{\"history\": true}", false);
 288   CheckRemovalPermitted("{\"indexedDB\": true}", true);
 289   CheckRemovalPermitted("{\"localStorage\": true}", true);
 290   CheckRemovalPermitted("{\"serverBoundCertificates\": true}", true);
 291   CheckRemovalPermitted("{\"passwords\": true}", true);
 292   CheckRemovalPermitted("{\"serviceWorkers\": true}", true);
 293   CheckRemovalPermitted("{\"webSQL\": true}", true);
 294
 295   // The entire removal is prohibited if any part is.
 296   CheckRemovalPermitted("{\"cache\": true, \"history\": true}", false);
 297   CheckRemovalPermitted("{\"cookies\": true, \"downloads\": true}", false);
 298
 299   // If a prohibited type is not selected, the removal is OK.
 300   CheckRemovalPermitted("{\"history\": false}", true);
 301   CheckRemovalPermitted("{\"downloads\": false}", true);
 302   CheckRemovalPermitted("{\"cache\": true, \"history\": false}", true);
 303   CheckRemovalPermitted("{\"cookies\": true, \"downloads\": false}", true);
 304 }
 305
 306 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, RemoveBrowsingDataAll) {
 307   scoped_refptr<BrowsingDataRemoveFunction> function =
 308       new BrowsingDataRemoveFunction();
 309   EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(function.get(),
 310                                                    kRemoveEverythingArguments,
 311                                                    browser()));
 312
 313   EXPECT_EQ(base::Time::FromDoubleT(1.0), GetBeginTime());
 314   EXPECT_EQ((BrowsingDataRemover::REMOVE_SITE_DATA |
 315       BrowsingDataRemover::REMOVE_CACHE |
 316       BrowsingDataRemover::REMOVE_DOWNLOADS |
 317       BrowsingDataRemover::REMOVE_FORM_DATA |
 318       BrowsingDataRemover::REMOVE_HISTORY |
 319       BrowsingDataRemover::REMOVE_PASSWORDS) &
 320       // TODO(benwells): implement clearing of site usage data via the browsing
 321       // data API. https://crbug.com/500801.
 322       ~BrowsingDataRemover::REMOVE_SITE_USAGE_DATA &
 323       // We can't remove plugin data inside a test profile.
 324       ~BrowsingDataRemover::REMOVE_PLUGIN_DATA, GetRemovalMask());
 325 }
 326
 327 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, BrowsingDataOriginTypeMask) {
 328   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask("{}", 0);
 329
 330   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 331       "{\"unprotectedWeb\": true}", UNPROTECTED_WEB);
 332   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 333       "{\"protectedWeb\": true}", PROTECTED_WEB);
 334   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 335       "{\"extension\": true}", EXTENSION);
 336
 337   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 338       "{\"unprotectedWeb\": true, \"protectedWeb\": true}",
 339       UNPROTECTED_WEB | PROTECTED_WEB);
 340   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 341       "{\"unprotectedWeb\": true, \"extension\": true}",
 342       UNPROTECTED_WEB | EXTENSION);
 343   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 344       "{\"protectedWeb\": true, \"extension\": true}",
 345       PROTECTED_WEB | EXTENSION);
 346
 347   RunBrowsingDataRemoveFunctionAndCompareOriginTypeMask(
 348       ("{\"unprotectedWeb\": true, \"protectedWeb\": true, "
 349        "\"extension\": true}"),
 350       UNPROTECTED_WEB | PROTECTED_WEB | EXTENSION);
 351 }
 352
 353 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
 354                        BrowsingDataRemovalMask) {
 355   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 356       "appcache", BrowsingDataRemover::REMOVE_APPCACHE);
 357   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 358       "cache", BrowsingDataRemover::REMOVE_CACHE);
 359   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 360       "cookies", BrowsingDataRemover::REMOVE_COOKIES);
 361   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 362       "downloads", BrowsingDataRemover::REMOVE_DOWNLOADS);
 363   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 364       "fileSystems", BrowsingDataRemover::REMOVE_FILE_SYSTEMS);
 365   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 366       "formData", BrowsingDataRemover::REMOVE_FORM_DATA);
 367   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 368       "history", BrowsingDataRemover::REMOVE_HISTORY);
 369   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 370       "indexedDB", BrowsingDataRemover::REMOVE_INDEXEDDB);
 371   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 372       "localStorage", BrowsingDataRemover::REMOVE_LOCAL_STORAGE);
 373   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 374       "serverBoundCertificates",
 375       BrowsingDataRemover::REMOVE_CHANNEL_IDS);
 376   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 377       "passwords", BrowsingDataRemover::REMOVE_PASSWORDS);
 378   // We can't remove plugin data inside a test profile.
 379   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 380       "serviceWorkers", BrowsingDataRemover::REMOVE_SERVICE_WORKERS);
 381   RunBrowsingDataRemoveWithKeyAndCompareRemovalMask(
 382       "webSQL", BrowsingDataRemover::REMOVE_WEBSQL);
 383 }
 384
 385 // Test an arbitrary combination of data types.
 386 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
 387                        BrowsingDataRemovalMaskCombination) {
 388   RunBrowsingDataRemoveFunctionAndCompareRemovalMask(
 389        "{\"appcache\": true, \"cookies\": true, \"history\": true}",
 390        BrowsingDataRemover::REMOVE_APPCACHE |
 391            BrowsingDataRemover::REMOVE_COOKIES |
 392            BrowsingDataRemover::REMOVE_HISTORY);
 393 }
 394
 395 // Make sure the remove() function accepts the format produced by settings().
 396 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
 397                        BrowsingDataRemovalInputFromSettings) {
 398   PrefService* prefs = browser()->profile()->GetPrefs();
 399   prefs->SetBoolean(prefs::kDeleteCache, true);
 400   prefs->SetBoolean(prefs::kDeleteBrowsingHistory, true);
 401   prefs->SetBoolean(prefs::kDeleteDownloadHistory, true);
 402   prefs->SetBoolean(prefs::kDeleteCookies, false);
 403   prefs->SetBoolean(prefs::kDeleteFormData, false);
 404   prefs->SetBoolean(prefs::kDeleteHostedAppsData, false);
 405   prefs->SetBoolean(prefs::kDeletePasswords, false);
 406   prefs->SetBoolean(prefs::kClearPluginLSODataEnabled, false);
 407   int expected_mask = BrowsingDataRemover::REMOVE_CACHE |
 408         BrowsingDataRemover::REMOVE_DOWNLOADS |
 409         BrowsingDataRemover::REMOVE_HISTORY;
 410   std::string json;
 411   // Scoping for the traces.
 412   {
 413     scoped_refptr<BrowsingDataSettingsFunction> settings_function =
 414         new BrowsingDataSettingsFunction();
 415     SCOPED_TRACE("settings_json");
 416     scoped_ptr<base::Value> result_value(RunFunctionAndReturnSingleResult(
 417         settings_function.get(), std::string("[]"), browser()));
 418
 419     base::DictionaryValue* result;
 420     EXPECT_TRUE(result_value->GetAsDictionary(&result));
 421     base::DictionaryValue* data_to_remove;
 422     EXPECT_TRUE(result->GetDictionary("dataToRemove", &data_to_remove));
 423
 424     JSONStringValueSerializer serializer(&json);
 425     EXPECT_TRUE(serializer.Serialize(*data_to_remove));
 426   }
 427   {
 428     scoped_refptr<BrowsingDataRemoveFunction> remove_function =
 429         new BrowsingDataRemoveFunction();
 430     SCOPED_TRACE("remove_json");
 431     EXPECT_EQ(NULL, RunFunctionAndReturnSingleResult(
 432         remove_function.get(),
 433         std::string("[{\"since\": 1},") + json + "]",
 434         browser()));
 435     EXPECT_EQ(expected_mask, GetRemovalMask());
 436     EXPECT_EQ(UNPROTECTED_WEB, GetOriginTypeMask());
 437   }
 438 }
 439
 440 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, ShortcutFunctionRemovalMask) {
 441   RunAndCompareRemovalMask<BrowsingDataRemoveAppcacheFunction>(
 442       BrowsingDataRemover::REMOVE_APPCACHE);
 443   RunAndCompareRemovalMask<BrowsingDataRemoveCacheFunction>(
 444       BrowsingDataRemover::REMOVE_CACHE);
 445   RunAndCompareRemovalMask<BrowsingDataRemoveCookiesFunction>(
 446       BrowsingDataRemover::REMOVE_COOKIES |
 447       BrowsingDataRemover::REMOVE_CHANNEL_IDS);
 448   RunAndCompareRemovalMask<BrowsingDataRemoveDownloadsFunction>(
 449       BrowsingDataRemover::REMOVE_DOWNLOADS);
 450   RunAndCompareRemovalMask<BrowsingDataRemoveFileSystemsFunction>(
 451       BrowsingDataRemover::REMOVE_FILE_SYSTEMS);
 452   RunAndCompareRemovalMask<BrowsingDataRemoveFormDataFunction>(
 453       BrowsingDataRemover::REMOVE_FORM_DATA);
 454   RunAndCompareRemovalMask<BrowsingDataRemoveHistoryFunction>(
 455       BrowsingDataRemover::REMOVE_HISTORY);
 456   RunAndCompareRemovalMask<BrowsingDataRemoveIndexedDBFunction>(
 457       BrowsingDataRemover::REMOVE_INDEXEDDB);
 458   RunAndCompareRemovalMask<BrowsingDataRemoveLocalStorageFunction>(
 459       BrowsingDataRemover::REMOVE_LOCAL_STORAGE);
 460   // We can't remove plugin data inside a test profile.
 461   RunAndCompareRemovalMask<BrowsingDataRemovePasswordsFunction>(
 462       BrowsingDataRemover::REMOVE_PASSWORDS);
 463   RunAndCompareRemovalMask<BrowsingDataRemoveServiceWorkersFunction>(
 464       BrowsingDataRemover::REMOVE_SERVICE_WORKERS);
 465   RunAndCompareRemovalMask<BrowsingDataRemoveWebSQLFunction>(
 466       BrowsingDataRemover::REMOVE_WEBSQL);
 467 }
 468
 469 // Test the processing of the 'delete since' preference.
 470 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSince) {
 471   SetSinceAndVerify(BrowsingDataRemover::EVERYTHING);
 472   SetSinceAndVerify(BrowsingDataRemover::LAST_HOUR);
 473   SetSinceAndVerify(BrowsingDataRemover::LAST_DAY);
 474   SetSinceAndVerify(BrowsingDataRemover::LAST_WEEK);
 475   SetSinceAndVerify(BrowsingDataRemover::FOUR_WEEKS);
 476 }
 477
 478 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionEmpty) {
 479   SetPrefsAndVerifySettings(0, 0, 0);
 480 }
 481
 482 // Test straightforward settings, mapped 1:1 to data types.
 483 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSimple) {
 484   SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_CACHE, 0,
 485                             BrowsingDataRemover::REMOVE_CACHE);
 486   SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_HISTORY, 0,
 487                             BrowsingDataRemover::REMOVE_HISTORY);
 488   SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_FORM_DATA, 0,
 489                             BrowsingDataRemover::REMOVE_FORM_DATA);
 490   SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_DOWNLOADS, 0,
 491                             BrowsingDataRemover::REMOVE_DOWNLOADS);
 492   SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_PASSWORDS, 0,
 493                             BrowsingDataRemover::REMOVE_PASSWORDS);
 494 }
 495
 496 // Test cookie and app data settings.
 497 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSiteData) {
 498   int site_data_no_usage = BrowsingDataRemover::REMOVE_SITE_DATA &
 499       ~BrowsingDataRemover::REMOVE_SITE_USAGE_DATA;
 500   int site_data_no_plugins = site_data_no_usage &
 501       ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
 502
 503   SetPrefsAndVerifySettings(BrowsingDataRemover::REMOVE_COOKIES,
 504                             UNPROTECTED_WEB,
 505                             site_data_no_plugins);
 506   SetPrefsAndVerifySettings(
 507       BrowsingDataRemover::REMOVE_HOSTED_APP_DATA_TESTONLY,
 508       PROTECTED_WEB,
 509       site_data_no_plugins);
 510   SetPrefsAndVerifySettings(
 511       BrowsingDataRemover::REMOVE_COOKIES |
 512           BrowsingDataRemover::REMOVE_HOSTED_APP_DATA_TESTONLY,
 513       PROTECTED_WEB | UNPROTECTED_WEB,
 514       site_data_no_plugins);
 515   SetPrefsAndVerifySettings(
 516       BrowsingDataRemover::REMOVE_COOKIES |
 517           BrowsingDataRemover::REMOVE_PLUGIN_DATA,
 518       UNPROTECTED_WEB,
 519       site_data_no_usage);
 520 }
 521
 522 // Test an arbitrary assortment of settings.
 523 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionAssorted) {
 524   int site_data_no_plugins = BrowsingDataRemover::REMOVE_SITE_DATA &
 525       ~BrowsingDataRemover::REMOVE_SITE_USAGE_DATA &
 526       ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
 527
 528   SetPrefsAndVerifySettings(
 529       BrowsingDataRemover::REMOVE_COOKIES |
 530           BrowsingDataRemover::REMOVE_HISTORY |
 531           BrowsingDataRemover::REMOVE_DOWNLOADS,
 532     UNPROTECTED_WEB,
 533     site_data_no_plugins |
 534         BrowsingDataRemover::REMOVE_HISTORY |
 535         BrowsingDataRemover::REMOVE_DOWNLOADS);
 536 }