Implement origin-based deletion for the domain reliability service.

chrome/browser/browsing_data/browsing_data_remover_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 331 matching lines @@
       const base::Callback<bool(const GURL&)>& filter)
       : to_match_(filter) {
   }
 
   virtual bool MatchAndExplain(const base::Callback<bool(const GURL&)>& filter,
                                MatchResultListener* listener) const {
     const GURL urls_to_test_[] =
         {kOrigin1, kOrigin2, kOrigin3, GURL("invalid spec")};
     for (GURL url : urls_to_test_) {
       if (filter.Run(url) != to_match_.Run(url)) {
-        *listener << "The filters differ on the URL " << url;
+        if (listener)
+          *listener << "The filters differ on the URL " << url;
         return false;
       }
     }
     return true;
   }
 
   virtual void DescribeTo(::std::ostream* os) const {
     *os << "is probably the same url filter as " << &to_match_;
   }
 
   virtual void DescribeNegationTo(::std::ostream* os) const {
     *os << "is definitely NOT the same url filter as " << &to_match_;
   }
 
  private:
   const base::Callback<bool(const GURL&)>& to_match_;
 };
 
 inline Matcher<const base::Callback<bool(const GURL&)>&> ProbablySameFilter(
     const base::Callback<bool(const GURL&)>& filter) {
   return MakeMatcher(new ProbablySameFilterMatcher(filter));
 }
 
+bool ProbablySameFilters(
+    const base::Callback<bool(const GURL&)>& filter1,
+    const base::Callback<bool(const GURL&)>& filter2) {
+  return ProbablySameFilter(filter1).MatchAndExplain(filter2, nullptr);
+}
+
 }  // namespace
 
 // Testers -------------------------------------------------------------------
 
 class RemoveCookieTester {
  public:
   RemoveCookieTester() {}
 
   // Returns true, if the given cookie exists in the cookie store.
   bool ContainsCookie() {
@@ skipping 454 matching lines @@
 
   ~MockDomainReliabilityService() override {}
 
   std::unique_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
       override {
     NOTREACHED();
     return std::unique_ptr<DomainReliabilityMonitor>();
   }
 
-  void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
-                         const base::Closure& callback) override {
+  void ClearBrowsingData(
+      DomainReliabilityClearMode clear_mode,
+      const base::Callback<bool(const GURL&)>& origin_filter,
+      const base::Closure& callback) override {
     clear_count_++;
     last_clear_mode_ = clear_mode;
+    last_filter_ = origin_filter;
     callback.Run();
   }
 
   void GetWebUIData(const base::Callback<void(std::unique_ptr<base::Value>)>&
                         callback) const override {
     NOTREACHED();
   }
 
   int clear_count() const { return clear_count_; }
 
   DomainReliabilityClearMode last_clear_mode() const {
     return last_clear_mode_;
   }
 
+  const base::Callback<bool(const GURL&)>& last_filter() const {
+    return last_filter_;
+  }
+
  private:
   unsigned clear_count_ = 0;
   DomainReliabilityClearMode last_clear_mode_;
+  base::Callback<bool(const GURL&)> last_filter_;
 };
 
 struct TestingDomainReliabilityServiceFactoryUserData
     : public base::SupportsUserData::Data {
   TestingDomainReliabilityServiceFactoryUserData(
       content::BrowserContext* context,
       MockDomainReliabilityService* service)
       : context(context),
         service(service),
         attached(false) {}
@@ skipping 32 matching lines @@
       mock_service_(new MockDomainReliabilityService()) {
     AttachService();
   }
 
   unsigned clear_count() const { return mock_service_->clear_count(); }
 
   DomainReliabilityClearMode last_clear_mode() const {
     return mock_service_->last_clear_mode();
   }
 
+  const base::Callback<bool(const GURL&)>& last_filter() const {
+    return mock_service_->last_filter();
+  }
+
  private:
   void AttachService() {
     const void* kKey = TestingDomainReliabilityServiceFactoryUserData::kKey;
 
     // Attach kludgey UserData struct to profile.
     TestingDomainReliabilityServiceFactoryUserData* data =
         new TestingDomainReliabilityServiceFactoryUserData(profile_,
                                                            mock_service_);
     EXPECT_FALSE(profile_->GetUserData(kKey));
     profile_->SetUserData(kKey, data);
@@ skipping 1334 matching lines @@
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Beacons) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(browsing_data::EVERYTHING,
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
+  EXPECT_TRUE(ProbablySameFilters(
+      BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
+}
+
+TEST_F(BrowsingDataRemoverTest, DomainReliability_Beacons_WithFilter) {
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
+
+  RegistrableDomainFilterBuilder builder(
+      RegistrableDomainFilterBuilder::WHITELIST);
+  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+
+  BlockUntilOriginDataRemoved(browsing_data::EVERYTHING,
+                              BrowsingDataRemover::REMOVE_HISTORY, builder);
+  EXPECT_EQ(1u, tester.clear_count());
+  EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
+  EXPECT_TRUE(ProbablySameFilters(
+      builder.BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Contexts) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(browsing_data::EVERYTHING,
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
+  EXPECT_TRUE(ProbablySameFilters(
+      BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
+}
+
+TEST_F(BrowsingDataRemoverTest, DomainReliability_Contexts_WithFilter) {
+  const ClearDomainReliabilityTester& tester =
+      clear_domain_reliability_tester();
+
+  RegistrableDomainFilterBuilder builder(
+      RegistrableDomainFilterBuilder::WHITELIST);
+  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+
+  BlockUntilOriginDataRemoved(browsing_data::EVERYTHING,
+                              BrowsingDataRemover::REMOVE_COOKIES, builder);
+  EXPECT_EQ(1u, tester.clear_count());
+  EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
+  EXPECT_TRUE(ProbablySameFilters(
+      builder.BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_ContextsWin) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
       browsing_data::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY | BrowsingDataRemover::REMOVE_COOKIES,
       false);
@@ skipping 231 matching lines @@
   BrowsingDataRemover::ClearSettingsForOneTypeWithPredicate(
       host_content_settings_map, CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
       base::Bind(&MatchPrimaryPattern, http_pattern));
   // Verify we only have one, and it's url1.
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), &host_settings);
   EXPECT_EQ(1u, host_settings.size());
   EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(url1),
             host_settings[0].primary_pattern);
 }