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