Reporting: Add histograms.

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>
@@ skipping 30 matching lines @@
 
   return domain.substr(dot_pos + 1);
 }
 
 }  // namespace
 
 ReportingCache::ReportingCache(ReportingContext* context) : context_(context) {
   DCHECK(context_);
 }
 
-ReportingCache::~ReportingCache() {}
+ReportingCache::~ReportingCache() {
+  base::TimeTicks now = tick_clock()->NowTicks();
+
+  // Mark all undoomed reports as erased at shutdown, and record outcomes of
+  // all remaining reports (doomed or not).
+  for (auto it = reports_.begin(); it != reports_.end(); ++it) {
+    ReportingReport* report = it->second.get();
+    if (!base::ContainsKey(doomed_reports_, report))
+      report->outcome = ReportingReport::Outcome::ERASED_REPORTING_SHUT_DOWN;
+    report->RecordOutcome(now);
+  }
+
+  reports_.clear();
+}
 
 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);
 
   if (reports_.size() > context_->policy().max_report_count) {
     // There should be at most one extra report (the one added above).
     DCHECK_EQ(context_->policy().max_report_count + 1, reports_.size());
     const ReportingReport* to_evict = FindReportToEvict();
     DCHECK_NE(nullptr, to_evict);
     // The newly-added report isn't pending, so even if all other reports are
     // pending, the cache should have a report to evict.
     DCHECK(!base::ContainsKey(pending_reports_, to_evict));
-    size_t erased = reports_.erase(to_evict);
-    DCHECK_EQ(1u, erased);
+    reports_[to_evict]->outcome = ReportingReport::Outcome::ERASED_EVICTED;
+    RemoveReportInternal(to_evict);
   }
 
   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))
@@ skipping 15 matching lines @@
 
   for (const ReportingReport* report : reports) {
     size_t erased = pending_reports_.erase(report);
     DCHECK_EQ(1u, erased);
     if (base::ContainsKey(doomed_reports_, report)) {
       reports_to_remove.push_back(report);
       doomed_reports_.erase(report);
     }
   }
 
-  RemoveReports(reports_to_remove);
+  for (const ReportingReport* report : reports_to_remove)
+    RemoveReportInternal(report);
 }
 
 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) {
+    const std::vector<const ReportingReport*>& reports,
+    ReportingReport::Outcome outcome) {
   for (const ReportingReport* report : reports) {
+    reports_[report]->outcome = outcome;
     if (base::ContainsKey(pending_reports_, report)) {
       doomed_reports_.insert(report);
     } else {
       DCHECK(!base::ContainsKey(doomed_reports_, report));
-      size_t erased = reports_.erase(report);
-      DCHECK_EQ(1u, erased);
+      RemoveReportInternal(report);
     }
   }
 
   context_->NotifyCacheUpdated();
 }
 
-void ReportingCache::RemoveAllReports() {
-  std::vector<std::unordered_map<const ReportingReport*,
-                                 std::unique_ptr<ReportingReport>>::iterator>
-      reports_to_remove;
+void ReportingCache::RemoveAllReports(ReportingReport::Outcome outcome) {
+  std::vector<const ReportingReport*> reports_to_remove;
   for (auto it = reports_.begin(); it != reports_.end(); ++it) {
     ReportingReport* report = it->second.get();
+    report->outcome = outcome;
     if (!base::ContainsKey(pending_reports_, report))
-      reports_to_remove.push_back(it);
+      reports_to_remove.push_back(report);
     else
       doomed_reports_.insert(report);
   }
 
-  for (auto& it : reports_to_remove)
-    reports_.erase(it);
+  for (const ReportingReport* report : reports_to_remove)
+    RemoveReportInternal(report);
 
   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 98 matching lines @@
 }
 
 void ReportingCache::RemoveAllClients() {
   clients_.clear();
   wildcard_clients_.clear();
   client_last_used_.clear();
 
   context_->NotifyCacheUpdated();
 }
 
+void ReportingCache::RemoveReportInternal(const ReportingReport* report) {
+  reports_[report]->RecordOutcome(tick_clock()->NowTicks());
+  size_t erased = reports_.erase(report);
+  DCHECK_EQ(1u, erased);
+}
+
 const ReportingReport* ReportingCache::FindReportToEvict() const {
   const ReportingReport* earliest_queued = nullptr;
 
   for (const auto& it : reports_) {
     const ReportingReport* report = it.first;
     if (base::ContainsKey(pending_reports_, report))
       continue;
     if (!earliest_queued || report->queued < earliest_queued->queued) {
       earliest_queued = report;
     }
@@ skipping 110 matching lines @@
     return earliest_expired;
   else
     return earliest_used;
 }
 
 base::TickClock* ReportingCache::tick_clock() {
   return context_->tick_clock();
 }
 
 }  // namespace net