Reporting: Add Observer interface to observe cache updates.

net/reporting/reporting_cache.cc

 // Copyright 2017 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 "net/reporting/reporting_cache.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "net/reporting/reporting_client.h"
+#include "net/reporting/reporting_context.h"
 #include "net/reporting/reporting_report.h"
 #include "url/gurl.h"
 
 namespace net {
 
 ReportingCache::ReportingCache(ReportingContext* context) : context_(context) {
   DCHECK(context_);
 }
 
 ReportingCache::~ReportingCache() {}
 
 void ReportingCache::AddReport(const GURL& url,
                                const std::string& group,
                                const std::string& type,
                                std::unique_ptr<const base::Value> body,
                                base::TimeTicks queued,
                                int attempts) {
   auto report = base::MakeUnique<ReportingReport>(
       url, group, type, std::move(body), queued, attempts);
 
   auto inserted =
       reports_.insert(std::make_pair(report.get(), std::move(report)));
   DCHECK(inserted.second);
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::GetReports(
     std::vector<const ReportingReport*>* reports_out) const {
   reports_out->clear();
   for (const auto& it : reports_) {
     if (!base::ContainsKey(doomed_reports_, it.first))
       reports_out->push_back(it.second.get());
   }
 }
@@ skipping 21 matching lines @@
 
   RemoveReports(reports_to_remove);
 }
 
 void ReportingCache::IncrementReportsAttempts(
     const std::vector<const ReportingReport*>& reports) {
   for (const ReportingReport* report : reports) {
     DCHECK(base::ContainsKey(reports_, report));
     reports_[report]->attempts++;
   }
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveReports(
     const std::vector<const ReportingReport*>& reports) {
   for (const ReportingReport* report : reports) {
     DCHECK(base::ContainsKey(reports_, report));
     if (base::ContainsKey(pending_reports_, report))
       doomed_reports_.insert(report);
     else {
       DCHECK(!base::ContainsKey(doomed_reports_, report));
       reports_.erase(report);
     }
   }
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveAllReports() {
   std::vector<std::unordered_map<const ReportingReport*,
                                  std::unique_ptr<ReportingReport>>::iterator>
       reports_to_remove;
   for (auto it = reports_.begin(); it != reports_.end(); ++it) {
     ReportingReport* report = it->second.get();
     if (!base::ContainsKey(pending_reports_, report))
       reports_to_remove.push_back(it);
     else
       doomed_reports_.insert(report);
   }
 
   for (auto& it : reports_to_remove)
     reports_.erase(it);
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::GetClients(
     std::vector<const ReportingClient*>* clients_out) const {
   clients_out->clear();
   for (const auto& it : clients_)
     for (const auto& endpoint_and_client : it.second)
       clients_out->push_back(endpoint_and_client.second.get());
 }
 
@@ skipping 15 matching lines @@
 
 void ReportingCache::SetClient(const url::Origin& origin,
                                const GURL& endpoint,
                                ReportingClient::Subdomains subdomains,
                                const std::string& group,
                                base::TimeTicks expires) {
   DCHECK(endpoint.SchemeIsCryptographic());
 
   clients_[origin][endpoint] = base::MakeUnique<ReportingClient>(
       origin, endpoint, subdomains, group, expires);
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveClients(
     const std::vector<const ReportingClient*>& clients_to_remove) {
   for (const ReportingClient* client : clients_to_remove) {
     DCHECK(base::ContainsKey(clients_[client->origin], client->endpoint));
     DCHECK(clients_[client->origin][client->endpoint].get() == client);
     clients_[client->origin].erase(client->endpoint);
   }
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveClientForOriginAndEndpoint(const url::Origin& origin,
                                                       const GURL& endpoint) {
   DCHECK(base::ContainsKey(clients_, origin));
   DCHECK(base::ContainsKey(clients_[origin], endpoint));
   clients_[origin].erase(endpoint);
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveClientsForEndpoint(const GURL& endpoint) {
   for (auto& it : clients_)
     it.second.erase(endpoint);
+
+  context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveAllClients() {
   clients_.clear();
+
+  context_->NotifyCacheUpdated();
 }
 
 }  // namespace net