Implement origin-based deletion for the domain reliability service.

BUG=589586

Review-Url: https://codereview.chromium.org/2132563003
Cr-Commit-Position: refs/heads/master@{#406025}

chrome/browser/browsing_data/browsing_data_remover.cc

@@ -1001,6 +1001,7 @@ void BrowsingDataRemover::RemoveImpl(
       waiting_for_clear_domain_reliability_monitor_ = true;
       service->ClearBrowsingData(
           mode,
+          filter,
           base::Bind(&BrowsingDataRemover::OnClearedDomainReliabilityMonitor,
                      weak_ptr_factory_.GetWeakPtr()));
     }

chrome/browser/browsing_data/browsing_data_remover_unittest.cc

@@ -349,7 +349,8 @@ class ProbablySameFilterMatcher
         {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;
       }
     }
@@ -373,6 +374,12 @@ inline Matcher<const base::Callback<bool(const GURL&)>&> ProbablySameFilter(
   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 -------------------------------------------------------------------
@@ -847,10 +854,13 @@ class MockDomainReliabilityService : public DomainReliabilityService {
     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();
   }
 
@@ -865,9 +875,14 @@ class MockDomainReliabilityService : public DomainReliabilityService {
     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
@@ -920,6 +935,10 @@ class ClearDomainReliabilityTester {
     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;
@@ -2274,6 +2293,24 @@ TEST_F(BrowsingDataRemoverTest, DomainReliability_Beacons) {
                                 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) {
@@ -2284,6 +2321,24 @@ TEST_F(BrowsingDataRemoverTest, DomainReliability_Contexts) {
                                 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) {

components/domain_reliability/context_manager.cc

@@ -14,7 +14,8 @@ DomainReliabilityContextManager::DomainReliabilityContextManager(
 }
 
 DomainReliabilityContextManager::~DomainReliabilityContextManager() {
-  RemoveAllContexts();
+  RemoveContexts(
+      base::Callback<bool(const GURL&)>() /* no filter - delete everything */);
 }
 
 void DomainReliabilityContextManager::RouteBeacon(
@@ -69,9 +70,14 @@ void DomainReliabilityContextManager::ClearConfig(const GURL& origin) {
   }
 }
 
-void DomainReliabilityContextManager::ClearBeaconsInAllContexts() {
-  for (auto& context_entry : contexts_)
-    context_entry.second->ClearBeacons();
+void DomainReliabilityContextManager::ClearBeacons(
+    const base::Callback<bool(const GURL&)>& origin_filter) {
+  for (auto& context_entry : contexts_) {
+    if (origin_filter.is_null() ||
+        origin_filter.Run(context_entry.second->config().origin)) {
+      context_entry.second->ClearBeacons();
+    }
+  }
 }
 
 DomainReliabilityContext* DomainReliabilityContextManager::AddContextForConfig(
@@ -89,10 +95,18 @@ DomainReliabilityContext* DomainReliabilityContextManager::AddContextForConfig(
   return *entry;
 }
 
-void DomainReliabilityContextManager::RemoveAllContexts() {
-  STLDeleteContainerPairSecondPointers(
-      contexts_.begin(), contexts_.end());
-  contexts_.clear();
+void DomainReliabilityContextManager::RemoveContexts(
+    const base::Callback<bool(const GURL&)>& origin_filter) {
+  for (ContextMap::iterator it = contexts_.begin(); it != contexts_.end(); ) {
+    if (!origin_filter.is_null() &&
+        !origin_filter.Run(it->second->config().origin)) {
+      ++it;
+      continue;
+    }
+
+    delete it->second;
+    it = contexts_.erase(it);
+  }
 }
 
 std::unique_ptr<base::Value> DomainReliabilityContextManager::GetWebUIData()

components/domain_reliability/context_manager.h

@@ -37,9 +37,11 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityContextManager {
                  base::TimeDelta max_age);
   void ClearConfig(const GURL& origin);
 
-  // Calls |ClearBeacons| on all contexts added to this manager, but leaves
-  // the contexts themselves intact.
-  void ClearBeaconsInAllContexts();
+  // Calls |ClearBeacons| on all contexts matched by |origin_filter| added
+  // to this manager, but leaves the contexts themselves intact. A null
+  // |origin_filter| is interpreted as an always-true filter, indicating
+  // complete deletion.
+  void ClearBeacons(const base::Callback<bool(const GURL&)>& origin_filter);
 
   // TODO(juliatuttle): Once unit tests test ContextManager directly, they can
   // use a custom Context::Factory to get the created Context, and this can be
@@ -47,9 +49,10 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityContextManager {
   DomainReliabilityContext* AddContextForConfig(
       std::unique_ptr<const DomainReliabilityConfig> config);
 
-  // Removes all contexts from this manager (discarding all queued beacons in
-  // the process).
-  void RemoveAllContexts();
+  // Removes all contexts matched by |origin_filter| from this manager
+  // (discarding all queued beacons in the process). A null |origin_filter|
+  // is interpreted as an always-true filter, indicating complete deletion.
+  void RemoveContexts(const base::Callback<bool(const GURL&)>& origin_filter);
 
   std::unique_ptr<base::Value> GetWebUIData() const;
 

components/domain_reliability/monitor.cc

@@ -217,15 +217,16 @@ void DomainReliabilityMonitor::OnNetworkChanged(
 }
 
 void DomainReliabilityMonitor::ClearBrowsingData(
-   DomainReliabilityClearMode mode) {
+   DomainReliabilityClearMode mode,
+   const base::Callback<bool(const GURL&)>& origin_filter) {
   DCHECK(OnNetworkThread());
 
   switch (mode) {
     case CLEAR_BEACONS:
-      context_manager_.ClearBeaconsInAllContexts();
+      context_manager_.ClearBeacons(origin_filter);
       break;
     case CLEAR_CONTEXTS:
-      context_manager_.RemoveAllContexts();
+      context_manager_.RemoveContexts(origin_filter);
       break;
     case MAX_CLEAR_MODE:
       NOTREACHED();

components/domain_reliability/monitor.h

@@ -111,10 +111,14 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
   void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) override;
 
-  // Called to remove browsing data. With CLEAR_BEACONS, leaves contexts in
-  // place but clears beacons (which betray browsing history); with
-  // CLEAR_CONTEXTS, removes all contexts (which can behave as cookies).
-  void ClearBrowsingData(DomainReliabilityClearMode mode);
+  // Called to remove browsing data for origins matched by |origin_filter|.
+  // With CLEAR_BEACONS, leaves contexts in place but clears beacons (which
+  // betray browsing history); with CLEAR_CONTEXTS, removes entire contexts
+  // (which can behave as cookies). A null |origin_filter| is interpreted
+  // as an always-true filter, indicating complete deletion.
+  void ClearBrowsingData(
+      DomainReliabilityClearMode mode,
+      const base::Callback<bool(const GURL&)>& origin_filter);
 
   // Gets a Value containing data that can be formatted into a web page for
   // debugging purposes.

components/domain_reliability/monitor_unittest.cc

@@ -295,25 +295,78 @@ TEST_F(DomainReliabilityMonitorTest, ClearBeacons) {
   // Make sure it was added.
   EXPECT_EQ(1u, CountQueuedBeacons(context));
 
-  monitor_.ClearBrowsingData(CLEAR_BEACONS);
+  monitor_.ClearBrowsingData(
+      CLEAR_BEACONS, base::Callback<bool(const GURL&)>());
 
   // Make sure the beacon was cleared, but not the contexts.
   EXPECT_EQ(1u, monitor_.contexts_size_for_testing());
   EXPECT_EQ(0u, CountQueuedBeacons(context));
 }
 
+TEST_F(DomainReliabilityMonitorTest, ClearBeaconsWithFilter) {
+  // Create two contexts, each with one beacon.
+  GURL origin1("http://example.com/");
+  GURL origin2("http://example.org/");
+
+  DomainReliabilityContext* context1 =
+      CreateAndAddContextForOrigin(origin1, false);
+  RequestInfo request = MakeRequestInfo();
+  request.url = origin1;
+  request.status =
+      net::URLRequestStatus::FromError(net::ERR_CONNECTION_RESET);
+  OnRequestLegComplete(request);
+
+  DomainReliabilityContext* context2 =
+      CreateAndAddContextForOrigin(origin2, false);
+  request = MakeRequestInfo();
+  request.url = origin2;
+  request.status =
+      net::URLRequestStatus::FromError(net::ERR_CONNECTION_RESET);
+  OnRequestLegComplete(request);
+
+  // Delete the beacons for |origin1|.
+  monitor_.ClearBrowsingData(
+      CLEAR_BEACONS,
+      base::Bind(&GURL::operator==, base::Unretained(&origin1)));
+
+  // Beacons for |context1| were cleared. Beacons for |context2| and
+  // the contexts themselves were not.
+  EXPECT_EQ(2u, monitor_.contexts_size_for_testing());
+  EXPECT_EQ(0u, CountQueuedBeacons(context1));
+  EXPECT_EQ(1u, CountQueuedBeacons(context2));
+}
+
 TEST_F(DomainReliabilityMonitorTest, ClearContexts) {
   CreateAndAddContext();
 
   // Initially the monitor should have just the test context.
   EXPECT_EQ(1u, monitor_.contexts_size_for_testing());
 
-  monitor_.ClearBrowsingData(CLEAR_CONTEXTS);
+  monitor_.ClearBrowsingData(
+      CLEAR_CONTEXTS, base::Callback<bool(const GURL&)>());
 
   // Clearing contexts should leave the monitor with none.
   EXPECT_EQ(0u, monitor_.contexts_size_for_testing());
 }
 
+TEST_F(DomainReliabilityMonitorTest, ClearContextsWithFilter) {
+  GURL origin1("http://example.com/");
+  GURL origin2("http://example.org/");
+
+  CreateAndAddContextForOrigin(origin1, false);
+  CreateAndAddContextForOrigin(origin2, false);
+
+  EXPECT_EQ(2u, monitor_.contexts_size_for_testing());
+
+  // Delete the contexts for |origin1|.
+  monitor_.ClearBrowsingData(
+      CLEAR_CONTEXTS,
+      base::Bind(&GURL::operator==, base::Unretained(&origin1)));
+
+  // Only one of the contexts should have been deleted.
+  EXPECT_EQ(1u, monitor_.contexts_size_for_testing());
+}
+
 TEST_F(DomainReliabilityMonitorTest, WildcardMatchesSelf) {
   DomainReliabilityContext* context =
       CreateAndAddContextForOrigin(GURL("https://wildcard/"), true);

components/domain_reliability/service.cc

@@ -12,6 +12,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/domain_reliability/monitor.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "url/gurl.h"
 
 namespace domain_reliability {
 
@@ -56,15 +57,18 @@ class DomainReliabilityServiceImpl : public DomainReliabilityService {
     return monitor;
   }
 
-  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 {
     DCHECK(network_task_runner_.get());
 
     network_task_runner_->PostTaskAndReply(
         FROM_HERE,
         base::Bind(&DomainReliabilityMonitor::ClearBrowsingData,
                    monitor_,
-                   clear_mode),
+                   clear_mode,
+                   base::Callback<bool(const GURL&)>(origin_filter)),
         callback);
   }
 

components/domain_reliability/service.h

@@ -16,6 +16,7 @@
 #include "components/domain_reliability/domain_reliability_export.h"
 #include "components/keyed_service/core/keyed_service.h"
 
+class GURL;
 class PrefService;
 
 namespace base {
@@ -54,8 +55,10 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityService
 
   // Clears browsing data on the associated Monitor. |Init()| must have been
   // called first.
-  virtual void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
-                                 const base::Closure& callback) = 0;
+  virtual void ClearBrowsingData(
+      DomainReliabilityClearMode clear_mode,
+      const base::Callback<bool(const GURL&)>& origin,
+      const base::Closure& callback) = 0;
 
   virtual void GetWebUIData(
       const base::Callback<void(std::unique_ptr<base::Value>)>& callback)