Add metrics for certificate report uploads

chrome/browser/safe_browsing/certificate_reporting_service_unittest.cc

 // Copyright 2016 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 "chrome/browser/safe_browsing/certificate_reporting_service.h"
 
 #include <string>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 18 matching lines @@
 #include "net/cert/x509_util.h"
 #include "net/ssl/ssl_info.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/test/url_request/url_request_mock_data_job.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using certificate_reporting_test_utils::CertificateReportingServiceTestHelper;
 using certificate_reporting_test_utils::CertificateReportingServiceObserver;
+using certificate_reporting_test_utils::EventHistogramTester;
 using certificate_reporting_test_utils::ReportExpectation;
 using certificate_reporting_test_utils::RetryStatus;
 
 namespace {
 
 // Maximum number of reports kept in the certificate reporting service's retry
 // queue.
 const size_t kMaxReportCountInQueue = 3;
 
 const char* kFailedReportHistogram = "SSL.CertificateErrorReportFailure";
@@ skipping 63 matching lines @@
   }
 
  private:
   unsigned int num_expected_failed_report_ = 0;
   base::HistogramTester histogram_tester_;
 };
 
 }  // namespace
 
 TEST(CertificateReportingServiceReportListTest, BoundedReportList) {
+  EventHistogramTester event_histogram_tester;
+
   // Create a report list with maximum of 2 items.
   CertificateReportingService::BoundedReportList list(2 /* max_size */);
   EXPECT_EQ(0u, list.items().size());
 
   // Add a ten minute old report.
   list.Add(CertificateReportingService::Report(
       1, base::Time::Now() - base::TimeDelta::FromMinutes(10),
       std::string("report1_ten_minutes_old")));
   EXPECT_EQ(1u, list.items().size());
   EXPECT_EQ("report1_ten_minutes_old", list.items()[0].serialized_report);
@@ skipping 15 matching lines @@
   EXPECT_EQ("report2_five_minutes_old", list.items()[1].serialized_report);
 
   // Adding a report older than the oldest report in the list (report2) is
   // a no-op.
   list.Add(CertificateReportingService::Report(
       0, base::Time::Now() - base::TimeDelta::FromMinutes(10),
       std::string("report0_ten_minutes_old")));
   EXPECT_EQ(2u, list.items().size());
   EXPECT_EQ("report3_zero_minutes_old", list.items()[0].serialized_report);
   EXPECT_EQ("report2_five_minutes_old", list.items()[1].serialized_report);
+
+  event_histogram_tester.SetExpectedValues(0 /* submitted */, 0 /* failed */,
+                                           0 /* successful */, 2 /* dropped */);
 }
 
 class CertificateReportingServiceReporterOnIOThreadTest
     : public ::testing::Test {
  public:
   void SetUp() override {
     message_loop_.reset(new base::MessageLoopForIO());
     io_thread_.reset(new content::TestBrowserThread(content::BrowserThread::IO,
                                                     message_loop_.get()));
     url_request_context_getter_ =
         new net::TestURLRequestContextGetter(message_loop_->task_runner());
     net::URLRequestFailedJob::AddUrlHandler();
     net::URLRequestMockDataJob::AddUrlHandler();
+
+    event_histogram_tester_.reset(new EventHistogramTester());
   }
 
   void TearDown() override {
     ClearURLHandlers();
-    // Check the histogram as the last thing. This makes sure no in-flight
-    // report is missed.
+    // Check histograms as the last thing. This makes sure no in-flight report
+    // is missed.
     histogram_test_helper_.CheckHistogram();
+    event_histogram_tester_.reset();
   }
 
  protected:
   net::URLRequestContextGetter* url_request_context_getter() {
     return url_request_context_getter_.get();
   }
 
   void SetExpectedFailedReportCountOnTearDown(unsigned int count) {
     histogram_test_helper_.SetExpectedFailedReportCount(count);
   }
 
+  EventHistogramTester* event_histogram_tester() {
+    return event_histogram_tester_.get();
+  }
+
  private:
   std::unique_ptr<base::MessageLoopForIO> message_loop_;
   std::unique_ptr<content::TestBrowserThread> io_thread_;
 
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   ReportHistogramTestHelper histogram_test_helper_;
+  // Histogram tester for reporting events. This is a member instead of a local
+  // so that we can check the histogram after the test teardown. At that point
+  // all in flight reports should be completed or deleted because
+  // of CleanUpOnIOThread().
+  std::unique_ptr<EventHistogramTester> event_histogram_tester_;
 };
 
 TEST_F(CertificateReportingServiceReporterOnIOThreadTest,
        Reporter_RetriesEnabled) {
   SetExpectedFailedReportCountOnTearDown(6);
 
   std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
   const base::Time reference_time = base::Time::Now();
   clock->SetNow(reference_time);
 
@@ skipping 69 matching lines @@
   // Send pending reports again, this time successfully. There should be no
   // pending reports left.
   const GURL kSuccessURL =
       net::URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
   certificate_error_reporter->set_upload_url_for_testing(kSuccessURL);
   clock->Advance(base::TimeDelta::FromSeconds(1));
   reporter.SendPending();
   EXPECT_EQ(1u, reporter.inflight_report_count_for_testing());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, list->items().size());
+
+  // report1 was submitted once, failed once, dropped once.
+  // report2 was submitted twice, failed twice, dropped once.
+  // report3 was submitted four times, failed thrice, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      7 /* submitted */, 6 /* failed */, 1 /* successful */, 2 /* dropped */);
 }
 
 // Same as above, but retries are disabled.
 TEST_F(CertificateReportingServiceReporterOnIOThreadTest,
        Reporter_RetriesDisabled) {
   SetExpectedFailedReportCountOnTearDown(2);
 
   std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
   base::Time reference_time = base::Time::Now();
   clock->SetNow(reference_time);
@@ skipping 29 matching lines @@
   clock->Advance(base::TimeDelta::FromSeconds(10));
   reporter.Send("report2");
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(0u, list->items().size());
 
   // Send pending reports. Nothing should be sent.
   clock->Advance(base::TimeDelta::FromSeconds(10));
   reporter.SendPending();
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(0u, list->items().size());
+
+  // report1 and report2 were both submitted once, failed once.
+  event_histogram_tester()->SetExpectedValues(
+      2 /* submitted */, 2 /* failed */, 0 /* successful */, 0 /* dropped */);
 }
 
 class CertificateReportingServiceTest : public ::testing::Test {
  public:
   CertificateReportingServiceTest()
       : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD),
         io_task_runner_(content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::IO)) {}
 
   ~CertificateReportingServiceTest() override {}
@@ skipping 15 matching lines @@
 
     clock_.reset(new base::SimpleTestClock());
     service_.reset(new CertificateReportingService(
         sb_service_.get(), url_request_context_getter(), &profile_,
         test_helper_.server_public_key(),
         test_helper_.server_public_key_version(), kMaxReportCountInQueue,
         base::TimeDelta::FromHours(24), clock_.get(),
         base::Bind(&CertificateReportingServiceObserver::OnServiceReset,
                    base::Unretained(&service_observer_))));
     service_observer_.WaitForReset();
+
+    event_histogram_tester_.reset(new EventHistogramTester());
   }
 
   void TearDown() override {
     WaitForIOThread();
     test_helper()->ExpectNoRequests(service());
 
     service_->Shutdown();
     WaitForIOThread();
     service_.reset(nullptr);
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::BindOnce(&CertificateReportingServiceTest::TearDownOnIOThread,
                        base::Unretained(this)));
     content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
                                      base::BindOnce(&ClearURLHandlers));
     WaitForIOThread();
 
     histogram_test_helper_.CheckHistogram();
+    event_histogram_tester_.reset();
   }
 
  protected:
   net::URLRequestContextGetter* url_request_context_getter() {
     return url_request_context_getter_.get();
   }
 
   void WaitForIOThread() {
     scoped_refptr<base::ThreadTestHelper> io_helper(
         new base::ThreadTestHelper(io_task_runner_));
@@ skipping 22 matching lines @@
         base::BindOnce(&base::SimpleTestClock::SetNow,
                        base::Unretained(clock_.get()), now));
   }
 
   void SetExpectedFailedReportCountOnTearDown(unsigned int count) {
     histogram_test_helper_.SetExpectedFailedReportCount(count);
   }
 
   CertificateReportingServiceTestHelper* test_helper() { return &test_helper_; }
 
+  EventHistogramTester* event_histogram_tester() {
+    return event_histogram_tester_.get();
+  }
+
  private:
   void SetUpURLRequestContextOnIOThread() {
     std::unique_ptr<net::TestURLRequestContext> url_request_context(
         new net::TestURLRequestContext(false));
     url_request_context_getter_ = new net::TestURLRequestContextGetter(
         io_task_runner_, std::move(url_request_context));
   }
 
   void TearDownOnIOThread() {
     url_request_context_getter_ = nullptr;
   }
 
   // Must be initialized before url_request_context_getter_
   content::TestBrowserThreadBundle thread_bundle_;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
 
   std::unique_ptr<CertificateReportingService> service_;
   std::unique_ptr<base::SimpleTestClock> clock_;
 
   scoped_refptr<safe_browsing::SafeBrowsingService> sb_service_;
   safe_browsing::TestSafeBrowsingServiceFactory sb_service_factory;
   TestingProfile profile_;
 
   CertificateReportingServiceTestHelper test_helper_;
   ReportHistogramTestHelper histogram_test_helper_;
   CertificateReportingServiceObserver service_observer_;
+
+  std::unique_ptr<EventHistogramTester> event_histogram_tester_;
 };
 
 TEST_F(CertificateReportingServiceTest, SendSuccessful) {
   SetExpectedFailedReportCountOnTearDown(0);
 
   // Let all reports succeed.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   service()->Send(MakeReport("report0"));
   service()->Send(MakeReport("report1"));
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Successful({{"report0", RetryStatus::NOT_RETRIED},
                                      {"report1", RetryStatus::NOT_RETRIED}}));
+
+  // report0 and report1 were both submitted once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      2 /* submitted */, 0 /* failed */, 2 /* successful */, 0 /* dropped */);
 }
 
 TEST_F(CertificateReportingServiceTest, SendFailure) {
   SetExpectedFailedReportCountOnTearDown(4);
 
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
   // Send two reports. Both should fail and get queued.
@@ skipping 15 matching lines @@
   // Send a third report. This should not be queued.
   service()->Send(MakeReport("report2"));
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Successful({{"report2", RetryStatus::NOT_RETRIED}}));
 
   // Send pending reports. Previously failed and queued two reports should be
   // observed.
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(ReportExpectation::Successful(
       {{"report0", RetryStatus::RETRIED}, {"report1", RetryStatus::RETRIED}}));
+
+  // report0 and report1 were both submitted thrice, failed twice, succeeded
+  // once. report2 was submitted once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      7 /* submitted */, 4 /* failed */, 3 /* successful */, 0 /* dropped */);
 }
 
 TEST_F(CertificateReportingServiceTest, Disabled_ShouldNotSend) {
   SetExpectedFailedReportCountOnTearDown(0);
 
   // Let all reports succeed.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   // Disable the service.
   SetServiceEnabledAndWait(false);
 
   // Send a report. Report attempt should be cancelled and no sent reports
   // should be observed.
   service()->Send(MakeReport("report0"));
 
   // Enable the service and send a report again. It should be sent successfully.
   SetServiceEnabledAndWait(true);
 
   service()->Send(MakeReport("report1"));
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Successful({{"report1", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was never sent. report1 was submitted once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 0 /* failed */, 1 /* successful */, 0 /* dropped */);
 }
 
 TEST_F(CertificateReportingServiceTest, Disabled_ShouldClearPendingReports) {
   SetExpectedFailedReportCountOnTearDown(1);
 
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
   service()->Send(MakeReport("report0"));
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Disable the service.
   SetServiceEnabledAndWait(false);
 
   // Sending has no effect while disabled.
   service()->SendPending();
 
   // Re-enable the service and send pending reports. Pending reports should have
   // been cleared when the service was disabled, so no report should be seen.
   SetServiceEnabledAndWait(true);
 
   // Sending with empty queue has no effect.
   service()->SendPending();
+
+  // report0 was submitted once, failed once.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 1 /* failed */, 0 /* successful */, 0 /* dropped */);
 }
 
 TEST_F(CertificateReportingServiceTest, DontSendOldReports) {
   SetExpectedFailedReportCountOnTearDown(5);
 
   SetNow(base::Time::Now());
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
@@ skipping 27 matching lines @@
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Failed({{"report2", RetryStatus::RETRIED}}));
 
   // Advance the clock 20 hours again so that report2 is 25 hours old and is
   // older than max age (24 hours)
   AdvanceClock(base::TimeDelta::FromHours(20));
   // Send pending reports. report2 should be discarded since it's too old. No
   // other reports remain.
   service()->SendPending();
+
+  // report0 was submitted once, failed once, dropped once.
+  // report1 was submitted twice, failed twice, dropped once.
+  // report2 was submitted twice, failed twice, dropped once.
+  // Need to wait for SendPending() to complete.
+  event_histogram_tester()->SetExpectedValues(
+      5 /* submitted */, 5 /* failed */, 0 /* successful */, 3 /* dropped */);
 }
 
 TEST_F(CertificateReportingServiceTest, DiscardOldReports) {
   SetExpectedFailedReportCountOnTearDown(7);
 
   SetNow(base::Time::Now());
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
@@ skipping 38 matching lines @@
   // report3 is 15 hours old.
   AdvanceClock(base::TimeDelta::FromHours(15));
   // Send pending reports. Only report2 and report3 should be sent, report1
   // should be ignored because it's too old.
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(ReportExpectation::Successful(
       {{"report2", RetryStatus::RETRIED}, {"report3", RetryStatus::RETRIED}}));
 
   // Do a final send. No reports should be sent.
   service()->SendPending();
+
+  // report0 was submitted once, failed once, dropped once.
+  // report1 was submitted twice, failed twice, dropped once.
+  // report2 was submitted thrice, failed twice, succeeded once.
+  // report3 was submitted thrice, failed twice, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      9 /* submitted */, 7 /* failed */, 2 /* successful */, 2 /* dropped */);
 }
 
 // A delayed report should successfully upload when it's resumed.
 TEST_F(CertificateReportingServiceTest, Delayed_Resumed) {
   SetExpectedFailedReportCountOnTearDown(0);
 
   // Let reports hang.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_DELAY);
   // Send a report. The report upload hangs, so no error or success callbacks
   // should be called.
   service()->Send(MakeReport("report0"));
 
   // Resume the report upload and run the callbacks. The report should be
   // successfully sent.
   test_helper()->ResumeDelayedRequest();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was submitted once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 0 /* failed */, 1 /* successful */, 0 /* dropped */);
 }
 
 // Delayed reports should cleaned when the service is reset.
 TEST_F(CertificateReportingServiceTest, Delayed_Reset) {
   SetExpectedFailedReportCountOnTearDown(0);
 
   // Let reports hang.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_DELAY);
   // Send a report. The report is triggered but hangs, so no error or success
@@ skipping 15 matching lines @@
   // Send a report. The report is triggered but hangs, so no error or success
   // callbacks should be called. The report id is again 0 since the pending
   // report queue has been cleared above.
   service()->Send(MakeReport("report1"));
 
   // Resume delayed report. Two reports are successfully sent.
   test_helper()->ResumeDelayedRequest();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED},
                                   {"report1", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was submitted once, but neither failed nor succeeded because the
+  // report queue was cleared. report1 was submitted once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      2 /* submitted */, 0 /* failed */, 1 /* successful */, 0 /* dropped */);
 }