Reporting: Cap number of reports in cache.

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 43 matching lines @@
                                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);
+  }
+
   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 152 matching lines @@
   context_->NotifyCacheUpdated();
 }
 
 void ReportingCache::RemoveAllClients() {
   clients_.clear();
   wildcard_clients_.clear();
 
   context_->NotifyCacheUpdated();
 }
 
+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;
+    }
+  }
+
+  return earliest_queued;
+}
+
 void ReportingCache::MaybeAddWildcardClient(const ReportingClient* client) {
   if (client->subdomains != ReportingClient::Subdomains::INCLUDE)
     return;
 
   const std::string& domain = client->origin.host();
   auto inserted = wildcard_clients_[domain].insert(client);
   DCHECK(inserted.second);
 }
 
 void ReportingCache::MaybeRemoveWildcardClient(const ReportingClient* client) {
@@ skipping 16 matching lines @@
     return;
 
   for (const ReportingClient* client : it->second) {
     DCHECK_EQ(ReportingClient::Subdomains::INCLUDE, client->subdomains);
     if (client->group == group)
       clients_out->push_back(client);
   }
 }
 
 }  // namespace net