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