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