Implement origin-based deletion for the domain reliability service.

components/domain_reliability/context_manager.cc

 // Copyright 2015 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 "components/domain_reliability/context_manager.h"
 
 #include <utility>
 
 namespace domain_reliability {
 
 DomainReliabilityContextManager::DomainReliabilityContextManager(
     DomainReliabilityContext::Factory* context_factory)
     : context_factory_(context_factory) {
 }
 
 DomainReliabilityContextManager::~DomainReliabilityContextManager() {
-  RemoveAllContexts();
+  RemoveContexts(
+      base::Callback<bool(const GURL&)>() /* no filter - delete everything */);
 }
 
 void DomainReliabilityContextManager::RouteBeacon(
     std::unique_ptr<DomainReliabilityBeacon> beacon) {
   DomainReliabilityContext* context = GetContextForHost(beacon->url.host());
   if (!context)
     return;
 
   context->OnBeacon(std::move(beacon));
 }
@@ skipping 34 matching lines @@
 void DomainReliabilityContextManager::ClearConfig(const GURL& origin) {
   std::string key = origin.host();
 
   if (contexts_.count(key)) {
     DVLOG(1) << "Removing context for existing origin " << origin.spec() << ".";
     contexts_.erase(key);
     removed_contexts_.insert(key);
   }
 }
 
-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(
     std::unique_ptr<const DomainReliabilityConfig> config) {
   std::string key = config->origin.host();
   // TODO(juliatuttle): Convert this to actual origin.
 
   std::unique_ptr<DomainReliabilityContext> context =
       context_factory_->CreateContextForConfig(std::move(config));
   DomainReliabilityContext** entry = &contexts_[key];
   if (*entry)
     delete *entry;
 
   *entry = context.release();
   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()
     const {
   std::unique_ptr<base::ListValue> contexts_value(new base::ListValue());
   for (const auto& context_entry : contexts_)
     contexts_value->Append(context_entry.second->GetWebUIData());
   return std::move(contexts_value);
 }
 
@@ skipping 15 matching lines @@
   context_it = contexts_.find(parent_host);
   if (context_it != contexts_.end()
       && context_it->second->config().include_subdomains) {
     return context_it->second;
   }
 
   return nullptr;
 }
 
 }  // namespace domain_reliability