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