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 "chrome/browser/browsing_data/browsing_data_remover.h"
6
7#include <set>
8#include <vector>
9
10#include "base/bind.h"
11#include "base/bind_helpers.h"
12#include "base/file_util.h"
13#include "base/files/file_path.h"
14#include "base/guid.h"
15#include "base/message_loop/message_loop.h"
16#include "base/platform_file.h"
17#include "base/prefs/testing_pref_service.h"
18#include "base/strings/utf_string_conversions.h"
19#include "chrome/browser/autofill/personal_data_manager_factory.h"
20#include "chrome/browser/browsing_data/browsing_data_helper.h"
21#include "chrome/browser/chrome_notification_types.h"
22#if defined(OS_CHROMEOS)
23#include "chrome/browser/chromeos/login/mock_user_manager.h"
24#include "chrome/browser/chromeos/login/user_manager.h"
25#include "chrome/browser/chromeos/settings/cros_settings.h"
26#include "chrome/browser/chromeos/settings/device_settings_service.h"
27#endif
28#include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
29#include "chrome/browser/history/history_service.h"
30#include "chrome/browser/history/history_service_factory.h"
31#include "chrome/browser/safe_browsing/safe_browsing_service.h"
32#include "chrome/common/pref_names.h"
33#include "chrome/test/base/testing_browser_process.h"
34#include "chrome/test/base/testing_profile.h"
35#if defined(OS_CHROMEOS)
36#include "chromeos/dbus/dbus_thread_manager.h"
37#include "chromeos/dbus/fake_dbus_thread_manager.h"
38#include "chromeos/dbus/mock_cryptohome_client.h"
39#endif
40#include "components/autofill/core/browser/autofill_profile.h"
41#include "components/autofill/core/browser/autofill_test_utils.h"
42#include "components/autofill/core/browser/credit_card.h"
43#include "components/autofill/core/browser/personal_data_manager.h"
44#include "components/autofill/core/browser/personal_data_manager_observer.h"
45#include "content/public/browser/dom_storage_context.h"
46#include "content/public/browser/local_storage_usage_info.h"
47#include "content/public/browser/notification_service.h"
48#include "content/public/browser/storage_partition.h"
49#include "content/public/test/test_browser_thread.h"
50#include "content/public/test/test_browser_thread_bundle.h"
51#include "net/cookies/cookie_monster.h"
52#include "net/ssl/server_bound_cert_service.h"
53#include "net/ssl/server_bound_cert_store.h"
54#include "net/ssl/ssl_client_cert_type.h"
55#include "net/url_request/url_request_context.h"
56#include "net/url_request/url_request_context_getter.h"
57#include "testing/gmock/include/gmock/gmock.h"
58#include "testing/gtest/include/gtest/gtest.h"
59
60using content::BrowserThread;
61using content::StoragePartition;
62using testing::_;
63using testing::Invoke;
64using testing::WithArgs;
65
66namespace {
67
68const char kTestOrigin1[] = "http://host1:1/";
69const char kTestOrigin2[] = "http://host2:1/";
70const char kTestOrigin3[] = "http://host3:1/";
71const char kTestOriginExt[] = "chrome-extension://abcdefghijklmnopqrstuvwxyz/";
72const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
73
74// For Autofill.
75const char kChromeOrigin[] = "Chrome settings";
76const char kWebOrigin[] = "https://www.example.com/";
77
78const GURL kOrigin1(kTestOrigin1);
79const GURL kOrigin2(kTestOrigin2);
80const GURL kOrigin3(kTestOrigin3);
81const GURL kOriginExt(kTestOriginExt);
82const GURL kOriginDevTools(kTestOriginDevTools);
83
84const base::FilePath::CharType kDomStorageOrigin1[] =
85    FILE_PATH_LITERAL("http_host1_1.localstorage");
86
87const base::FilePath::CharType kDomStorageOrigin2[] =
88    FILE_PATH_LITERAL("http_host2_1.localstorage");
89
90const base::FilePath::CharType kDomStorageOrigin3[] =
91    FILE_PATH_LITERAL("http_host3_1.localstorage");
92
93const base::FilePath::CharType kDomStorageExt[] = FILE_PATH_LITERAL(
94    "chrome-extension_abcdefghijklmnopqrstuvwxyz_0.localstorage");
95
96class AwaitCompletionHelper : public BrowsingDataRemover::Observer {
97 public:
98  AwaitCompletionHelper() : start_(false), already_quit_(false) {}
99  virtual ~AwaitCompletionHelper() {}
100
101  void BlockUntilNotified() {
102    if (!already_quit_) {
103      DCHECK(!start_);
104      start_ = true;
105      base::MessageLoop::current()->Run();
106    } else {
107      DCHECK(!start_);
108      already_quit_ = false;
109    }
110  }
111
112  void Notify() {
113    if (start_) {
114      DCHECK(!already_quit_);
115      base::MessageLoop::current()->Quit();
116      start_ = false;
117    } else {
118      DCHECK(!already_quit_);
119      already_quit_ = true;
120    }
121  }
122
123 protected:
124  // BrowsingDataRemover::Observer implementation.
125  virtual void OnBrowsingDataRemoverDone() OVERRIDE {
126    Notify();
127  }
128
129 private:
130  // Helps prevent from running message_loop, if the callback invoked
131  // immediately.
132  bool start_;
133  bool already_quit_;
134
135  DISALLOW_COPY_AND_ASSIGN(AwaitCompletionHelper);
136};
137
138#if defined(OS_CHROMEOS)
139void FakeDBusCall(const chromeos::BoolDBusMethodCallback& callback) {
140  base::MessageLoop::current()->PostTask(
141      FROM_HERE,
142      base::Bind(callback, chromeos::DBUS_METHOD_CALL_SUCCESS, true));
143}
144#endif
145
146struct StoragePartitionRemovalData {
147  uint32 remove_mask;
148  uint32 quota_storage_remove_mask;
149  GURL remove_origin;
150  base::Time remove_begin;
151  base::Time remove_end;
152  StoragePartition::OriginMatcherFunction origin_matcher;
153
154  StoragePartitionRemovalData() : remove_mask(0),
155                                  quota_storage_remove_mask(0) {}
156};
157
158class TestStoragePartition : public StoragePartition {
159 public:
160  TestStoragePartition() {}
161  virtual ~TestStoragePartition() {}
162
163  // content::StoragePartition implementation.
164  virtual base::FilePath GetPath() OVERRIDE { return base::FilePath(); }
165  virtual net::URLRequestContextGetter* GetURLRequestContext() OVERRIDE {
166    return NULL;
167  }
168  virtual net::URLRequestContextGetter* GetMediaURLRequestContext() OVERRIDE {
169    return NULL;
170  }
171  virtual quota::QuotaManager* GetQuotaManager() OVERRIDE {
172    return NULL;
173  }
174  virtual appcache::AppCacheService* GetAppCacheService() OVERRIDE {
175    return NULL;
176  }
177  virtual fileapi::FileSystemContext* GetFileSystemContext() OVERRIDE {
178    return NULL;
179  }
180  virtual webkit_database::DatabaseTracker* GetDatabaseTracker() OVERRIDE {
181    return NULL;
182  }
183  virtual content::DOMStorageContext* GetDOMStorageContext() OVERRIDE {
184    return NULL;
185  }
186  virtual content::IndexedDBContext* GetIndexedDBContext() OVERRIDE {
187    return NULL;
188  }
189
190  virtual void ClearDataForOrigin(
191      uint32 remove_mask,
192      uint32 quota_storage_remove_mask,
193      const GURL& storage_origin,
194      net::URLRequestContextGetter* rq_context) OVERRIDE {}
195
196  virtual void ClearData(uint32 remove_mask,
197                         uint32 quota_storage_remove_mask,
198                         const GURL* storage_origin,
199                         const OriginMatcherFunction& origin_matcher,
200                         const base::Time begin,
201                         const base::Time end,
202                         const base::Closure& callback) OVERRIDE {
203    // Store stuff to verify parameters' correctness later.
204    storage_partition_removal_data_.remove_mask = remove_mask;
205    storage_partition_removal_data_.quota_storage_remove_mask =
206        quota_storage_remove_mask;
207    storage_partition_removal_data_.remove_origin =
208        storage_origin ? *storage_origin : GURL();
209    storage_partition_removal_data_.remove_begin = begin;
210    storage_partition_removal_data_.remove_end = end;
211    storage_partition_removal_data_.origin_matcher = origin_matcher;
212
213    BrowserThread::PostTask(
214        BrowserThread::UI,
215        FROM_HERE,
216        base::Bind(&TestStoragePartition::AsyncRunCallback,
217                   base::Unretained(this), callback));
218  }
219
220  StoragePartitionRemovalData GetStoragePartitionRemovalData() {
221    return storage_partition_removal_data_;
222  }
223 private:
224  void AsyncRunCallback(const base::Closure& callback) {
225    callback.Run();
226  }
227
228  StoragePartitionRemovalData storage_partition_removal_data_;
229
230  DISALLOW_COPY_AND_ASSIGN(TestStoragePartition);
231};
232
233}  // namespace
234
235// Testers -------------------------------------------------------------------
236
237class RemoveCookieTester {
238 public:
239  RemoveCookieTester() : get_cookie_success_(false), monster_(NULL) {
240  }
241
242  // Returns true, if the given cookie exists in the cookie store.
243  bool ContainsCookie() {
244    get_cookie_success_ = false;
245    monster_->GetCookiesWithOptionsAsync(
246        kOrigin1, net::CookieOptions(),
247        base::Bind(&RemoveCookieTester::GetCookieCallback,
248                   base::Unretained(this)));
249    await_completion_.BlockUntilNotified();
250    return get_cookie_success_;
251  }
252
253  void AddCookie() {
254    monster_->SetCookieWithOptionsAsync(
255        kOrigin1, "A=1", net::CookieOptions(),
256        base::Bind(&RemoveCookieTester::SetCookieCallback,
257                   base::Unretained(this)));
258    await_completion_.BlockUntilNotified();
259  }
260
261 protected:
262  void SetMonster(net::CookieStore* monster) {
263    monster_ = monster;
264  }
265
266 private:
267  void GetCookieCallback(const std::string& cookies) {
268    if (cookies == "A=1") {
269      get_cookie_success_ = true;
270    } else {
271      EXPECT_EQ("", cookies);
272      get_cookie_success_ = false;
273    }
274    await_completion_.Notify();
275  }
276
277  void SetCookieCallback(bool result) {
278    ASSERT_TRUE(result);
279    await_completion_.Notify();
280  }
281
282  bool get_cookie_success_;
283  AwaitCompletionHelper await_completion_;
284  net::CookieStore* monster_;
285
286  DISALLOW_COPY_AND_ASSIGN(RemoveCookieTester);
287};
288
289#if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
290class RemoveSafeBrowsingCookieTester : public RemoveCookieTester {
291 public:
292  RemoveSafeBrowsingCookieTester()
293      : browser_process_(TestingBrowserProcess::GetGlobal()) {
294    scoped_refptr<SafeBrowsingService> sb_service =
295        SafeBrowsingService::CreateSafeBrowsingService();
296    browser_process_->SetSafeBrowsingService(sb_service.get());
297    sb_service->Initialize();
298    base::MessageLoop::current()->RunUntilIdle();
299
300    // Create a cookiemonster that does not have persistant storage, and replace
301    // the SafeBrowsingService created one with it.
302    net::CookieStore* monster = new net::CookieMonster(NULL, NULL);
303    sb_service->url_request_context()->GetURLRequestContext()->
304        set_cookie_store(monster);
305    SetMonster(monster);
306  }
307
308  virtual ~RemoveSafeBrowsingCookieTester() {
309    browser_process_->safe_browsing_service()->ShutDown();
310    base::MessageLoop::current()->RunUntilIdle();
311    browser_process_->SetSafeBrowsingService(NULL);
312  }
313
314 private:
315  TestingBrowserProcess* browser_process_;
316
317  DISALLOW_COPY_AND_ASSIGN(RemoveSafeBrowsingCookieTester);
318};
319#endif
320
321class RemoveServerBoundCertTester : public net::SSLConfigService::Observer {
322 public:
323  explicit RemoveServerBoundCertTester(TestingProfile* profile)
324      : ssl_config_changed_count_(0) {
325    server_bound_cert_service_ = profile->GetRequestContext()->
326        GetURLRequestContext()->server_bound_cert_service();
327    ssl_config_service_ = profile->GetSSLConfigService();
328    ssl_config_service_->AddObserver(this);
329  }
330
331  virtual ~RemoveServerBoundCertTester() {
332    ssl_config_service_->RemoveObserver(this);
333  }
334
335  int ServerBoundCertCount() {
336    return server_bound_cert_service_->cert_count();
337  }
338
339  // Add a server bound cert for |server| with specific creation and expiry
340  // times.  The cert and key data will be filled with dummy values.
341  void AddServerBoundCertWithTimes(const std::string& server_identifier,
342                                   base::Time creation_time,
343                                   base::Time expiration_time) {
344    GetCertStore()->SetServerBoundCert(server_identifier,
345                                       creation_time,
346                                       expiration_time,
347                                       "a",
348                                       "b");
349  }
350
351  // Add a server bound cert for |server|, with the current time as the
352  // creation time.  The cert and key data will be filled with dummy values.
353  void AddServerBoundCert(const std::string& server_identifier) {
354    base::Time now = base::Time::Now();
355    AddServerBoundCertWithTimes(server_identifier,
356                                now,
357                                now + base::TimeDelta::FromDays(1));
358  }
359
360  void GetCertList(net::ServerBoundCertStore::ServerBoundCertList* certs) {
361    GetCertStore()->GetAllServerBoundCerts(
362        base::Bind(&RemoveServerBoundCertTester::GetAllCertsCallback, certs));
363  }
364
365  net::ServerBoundCertStore* GetCertStore() {
366    return server_bound_cert_service_->GetCertStore();
367  }
368
369  int ssl_config_changed_count() const {
370    return ssl_config_changed_count_;
371  }
372
373  // net::SSLConfigService::Observer implementation:
374  virtual void OnSSLConfigChanged() OVERRIDE {
375    ssl_config_changed_count_++;
376  }
377
378 private:
379  static void GetAllCertsCallback(
380      net::ServerBoundCertStore::ServerBoundCertList* dest,
381      const net::ServerBoundCertStore::ServerBoundCertList& result) {
382    *dest = result;
383  }
384
385  net::ServerBoundCertService* server_bound_cert_service_;
386  scoped_refptr<net::SSLConfigService> ssl_config_service_;
387  int ssl_config_changed_count_;
388
389  DISALLOW_COPY_AND_ASSIGN(RemoveServerBoundCertTester);
390};
391
392class RemoveHistoryTester {
393 public:
394  RemoveHistoryTester() : query_url_success_(false), history_service_(NULL) {}
395
396  bool Init(TestingProfile* profile) WARN_UNUSED_RESULT {
397    if (!profile->CreateHistoryService(true, false))
398      return false;
399    history_service_ = HistoryServiceFactory::GetForProfile(
400        profile, Profile::EXPLICIT_ACCESS);
401    return true;
402  }
403
404  // Returns true, if the given URL exists in the history service.
405  bool HistoryContainsURL(const GURL& url) {
406    history_service_->QueryURL(
407        url,
408        true,
409        &consumer_,
410        base::Bind(&RemoveHistoryTester::SaveResultAndQuit,
411                   base::Unretained(this)));
412    await_completion_.BlockUntilNotified();
413    return query_url_success_;
414  }
415
416  void AddHistory(const GURL& url, base::Time time) {
417    history_service_->AddPage(url, time, NULL, 0, GURL(),
418        history::RedirectList(), content::PAGE_TRANSITION_LINK,
419        history::SOURCE_BROWSED, false);
420  }
421
422 private:
423  // Callback for HistoryService::QueryURL.
424  void SaveResultAndQuit(HistoryService::Handle,
425                         bool success,
426                         const history::URLRow*,
427                         history::VisitVector*) {
428    query_url_success_ = success;
429    await_completion_.Notify();
430  }
431
432  // For History requests.
433  CancelableRequestConsumer consumer_;
434  bool query_url_success_;
435
436  // TestingProfile owns the history service; we shouldn't delete it.
437  HistoryService* history_service_;
438
439  AwaitCompletionHelper await_completion_;
440
441  DISALLOW_COPY_AND_ASSIGN(RemoveHistoryTester);
442};
443
444class RemoveAutofillTester : public autofill::PersonalDataManagerObserver {
445 public:
446  explicit RemoveAutofillTester(TestingProfile* profile)
447      : personal_data_manager_(
448            autofill::PersonalDataManagerFactory::GetForProfile(profile)) {
449        autofill::test::DisableSystemServices(profile);
450    personal_data_manager_->AddObserver(this);
451  }
452
453  virtual ~RemoveAutofillTester() {
454    personal_data_manager_->RemoveObserver(this);
455  }
456
457  // Returns true if there are autofill profiles.
458  bool HasProfile() {
459    return !personal_data_manager_->GetProfiles().empty() &&
460           !personal_data_manager_->GetCreditCards().empty();
461  }
462
463  bool HasOrigin(const std::string& origin) {
464    const std::vector<autofill::AutofillProfile*>& profiles =
465        personal_data_manager_->GetProfiles();
466    for (std::vector<autofill::AutofillProfile*>::const_iterator it =
467             profiles.begin();
468         it != profiles.end(); ++it) {
469      if ((*it)->origin() == origin)
470        return true;
471    }
472
473    const std::vector<autofill::CreditCard*>& credit_cards =
474        personal_data_manager_->GetCreditCards();
475    for (std::vector<autofill::CreditCard*>::const_iterator it =
476             credit_cards.begin();
477         it != credit_cards.end(); ++it) {
478      if ((*it)->origin() == origin)
479        return true;
480    }
481
482    return false;
483  }
484
485  // Add two profiles and two credit cards to the database.  In each pair, one
486  // entry has a web origin and the other has a Chrome origin.
487  void AddProfilesAndCards() {
488    std::vector<autofill::AutofillProfile> profiles;
489    autofill::AutofillProfile profile;
490    profile.set_guid(base::GenerateGUID());
491    profile.set_origin(kWebOrigin);
492    profile.SetRawInfo(autofill::NAME_FIRST, ASCIIToUTF16("Bob"));
493    profile.SetRawInfo(autofill::NAME_LAST, ASCIIToUTF16("Smith"));
494    profile.SetRawInfo(autofill::ADDRESS_HOME_ZIP, ASCIIToUTF16("94043"));
495    profile.SetRawInfo(autofill::EMAIL_ADDRESS,
496                       ASCIIToUTF16("sue@example.com"));
497    profile.SetRawInfo(autofill::COMPANY_NAME, ASCIIToUTF16("Company X"));
498    profiles.push_back(profile);
499
500    profile.set_guid(base::GenerateGUID());
501    profile.set_origin(kChromeOrigin);
502    profiles.push_back(profile);
503
504    personal_data_manager_->SetProfiles(&profiles);
505    base::MessageLoop::current()->Run();
506
507    std::vector<autofill::CreditCard> cards;
508    autofill::CreditCard card;
509    card.set_guid(base::GenerateGUID());
510    card.set_origin(kWebOrigin);
511    card.SetRawInfo(autofill::CREDIT_CARD_NUMBER,
512                    ASCIIToUTF16("1234-5678-9012-3456"));
513    cards.push_back(card);
514
515    card.set_guid(base::GenerateGUID());
516    card.set_origin(kChromeOrigin);
517    cards.push_back(card);
518
519    personal_data_manager_->SetCreditCards(&cards);
520    base::MessageLoop::current()->Run();
521  }
522
523 private:
524  virtual void OnPersonalDataChanged() OVERRIDE {
525    base::MessageLoop::current()->Quit();
526  }
527
528  autofill::PersonalDataManager* personal_data_manager_;
529  DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester);
530};
531
532class RemoveLocalStorageTester {
533 public:
534  explicit RemoveLocalStorageTester(TestingProfile* profile)
535      : profile_(profile), dom_storage_context_(NULL) {
536    dom_storage_context_ =
537        content::BrowserContext::GetDefaultStoragePartition(profile)->
538            GetDOMStorageContext();
539  }
540
541  // Returns true, if the given origin URL exists.
542  bool DOMStorageExistsForOrigin(const GURL& origin) {
543    GetLocalStorageUsage();
544    await_completion_.BlockUntilNotified();
545    for (size_t i = 0; i < infos_.size(); ++i) {
546      if (origin == infos_[i].origin)
547        return true;
548    }
549    return false;
550  }
551
552  void AddDOMStorageTestData() {
553    // Note: This test depends on details of how the dom_storage library
554    // stores data in the host file system.
555    base::FilePath storage_path =
556        profile_->GetPath().AppendASCII("Local Storage");
557    base::CreateDirectory(storage_path);
558
559    // Write some files.
560    file_util::WriteFile(storage_path.Append(kDomStorageOrigin1), NULL, 0);
561    file_util::WriteFile(storage_path.Append(kDomStorageOrigin2), NULL, 0);
562    file_util::WriteFile(storage_path.Append(kDomStorageOrigin3), NULL, 0);
563    file_util::WriteFile(storage_path.Append(kDomStorageExt), NULL, 0);
564
565    // Tweak their dates.
566    base::Time now = base::Time::Now();
567    base::TouchFile(storage_path.Append(kDomStorageOrigin1), now, now);
568
569    base::Time one_day_ago = now - base::TimeDelta::FromDays(1);
570    base::TouchFile(storage_path.Append(kDomStorageOrigin2),
571                    one_day_ago, one_day_ago);
572
573    base::Time sixty_days_ago = now - base::TimeDelta::FromDays(60);
574    base::TouchFile(storage_path.Append(kDomStorageOrigin3),
575                    sixty_days_ago, sixty_days_ago);
576
577    base::TouchFile(storage_path.Append(kDomStorageExt), now, now);
578  }
579
580 private:
581  void GetLocalStorageUsage() {
582    dom_storage_context_->GetLocalStorageUsage(
583        base::Bind(&RemoveLocalStorageTester::OnGotLocalStorageUsage,
584                   base::Unretained(this)));
585  }
586  void OnGotLocalStorageUsage(
587      const std::vector<content::LocalStorageUsageInfo>& infos) {
588    infos_ = infos;
589    await_completion_.Notify();
590  }
591
592  // We don't own these pointers.
593  TestingProfile* profile_;
594  content::DOMStorageContext* dom_storage_context_;
595
596  std::vector<content::LocalStorageUsageInfo> infos_;
597
598  AwaitCompletionHelper await_completion_;
599
600  DISALLOW_COPY_AND_ASSIGN(RemoveLocalStorageTester);
601};
602
603// Test Class ----------------------------------------------------------------
604
605class BrowsingDataRemoverTest : public testing::Test,
606                                public content::NotificationObserver {
607 public:
608  BrowsingDataRemoverTest()
609      : profile_(new TestingProfile()) {
610    registrar_.Add(this, chrome::NOTIFICATION_BROWSING_DATA_REMOVED,
611                   content::Source<Profile>(profile_.get()));
612  }
613
614  virtual ~BrowsingDataRemoverTest() {
615  }
616
617  virtual void TearDown() {
618    // TestingProfile contains a DOMStorageContext.  BrowserContext's destructor
619    // posts a message to the WEBKIT thread to delete some of its member
620    // variables. We need to ensure that the profile is destroyed, and that
621    // the message loop is cleared out, before destroying the threads and loop.
622    // Otherwise we leak memory.
623    profile_.reset();
624    base::MessageLoop::current()->RunUntilIdle();
625  }
626
627  void BlockUntilBrowsingDataRemoved(BrowsingDataRemover::TimePeriod period,
628                                     int remove_mask,
629                                     bool include_protected_origins) {
630    BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
631        profile_.get(), period);
632
633    TestStoragePartition storage_partition;
634    remover->OverrideStoragePartitionForTesting(&storage_partition);
635
636    AwaitCompletionHelper await_completion;
637    remover->AddObserver(&await_completion);
638
639    called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
640
641    // BrowsingDataRemover deletes itself when it completes.
642    int origin_set_mask = BrowsingDataHelper::UNPROTECTED_WEB;
643    if (include_protected_origins)
644      origin_set_mask |= BrowsingDataHelper::PROTECTED_WEB;
645    remover->Remove(remove_mask, origin_set_mask);
646    await_completion.BlockUntilNotified();
647
648    // Save so we can verify later.
649    storage_partition_removal_data_ =
650        storage_partition.GetStoragePartitionRemovalData();
651  }
652
653  void BlockUntilOriginDataRemoved(BrowsingDataRemover::TimePeriod period,
654                                   int remove_mask,
655                                   const GURL& remove_origin) {
656    BrowsingDataRemover* remover = BrowsingDataRemover::CreateForPeriod(
657        profile_.get(), period);
658    TestStoragePartition storage_partition;
659    remover->OverrideStoragePartitionForTesting(&storage_partition);
660
661    AwaitCompletionHelper await_completion;
662    remover->AddObserver(&await_completion);
663
664    called_with_details_.reset(new BrowsingDataRemover::NotificationDetails());
665
666    // BrowsingDataRemover deletes itself when it completes.
667    remover->RemoveImpl(remove_mask, remove_origin,
668        BrowsingDataHelper::UNPROTECTED_WEB);
669    await_completion.BlockUntilNotified();
670
671    // Save so we can verify later.
672    storage_partition_removal_data_ =
673        storage_partition.GetStoragePartitionRemovalData();
674  }
675
676  TestingProfile* GetProfile() {
677    return profile_.get();
678  }
679
680  base::Time GetBeginTime() {
681    return called_with_details_->removal_begin;
682  }
683
684  int GetRemovalMask() {
685    return called_with_details_->removal_mask;
686  }
687
688  int GetOriginSetMask() {
689    return called_with_details_->origin_set_mask;
690  }
691
692  StoragePartitionRemovalData GetStoragePartitionRemovalData() {
693    return storage_partition_removal_data_;
694  }
695
696  // content::NotificationObserver implementation.
697  virtual void Observe(int type,
698                       const content::NotificationSource& source,
699                       const content::NotificationDetails& details) OVERRIDE {
700    DCHECK_EQ(type, chrome::NOTIFICATION_BROWSING_DATA_REMOVED);
701
702    // We're not taking ownership of the details object, but storing a copy of
703    // it locally.
704    called_with_details_.reset(new BrowsingDataRemover::NotificationDetails(
705        *content::Details<BrowsingDataRemover::NotificationDetails>(
706            details).ptr()));
707
708    registrar_.RemoveAll();
709  }
710
711 private:
712  scoped_ptr<BrowsingDataRemover::NotificationDetails> called_with_details_;
713  content::NotificationRegistrar registrar_;
714
715  content::TestBrowserThreadBundle thread_bundle_;
716  scoped_ptr<TestingProfile> profile_;
717
718  StoragePartitionRemovalData storage_partition_removal_data_;
719
720  DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
721};
722
723// Tests ---------------------------------------------------------------------
724
725TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
726  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
727                                BrowsingDataRemover::REMOVE_COOKIES,
728                                false);
729
730  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
731  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
732
733  // Verify that storage partition was instructed to remove the cookies.
734  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
735  EXPECT_EQ(removal_data.remove_mask,
736            static_cast<uint32>(
737                StoragePartition::REMOVE_DATA_MASK_COOKIES));
738  EXPECT_EQ(removal_data.quota_storage_remove_mask,
739            static_cast<uint32>(
740                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
741  EXPECT_TRUE(removal_data.remove_origin.is_empty());
742  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
743}
744
745TEST_F(BrowsingDataRemoverTest, RemoveCookieLastHour) {
746  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
747                                BrowsingDataRemover::REMOVE_COOKIES,
748                                false);
749
750  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
751  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
752
753  // Verify that storage partition was instructed to remove the cookies.
754  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
755  EXPECT_EQ(removal_data.remove_mask,
756            static_cast<uint32>(
757                StoragePartition::REMOVE_DATA_MASK_COOKIES));
758  // Removing with time period other than EVERYTHING should not clear
759  // persistent storage data.
760  EXPECT_EQ(removal_data.quota_storage_remove_mask,
761            static_cast<uint32>(
762                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL &
763                ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT));
764  EXPECT_TRUE(removal_data.remove_origin.is_empty());
765  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
766}
767
768#if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
769TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieForever) {
770  RemoveSafeBrowsingCookieTester tester;
771
772  tester.AddCookie();
773  ASSERT_TRUE(tester.ContainsCookie());
774
775  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
776      BrowsingDataRemover::REMOVE_COOKIES, false);
777
778  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
779  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
780  EXPECT_FALSE(tester.ContainsCookie());
781}
782
783TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieLastHour) {
784  RemoveSafeBrowsingCookieTester tester;
785
786  tester.AddCookie();
787  ASSERT_TRUE(tester.ContainsCookie());
788
789  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
790      BrowsingDataRemover::REMOVE_COOKIES, false);
791
792  EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
793  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
794  // Removing with time period other than EVERYTHING should not clear safe
795  // browsing cookies.
796  EXPECT_TRUE(tester.ContainsCookie());
797}
798#endif
799
800TEST_F(BrowsingDataRemoverTest, RemoveServerBoundCertForever) {
801  RemoveServerBoundCertTester tester(GetProfile());
802
803  tester.AddServerBoundCert(kTestOrigin1);
804  EXPECT_EQ(0, tester.ssl_config_changed_count());
805  EXPECT_EQ(1, tester.ServerBoundCertCount());
806
807  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
808      BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, false);
809
810  EXPECT_EQ(BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, GetRemovalMask());
811  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
812  EXPECT_EQ(1, tester.ssl_config_changed_count());
813  EXPECT_EQ(0, tester.ServerBoundCertCount());
814}
815
816TEST_F(BrowsingDataRemoverTest, RemoveServerBoundCertLastHour) {
817  RemoveServerBoundCertTester tester(GetProfile());
818
819  base::Time now = base::Time::Now();
820  tester.AddServerBoundCert(kTestOrigin1);
821  tester.AddServerBoundCertWithTimes(kTestOrigin2,
822                                     now - base::TimeDelta::FromHours(2),
823                                     now);
824  EXPECT_EQ(0, tester.ssl_config_changed_count());
825  EXPECT_EQ(2, tester.ServerBoundCertCount());
826
827  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
828      BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, false);
829
830  EXPECT_EQ(BrowsingDataRemover::REMOVE_SERVER_BOUND_CERTS, GetRemovalMask());
831  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
832  EXPECT_EQ(1, tester.ssl_config_changed_count());
833  ASSERT_EQ(1, tester.ServerBoundCertCount());
834  net::ServerBoundCertStore::ServerBoundCertList certs;
835  tester.GetCertList(&certs);
836  ASSERT_EQ(1U, certs.size());
837  EXPECT_EQ(kTestOrigin2, certs.front().server_identifier());
838}
839
840TEST_F(BrowsingDataRemoverTest, RemoveUnprotectedLocalStorageForever) {
841  // Protect kOrigin1.
842  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
843      new MockExtensionSpecialStoragePolicy;
844  mock_policy->AddProtected(kOrigin1.GetOrigin());
845  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
846
847  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
848                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
849                                false);
850
851  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
852  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
853
854  // Verify that storage partition was instructed to remove the data correctly.
855  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
856  EXPECT_EQ(removal_data.remove_mask,
857            static_cast<uint32>(
858                StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE));
859  EXPECT_EQ(removal_data.quota_storage_remove_mask,
860            static_cast<uint32>(
861                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
862  EXPECT_TRUE(removal_data.remove_origin.is_empty());
863  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
864
865  // Check origin matcher.
866  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
867  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
868  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
869  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy));
870}
871
872TEST_F(BrowsingDataRemoverTest, RemoveProtectedLocalStorageForever) {
873  // Protect kOrigin1.
874  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
875      new MockExtensionSpecialStoragePolicy;
876  mock_policy->AddProtected(kOrigin1.GetOrigin());
877  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
878
879  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
880                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
881                                true);
882
883  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
884  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB |
885            BrowsingDataHelper::PROTECTED_WEB, GetOriginSetMask());
886
887  // Verify that storage partition was instructed to remove the data correctly.
888  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
889  EXPECT_EQ(removal_data.remove_mask,
890            static_cast<uint32>(
891                StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE));
892  EXPECT_EQ(removal_data.quota_storage_remove_mask,
893            static_cast<uint32>(
894                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
895  EXPECT_TRUE(removal_data.remove_origin.is_empty());
896  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
897
898  // Check origin matcher all http origin will match since we specified
899  // both protected and unprotected.
900  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
901  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
902  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
903  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy));
904}
905
906TEST_F(BrowsingDataRemoverTest, RemoveLocalStorageForLastWeek) {
907  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
908      new MockExtensionSpecialStoragePolicy;
909  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
910
911  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
912                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
913                                false);
914
915  EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
916  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
917
918  // Verify that storage partition was instructed to remove the data correctly.
919  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
920  EXPECT_EQ(removal_data.remove_mask,
921            static_cast<uint32>(
922                StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE));
923  // Persistent storage won't be deleted.
924  EXPECT_EQ(removal_data.quota_storage_remove_mask,
925            static_cast<uint32>(
926                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL &
927                ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT));
928  EXPECT_TRUE(removal_data.remove_origin.is_empty());
929  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
930
931  // Check origin matcher.
932  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
933  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
934  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
935  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy));
936}
937
938TEST_F(BrowsingDataRemoverTest, RemoveHistoryForever) {
939  RemoveHistoryTester tester;
940  ASSERT_TRUE(tester.Init(GetProfile()));
941
942  tester.AddHistory(kOrigin1, base::Time::Now());
943  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
944
945  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
946      BrowsingDataRemover::REMOVE_HISTORY, false);
947
948  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
949  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
950  EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
951}
952
953TEST_F(BrowsingDataRemoverTest, RemoveHistoryForLastHour) {
954  RemoveHistoryTester tester;
955  ASSERT_TRUE(tester.Init(GetProfile()));
956
957  base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
958
959  tester.AddHistory(kOrigin1, base::Time::Now());
960  tester.AddHistory(kOrigin2, two_hours_ago);
961  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
962  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
963
964  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
965      BrowsingDataRemover::REMOVE_HISTORY, false);
966
967  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
968  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
969  EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
970  EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
971}
972
973// This should crash (DCHECK) in Debug, but death tests don't work properly
974// here.
975#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
976TEST_F(BrowsingDataRemoverTest, RemoveHistoryProhibited) {
977  RemoveHistoryTester tester;
978  ASSERT_TRUE(tester.Init(GetProfile()));
979  PrefService* prefs = GetProfile()->GetPrefs();
980  prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
981
982  base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
983
984  tester.AddHistory(kOrigin1, base::Time::Now());
985  tester.AddHistory(kOrigin2, two_hours_ago);
986  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
987  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
988
989  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
990      BrowsingDataRemover::REMOVE_HISTORY, false);
991  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
992  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
993
994  // Nothing should have been deleted.
995  EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1));
996  EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
997}
998#endif
999
1000TEST_F(BrowsingDataRemoverTest, RemoveMultipleTypes) {
1001  // Add some history.
1002  RemoveHistoryTester history_tester;
1003  ASSERT_TRUE(history_tester.Init(GetProfile()));
1004  history_tester.AddHistory(kOrigin1, base::Time::Now());
1005  ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
1006
1007  int removal_mask = BrowsingDataRemover::REMOVE_HISTORY |
1008                     BrowsingDataRemover::REMOVE_COOKIES;
1009
1010  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1011      removal_mask, false);
1012
1013  EXPECT_EQ(removal_mask, GetRemovalMask());
1014  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1015  EXPECT_FALSE(history_tester.HistoryContainsURL(kOrigin1));
1016
1017  // The cookie would be deleted throught the StorageParition, check if the
1018  // partition was requested to remove cookie.
1019  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1020  EXPECT_EQ(removal_data.remove_mask,
1021            static_cast<uint32>(
1022                StoragePartition::REMOVE_DATA_MASK_COOKIES));
1023  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1024            static_cast<uint32>(
1025                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1026}
1027
1028// This should crash (DCHECK) in Debug, but death tests don't work properly
1029// here.
1030#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
1031TEST_F(BrowsingDataRemoverTest, RemoveMultipleTypesHistoryProhibited) {
1032  PrefService* prefs = GetProfile()->GetPrefs();
1033  prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
1034
1035  // Add some history.
1036  RemoveHistoryTester history_tester;
1037  ASSERT_TRUE(history_tester.Init(GetProfile()));
1038  history_tester.AddHistory(kOrigin1, base::Time::Now());
1039  ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
1040
1041  int removal_mask = BrowsingDataRemover::REMOVE_HISTORY |
1042                     BrowsingDataRemover::REMOVE_COOKIES;
1043
1044  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
1045                                removal_mask, false);
1046  EXPECT_EQ(removal_mask, GetRemovalMask());
1047  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1048
1049  // 1/2. History should remain.
1050  EXPECT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
1051
1052  // 2/2. The cookie(s) would be deleted throught the StorageParition, check if
1053  // the partition was requested to remove cookie.
1054  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1055  EXPECT_EQ(removal_data.remove_mask,
1056            static_cast<uint32>(
1057                StoragePartition::REMOVE_DATA_MASK_COOKIES));
1058  // Persistent storage won't be deleted, since EVERYTHING was not specified.
1059  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1060            static_cast<uint32>(
1061                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL &
1062                ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT));
1063}
1064#endif
1065
1066TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverBoth) {
1067  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1068                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1069                                BrowsingDataRemover::REMOVE_WEBSQL |
1070                                BrowsingDataRemover::REMOVE_APPCACHE |
1071                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1072                                false);
1073
1074  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1075      BrowsingDataRemover::REMOVE_WEBSQL |
1076      BrowsingDataRemover::REMOVE_APPCACHE |
1077      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1078  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1079
1080  // Verify storage partition related stuffs.
1081  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1082  EXPECT_EQ(removal_data.remove_mask,
1083            static_cast<uint32>(
1084                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1085                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1086                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1087                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1088  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1089            static_cast<uint32>(
1090                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1091  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1092}
1093
1094TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyTemporary) {
1095  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1096      new MockExtensionSpecialStoragePolicy;
1097  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1098
1099  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1100                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1101                                BrowsingDataRemover::REMOVE_WEBSQL |
1102                                BrowsingDataRemover::REMOVE_APPCACHE |
1103                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1104                                false);
1105
1106  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1107      BrowsingDataRemover::REMOVE_WEBSQL |
1108      BrowsingDataRemover::REMOVE_APPCACHE |
1109      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1110  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1111
1112  // Verify storage partition related stuffs.
1113  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1114
1115  EXPECT_EQ(removal_data.remove_mask,
1116            static_cast<uint32>(
1117                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1118                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1119                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1120                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1121  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1122            static_cast<uint32>(
1123                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1124  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1125
1126  // Check that all related origin data would be removed, that is, origin
1127  // matcher would match these origin.
1128  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
1129  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
1130  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
1131}
1132
1133TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyPersistent) {
1134  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1135      new MockExtensionSpecialStoragePolicy;
1136  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1137
1138  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1139                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1140                                BrowsingDataRemover::REMOVE_WEBSQL |
1141                                BrowsingDataRemover::REMOVE_APPCACHE |
1142                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1143                                false);
1144
1145  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1146      BrowsingDataRemover::REMOVE_WEBSQL |
1147      BrowsingDataRemover::REMOVE_APPCACHE |
1148      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1149  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1150
1151  // Verify storage partition related stuffs.
1152  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1153
1154  EXPECT_EQ(removal_data.remove_mask,
1155            static_cast<uint32>(
1156                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1157                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1158                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1159                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1160  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1161            static_cast<uint32>(
1162                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1163  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1164
1165  // Check that all related origin data would be removed, that is, origin
1166  // matcher would match these origin.
1167  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
1168  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
1169  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
1170}
1171
1172TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverNeither) {
1173  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1174      new MockExtensionSpecialStoragePolicy;
1175  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1176
1177
1178  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1179                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1180                                BrowsingDataRemover::REMOVE_WEBSQL |
1181                                BrowsingDataRemover::REMOVE_APPCACHE |
1182                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1183                                false);
1184
1185  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1186      BrowsingDataRemover::REMOVE_WEBSQL |
1187      BrowsingDataRemover::REMOVE_APPCACHE |
1188      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1189  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1190
1191  // Verify storage partition related stuffs.
1192  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1193
1194  EXPECT_EQ(removal_data.remove_mask,
1195            static_cast<uint32>(
1196                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1197                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1198                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1199                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1200  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1201            static_cast<uint32>(
1202                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1203  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1204
1205  // Check that all related origin data would be removed, that is, origin
1206  // matcher would match these origin.
1207  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
1208  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
1209  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
1210}
1211
1212TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverSpecificOrigin) {
1213  // Remove Origin 1.
1214  BlockUntilOriginDataRemoved(BrowsingDataRemover::EVERYTHING,
1215                              BrowsingDataRemover::REMOVE_APPCACHE |
1216                              BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1217                              BrowsingDataRemover::REMOVE_INDEXEDDB |
1218                              BrowsingDataRemover::REMOVE_WEBSQL,
1219                              kOrigin1);
1220
1221  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
1222      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1223      BrowsingDataRemover::REMOVE_INDEXEDDB |
1224      BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
1225  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1226
1227  // Verify storage partition related stuffs.
1228  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1229
1230  EXPECT_EQ(removal_data.remove_mask,
1231            static_cast<uint32>(
1232                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1233                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1234                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1235                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1236  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1237            static_cast<uint32>(
1238                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1239  EXPECT_EQ(removal_data.remove_origin, kOrigin1);
1240}
1241
1242TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastHour) {
1243  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
1244                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1245                                BrowsingDataRemover::REMOVE_WEBSQL |
1246                                BrowsingDataRemover::REMOVE_APPCACHE |
1247                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1248                                false);
1249
1250  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1251      BrowsingDataRemover::REMOVE_WEBSQL |
1252      BrowsingDataRemover::REMOVE_APPCACHE |
1253      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1254  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1255
1256  // Verify storage partition related stuffs.
1257  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1258
1259  EXPECT_EQ(removal_data.remove_mask,
1260            static_cast<uint32>(
1261                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1262                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1263                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1264                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1265
1266  // Persistent data would be left out since we are not removing from
1267  // beginning of time.
1268  uint32 expected_quota_mask =
1269      ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
1270  EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
1271  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1272  // Check removal begin time.
1273  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
1274}
1275
1276TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastWeek) {
1277  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
1278                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1279                                BrowsingDataRemover::REMOVE_WEBSQL |
1280                                BrowsingDataRemover::REMOVE_APPCACHE |
1281                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1282                                false);
1283
1284  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1285      BrowsingDataRemover::REMOVE_WEBSQL |
1286      BrowsingDataRemover::REMOVE_APPCACHE |
1287      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1288  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1289
1290  // Verify storage partition related stuffs.
1291  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1292
1293  EXPECT_EQ(removal_data.remove_mask,
1294            static_cast<uint32>(
1295                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1296                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1297                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1298                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1299
1300  // Persistent data would be left out since we are not removing from
1301  // beginning of time.
1302  uint32 expected_quota_mask =
1303      ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
1304  EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
1305  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1306  // Check removal begin time.
1307  EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
1308}
1309
1310TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedUnprotectedOrigins) {
1311  // Protect kOrigin1.
1312  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1313      new MockExtensionSpecialStoragePolicy;
1314  mock_policy->AddProtected(kOrigin1.GetOrigin());
1315  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1316
1317  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1318                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1319                                BrowsingDataRemover::REMOVE_WEBSQL |
1320                                BrowsingDataRemover::REMOVE_APPCACHE |
1321                                BrowsingDataRemover::REMOVE_INDEXEDDB,
1322                                false);
1323
1324  EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1325      BrowsingDataRemover::REMOVE_WEBSQL |
1326      BrowsingDataRemover::REMOVE_APPCACHE |
1327      BrowsingDataRemover::REMOVE_INDEXEDDB, GetRemovalMask());
1328  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1329
1330  // Verify storage partition related stuffs.
1331  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1332
1333  EXPECT_EQ(removal_data.remove_mask,
1334            static_cast<uint32>(
1335                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1336                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1337                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1338                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1339  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1340            static_cast<uint32>(
1341                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1342  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1343
1344  // Check OriginMatcherFunction, |kOrigin1| would not match mask since it
1345  // is protected.
1346  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
1347  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
1348  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
1349}
1350
1351TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedSpecificOrigin) {
1352  // Protect kOrigin1.
1353  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1354      new MockExtensionSpecialStoragePolicy;
1355  mock_policy->AddProtected(kOrigin1.GetOrigin());
1356  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1357
1358  // Try to remove kOrigin1. Expect failure.
1359  BlockUntilOriginDataRemoved(BrowsingDataRemover::EVERYTHING,
1360                              BrowsingDataRemover::REMOVE_APPCACHE |
1361                              BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1362                              BrowsingDataRemover::REMOVE_INDEXEDDB |
1363                              BrowsingDataRemover::REMOVE_WEBSQL,
1364                              kOrigin1);
1365
1366  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
1367      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1368      BrowsingDataRemover::REMOVE_INDEXEDDB |
1369      BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
1370  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1371
1372  // Verify storage partition related stuffs.
1373  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1374
1375  EXPECT_EQ(removal_data.remove_mask,
1376            static_cast<uint32>(
1377                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1378                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1379                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1380                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1381  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1382            static_cast<uint32>(
1383                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1384  EXPECT_EQ(removal_data.remove_origin, kOrigin1);
1385
1386  // Check OriginMatcherFunction, |kOrigin1| would not match mask since it
1387  // is protected.
1388  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
1389  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
1390  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
1391}
1392
1393TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedOrigins) {
1394  // Protect kOrigin1.
1395  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1396      new MockExtensionSpecialStoragePolicy;
1397  mock_policy->AddProtected(kOrigin1.GetOrigin());
1398  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1399
1400  // Try to remove kOrigin1. Expect success.
1401  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1402                                BrowsingDataRemover::REMOVE_APPCACHE |
1403                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1404                                BrowsingDataRemover::REMOVE_INDEXEDDB |
1405                                BrowsingDataRemover::REMOVE_WEBSQL,
1406                                true);
1407
1408  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
1409      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1410      BrowsingDataRemover::REMOVE_INDEXEDDB |
1411      BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
1412  EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB |
1413      BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1414
1415  // Verify storage partition related stuffs.
1416  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1417
1418  EXPECT_EQ(removal_data.remove_mask,
1419            static_cast<uint32>(
1420                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1421                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1422                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1423                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1424  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1425            static_cast<uint32>(
1426                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1427  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1428
1429  // Check OriginMatcherFunction, |kOrigin1| would match mask since we
1430  // would have 'protected' specified in origin_set_mask.
1431  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy));
1432  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy));
1433  EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy));
1434}
1435
1436TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedIgnoreExtensionsAndDevTools) {
1437  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
1438      new MockExtensionSpecialStoragePolicy;
1439  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy.get());
1440
1441  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
1442                                BrowsingDataRemover::REMOVE_APPCACHE |
1443                                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1444                                BrowsingDataRemover::REMOVE_INDEXEDDB |
1445                                BrowsingDataRemover::REMOVE_WEBSQL,
1446                                false);
1447
1448  EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
1449      BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
1450      BrowsingDataRemover::REMOVE_INDEXEDDB |
1451      BrowsingDataRemover::REMOVE_WEBSQL, GetRemovalMask());
1452  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1453
1454  // Verify storage partition related stuffs.
1455  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
1456
1457  EXPECT_EQ(removal_data.remove_mask,
1458            static_cast<uint32>(
1459                StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
1460                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
1461                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
1462                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB));
1463  EXPECT_EQ(removal_data.quota_storage_remove_mask,
1464            static_cast<uint32>(
1465                StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL));
1466  EXPECT_TRUE(removal_data.remove_origin.is_empty());
1467
1468  // Check that extension and devtools data wouldn't be removed, that is,
1469  // origin matcher would not match these origin.
1470  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy));
1471  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginDevTools, mock_policy));
1472}
1473
1474TEST_F(BrowsingDataRemoverTest, OriginBasedHistoryRemoval) {
1475  RemoveHistoryTester tester;
1476  ASSERT_TRUE(tester.Init(GetProfile()));
1477
1478  base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
1479
1480  tester.AddHistory(kOrigin1, base::Time::Now());
1481  tester.AddHistory(kOrigin2, two_hours_ago);
1482  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
1483  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
1484
1485  BlockUntilOriginDataRemoved(BrowsingDataRemover::EVERYTHING,
1486      BrowsingDataRemover::REMOVE_HISTORY, kOrigin2);
1487
1488  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
1489  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1490
1491  // Nothing should have been deleted.
1492  EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1));
1493  EXPECT_FALSE(tester.HistoryContainsURL(kOrigin2));
1494}
1495
1496TEST_F(BrowsingDataRemoverTest, OriginAndTimeBasedHistoryRemoval) {
1497  RemoveHistoryTester tester;
1498  ASSERT_TRUE(tester.Init(GetProfile()));
1499
1500  base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
1501
1502  tester.AddHistory(kOrigin1, base::Time::Now());
1503  tester.AddHistory(kOrigin2, two_hours_ago);
1504  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
1505  ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
1506
1507  BlockUntilOriginDataRemoved(BrowsingDataRemover::LAST_HOUR,
1508      BrowsingDataRemover::REMOVE_HISTORY, kOrigin2);
1509
1510  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
1511  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1512  EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1));
1513  EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
1514}
1515
1516// Verify that clearing autofill form data works.
1517TEST_F(BrowsingDataRemoverTest, AutofillRemovalLastHour) {
1518  GetProfile()->CreateWebDataService();
1519  RemoveAutofillTester tester(GetProfile());
1520
1521  ASSERT_FALSE(tester.HasProfile());
1522  tester.AddProfilesAndCards();
1523  ASSERT_TRUE(tester.HasProfile());
1524
1525  BlockUntilBrowsingDataRemoved(
1526      BrowsingDataRemover::LAST_HOUR,
1527      BrowsingDataRemover::REMOVE_FORM_DATA, false);
1528
1529  EXPECT_EQ(BrowsingDataRemover::REMOVE_FORM_DATA, GetRemovalMask());
1530  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1531  ASSERT_FALSE(tester.HasProfile());
1532}
1533
1534TEST_F(BrowsingDataRemoverTest, AutofillRemovalEverything) {
1535  GetProfile()->CreateWebDataService();
1536  RemoveAutofillTester tester(GetProfile());
1537
1538  ASSERT_FALSE(tester.HasProfile());
1539  tester.AddProfilesAndCards();
1540  ASSERT_TRUE(tester.HasProfile());
1541
1542  BlockUntilBrowsingDataRemoved(
1543      BrowsingDataRemover::EVERYTHING,
1544      BrowsingDataRemover::REMOVE_FORM_DATA, false);
1545
1546  EXPECT_EQ(BrowsingDataRemover::REMOVE_FORM_DATA, GetRemovalMask());
1547  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1548  ASSERT_FALSE(tester.HasProfile());
1549}
1550
1551// Verify that clearing autofill form data works.
1552TEST_F(BrowsingDataRemoverTest, AutofillOriginsRemovedWithHistory) {
1553  GetProfile()->CreateWebDataService();
1554  RemoveAutofillTester tester(GetProfile());
1555
1556  tester.AddProfilesAndCards();
1557  EXPECT_FALSE(tester.HasOrigin(std::string()));
1558  EXPECT_TRUE(tester.HasOrigin(kWebOrigin));
1559  EXPECT_TRUE(tester.HasOrigin(kChromeOrigin));
1560
1561  BlockUntilBrowsingDataRemoved(
1562      BrowsingDataRemover::LAST_HOUR,
1563      BrowsingDataRemover::REMOVE_HISTORY, false);
1564
1565  EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
1566  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginSetMask());
1567  EXPECT_TRUE(tester.HasOrigin(std::string()));
1568  EXPECT_FALSE(tester.HasOrigin(kWebOrigin));
1569  EXPECT_TRUE(tester.HasOrigin(kChromeOrigin));
1570}
1571
1572#if defined(OS_CHROMEOS)
1573TEST_F(BrowsingDataRemoverTest, ContentProtectionPlatformKeysRemoval) {
1574  chromeos::ScopedTestDeviceSettingsService test_device_settings_service;
1575  chromeos::ScopedTestCrosSettings test_cros_settings;
1576  chromeos::MockUserManager* mock_user_manager =
1577      new testing::NiceMock<chromeos::MockUserManager>();
1578  mock_user_manager->SetActiveUser("test@example.com");
1579  chromeos::ScopedUserManagerEnabler user_manager_enabler(mock_user_manager);
1580
1581  chromeos::FakeDBusThreadManager* fake_dbus_manager =
1582      new chromeos::FakeDBusThreadManager;
1583  chromeos::MockCryptohomeClient* cryptohome_client =
1584      new chromeos::MockCryptohomeClient;
1585  fake_dbus_manager->SetCryptohomeClient(
1586      scoped_ptr<chromeos::CryptohomeClient>(cryptohome_client));
1587  chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_manager);
1588
1589  // Expect exactly one call.  No calls means no attempt to delete keys and more
1590  // than one call means a significant performance problem.
1591  EXPECT_CALL(*cryptohome_client, TpmAttestationDeleteKeys(_, _, _, _))
1592      .WillOnce(WithArgs<3>(Invoke(FakeDBusCall)));
1593
1594  BlockUntilBrowsingDataRemoved(
1595      BrowsingDataRemover::EVERYTHING,
1596      BrowsingDataRemover::REMOVE_CONTENT_LICENSES, false);
1597
1598  chromeos::DBusThreadManager::Shutdown();
1599}
1600#endif
1601