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 32 matching lines @@
 
   return domain.substr(dot_pos + 1);
 }
 
 class ReportingCacheImpl : public ReportingCache {
  public:
   ReportingCacheImpl(ReportingContext* context) : context_(context) {
     DCHECK(context_);
   }
 
-  ~ReportingCacheImpl() override {}
+  ~ReportingCacheImpl() override {
+    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 AddReport(const GURL& url,
                  const std::string& group,
                  const std::string& type,
                  std::unique_ptr<const base::Value> body,
                  base::TimeTicks queued,
                  int attempts) override {
     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 GetReports(
       std::vector<const ReportingReport*>* reports_out) const override {
     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 IncrementReportsAttempts(
       const std::vector<const ReportingReport*>& reports) override {
     for (const ReportingReport* report : reports) {
       DCHECK(base::ContainsKey(reports_, report));
       reports_[report]->attempts++;
     }
 
     context_->NotifyCacheUpdated();
   }
 
-  void RemoveReports(
-      const std::vector<const ReportingReport*>& reports) override {
+  void RemoveReports(const std::vector<const ReportingReport*>& reports,
+                     ReportingReport::Outcome outcome) override {
     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 RemoveAllReports() override {
-    std::vector<std::unordered_map<const ReportingReport*,
-                                   std::unique_ptr<ReportingReport>>::iterator>
-        reports_to_remove;
+  void RemoveAllReports(ReportingReport::Outcome outcome) override {
+    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 GetClients(
       std::vector<const ReportingClient*>* clients_out) const override {
     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 142 matching lines @@
   // References but does not own all clients with includeSubdomains set, keyed
   // by domain name.
   std::unordered_map<std::string, std::unordered_set<const ReportingClient*>>
       wildcard_clients_;
 
   // The time that each client has last been used.
   std::unordered_map<const ReportingClient*, base::TimeTicks> client_last_used_;
 
   base::TickClock* tick_clock() { return context_->tick_clock(); }
 
+  void RemoveReportInternal(const ReportingReport* report) {
+    reports_[report]->RecordOutcome(tick_clock()->NowTicks());
+    size_t erased = reports_.erase(report);
+    DCHECK_EQ(1u, erased);
+  }
+
   const ReportingReport* 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 116 matching lines @@
 
 // static
 std::unique_ptr<ReportingCache> ReportingCache::Create(
     ReportingContext* context) {
   return base::MakeUnique<ReportingCacheImpl>(context);
 }
 
 ReportingCache::~ReportingCache() {}
 
 }  // namespace net