Reporting: Cap number of reports in cache.

net/reporting/reporting_cache_unittest.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 <string>
 
 #include "base/memory/ptr_util.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/reporting/reporting_client.h"
 #include "net/reporting/reporting_observer.h"
 #include "net/reporting/reporting_report.h"
 #include "net/reporting/reporting_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
@@ skipping 15 matching lines @@
 class ReportingCacheTest : public ReportingTestBase {
  protected:
   ReportingCacheTest() : ReportingTestBase() {
     context()->AddObserver(&observer_);
   }
 
   ~ReportingCacheTest() override { context()->RemoveObserver(&observer_); }
 
   TestReportingObserver* observer() { return &observer_; }
 
+  size_t report_count() {
+    std::vector<const ReportingReport*> reports;
+    cache()->GetReports(&reports);
+    return reports.size();
+  }
+
   const GURL kUrl1_ = GURL("https://origin1/path");
   const url::Origin kOrigin1_ = url::Origin(GURL("https://origin1/"));
   const url::Origin kOrigin2_ = url::Origin(GURL("https://origin2/"));
   const GURL kEndpoint1_ = GURL("https://endpoint1/");
   const GURL kEndpoint2_ = GURL("https://endpoint2/");
   const std::string kGroup1_ = "group1";
   const std::string kGroup2 = "group2";
   const std::string kType_ = "default";
   const base::TimeTicks kNow_ = base::TimeTicks::Now();
   const base::TimeTicks kExpires1_ = kNow_ + base::TimeDelta::FromDays(7);
@@ skipping 338 matching lines @@
   cache()->SetClient(kSuperSuperOrigin, kEndpoint1_,
                      ReportingClient::Subdomains::INCLUDE, kGroup1_,
                      kExpires1_);
 
   std::vector<const ReportingClient*> clients;
   cache()->GetClientsForOriginAndGroup(kOrigin, kGroup1_, &clients);
   ASSERT_EQ(1u, clients.size());
   EXPECT_EQ(kSuperOrigin, clients[0]->origin);
 }
 
+TEST_F(ReportingCacheTest, EvictOldest) {
+  ASSERT_LT(0u, policy().max_report_count);
+  ASSERT_GT(std::numeric_limits<size_t>::max(), policy().max_report_count);
+
+  base::TimeTicks earliest_queued = tick_clock()->NowTicks();
+
+  // Enqueue the maximum number of reports, spaced apart in time.
+  for (size_t i = 0; i < policy().max_report_count; ++i) {
+    cache()->AddReport(kUrl1_, kGroup1_, kType_,
+                       base::MakeUnique<base::DictionaryValue>(),
+                       tick_clock()->NowTicks(), 0);

[shivanisha, 2017/05/09 13:58:27]

Its possible for earliest_queued to be different than tick_clock()->NowTicks()
for the first report added. And that will make the subsequent
EXPECT_NE(earliest_queued, report->queued) invalid. So for i==0 use
earliest_queued instead of tick_clock()->NowTicks()?

[Julia Tuttle, 2017/05/09 14:37:22]

tick_clock() refers to the SimpleTestTickClock created in TestReportingContext,
so it won't advance except when I ask it to.

+    tick_clock()->Advance(base::TimeDelta::FromMinutes(1));
+  }
+  EXPECT_EQ(policy().max_report_count, report_count());
+
+  // Add one more report to force the cache to evict one.
+  cache()->AddReport(kUrl1_, kGroup1_, kType_,
+                     base::MakeUnique<base::DictionaryValue>(), kNow_, 0);
+
+  // Make sure the cache evicted a report to make room for the new one, and make
+  // sure the report evicted was the earliest-queued one.
+  std::vector<const ReportingReport*> reports;
+  cache()->GetReports(&reports);
+  EXPECT_EQ(policy().max_report_count, reports.size());
+  for (const ReportingReport* report : reports)
+    EXPECT_NE(earliest_queued, report->queued);
+}
+
+TEST_F(ReportingCacheTest, DontEvictPendingReports) {
+  ASSERT_LT(0u, policy().max_report_count);
+  ASSERT_GT(std::numeric_limits<size_t>::max(), policy().max_report_count);
+
+  // Enqueue the maximum number of reports, spaced apart in time.
+  for (size_t i = 0; i < policy().max_report_count; ++i) {
+    cache()->AddReport(kUrl1_, kGroup1_, kType_,
+                       base::MakeUnique<base::DictionaryValue>(),
+                       tick_clock()->NowTicks(), 0);
+    tick_clock()->Advance(base::TimeDelta::FromMinutes(1));
+  }
+  EXPECT_EQ(policy().max_report_count, report_count());
+
+  // Mark all of the queued reports pending.
+  std::vector<const ReportingReport*> queued_reports;
+  cache()->GetReports(&queued_reports);
+  cache()->SetReportsPending(queued_reports);
+
+  // Add one more report to force the cache to evict one. Since the cache has
+  // only pending reports, it will be forced to evict the *new* report!
+  cache()->AddReport(kUrl1_, kGroup1_, kType_,
+                     base::MakeUnique<base::DictionaryValue>(), kNow_, 0);
+
+  // Make sure the cache evicted a report, and make sure the report evicted was
+  // the new, non-pending one.
+  std::vector<const ReportingReport*> reports;
+  cache()->GetReports(&reports);
+  EXPECT_EQ(policy().max_report_count, reports.size());
+  for (const ReportingReport* report : reports)
+    EXPECT_TRUE(cache()->IsReportPendingForTesting(report));
+}
+
 }  // namespace
 }  // namespace net