Add metrics for certificate report uploads

chrome/browser/safe_browsing/certificate_reporting_service_browsertest.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 "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/test/histogram_tester.h"
@@ skipping 19 matching lines @@
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/report_sender.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "url/scheme_host_port.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 {
 
 const char* kFailedReportHistogram = "SSL.CertificateErrorReportFailure";
 
 void CleanUpOnIOThread() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   net::URLRequestFilter::GetInstance()->ClearHandlers();
@@ skipping 27 matching lines @@
     test_helper()->SetUpInterceptor();
 
     CertificateReportingServiceFactory::GetInstance()
         ->SetReportEncryptionParamsForTesting(
             test_helper()->server_public_key(),
             test_helper()->server_public_key_version());
     CertificateReportingServiceFactory::GetInstance()
         ->SetServiceResetCallbackForTesting(
             base::Bind(&CertificateReportingServiceObserver::OnServiceReset,
                        base::Unretained(&service_observer_)));
+
+    event_histogram_tester_.reset(new EventHistogramTester());
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
   void TearDownOnMainThread() override {
     test_helper()->ExpectNoRequests(service());
     content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
                                      base::BindOnce(&CleanUpOnIOThread));
     EXPECT_GE(num_expected_failed_report_, 0)
         << "Don't forget to set expected failed report count.";
     // Check the histogram as the last thing. This makes sure no in-flight
     // report is missed.
     if (num_expected_failed_report_ != 0) {
       histogram_tester_.ExpectUniqueSample(kFailedReportHistogram,
                                            -net::ERR_SSL_PROTOCOL_ERROR,
                                            num_expected_failed_report_);
     } else {
       histogram_tester_.ExpectTotalCount(kFailedReportHistogram, 0);
     }
+
+    event_histogram_tester_.reset();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(
         switches::kForceFieldTrials,
         "ReportCertificateErrors/ShowAndPossiblySend/");
     // Setting the sending threshold to 1.0 ensures reporting is enabled.
     command_line->AppendSwitchASCII(
         variations::switches::kForceFieldTrialParams,
         "ReportCertificateErrors.ShowAndPossiblySend:sendingThreshold/1.0");
@@ skipping 53 matching lines @@
 
   void SetExpectedHistogramCountOnTeardown(int num_expected_failed_report) {
     num_expected_failed_report_ = num_expected_failed_report;
   }
 
   CertificateReportingService* service() const {
     return CertificateReportingServiceFactory::GetForBrowserContext(
         browser()->profile());
   }
 
+  EventHistogramTester* event_histogram_tester() {
+    return event_histogram_tester_.get();
+  }
+
  private:
   // Checks that the serialized reports in |received_reports| have the same
   // hostnames as |expected_hostnames|.
   void CheckReports(const std::set<std::string>& expected_hostnames,
                     const std::set<std::string>& received_reports,
                     const std::string type) {
     std::set<std::string> received_hostnames;
     for (const std::string& serialized_report : received_reports) {
       certificate_reporting::ErrorReport report;
       ASSERT_TRUE(report.InitializeFromString(serialized_report));
       received_hostnames.insert(report.hostname());
     }
     EXPECT_EQ(expected_hostnames, received_hostnames) << type
                                                       << " comparison failed";
   }
 
   net::EmbeddedTestServer https_server_;
 
   int num_expected_failed_report_ = -1;
 
   CertificateReportingServiceTestHelper test_helper_;
 
   CertificateReportingServiceObserver service_observer_;
 
   base::HistogramTester histogram_tester_;
+  // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(CertificateReportingServiceBrowserTest);
 };
 
 // Tests that report send attempt should be cancelled when extended
 // reporting is not opted in.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        NotOptedIn_ShouldNotSendReports) {
   SetExpectedHistogramCountOnTeardown(0);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(),
       certificate_reporting_test_utils::EXTENDED_REPORTING_DO_NOT_OPT_IN);
   // Send a report. Test teardown checks for created and in-flight requests. If
   // a report was incorrectly sent, the test will fail.
   SendReport("no-report");
+
+  event_histogram_tester()->SetExpectedValues(0, 0, 0, 0);
 }
 
 // Tests that report send attempts are not cancelled when extended reporting is
 // opted in. Goes to an interstitial page and navigates away to force a report
 // send event.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        OptedIn_ShouldSendSuccessfulReport) {
   SetExpectedHistogramCountOnTeardown(0);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(), certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
 
   // Let reports uploads successfully complete.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   // Reporting is opted in, so the report should succeed.
   SendReport("report0");
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Successful({{"report0", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was successfully submitted.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 0 /* failed */, 1 /* successful */, 0 /* dropped */);
 }
 
 // Tests that report send attempts are not cancelled when extended reporting is
 // opted in. Goes to an interstitial page and navigate away to force a report
 // send event. Repeats this three times and checks expected number of reports.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        OptedIn_ShouldQueueFailedReport) {
   SetExpectedHistogramCountOnTeardown(2);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
@@ skipping 24 matching lines @@
   // Send all pending reports. The two previously failed reports should have
   // been queued, and now be sent successfully.
   SendPendingReports();
   test_helper()->WaitForRequestsDestroyed(ReportExpectation::Successful(
       {{"report0", RetryStatus::RETRIED}, {"report1", RetryStatus::RETRIED}}));
 
   // Try sending pending reports again. Since there is no pending report,
   // nothing should be sent this time. If any report is sent, test teardown
   // will catch it.
   SendPendingReports();
+
+  // report0 was submitted twice, failed once, succeeded once.
+  // report1 was submitted twice, failed once, succeeded once.
+  // report2 was submitted once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      5 /* submitted */, 2 /* failed */, 3 /* successful */, 0 /* dropped */);
 }
 
 // Opting in then opting out of extended reporting should clear the pending
 // report queue.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        OptedIn_ThenOptedOut) {
   SetExpectedHistogramCountOnTeardown(1);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(), certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
   // Send a failed report.
   SendReport("report0");
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Disable reporting. This should clear all pending reports.
   ChangeOptInAndWait(
       certificate_reporting_test_utils::EXTENDED_REPORTING_DO_NOT_OPT_IN);
 
   // Send pending reports. No reports should be observed during test teardown.
   SendPendingReports();
+
+  // report0 was submitted once and failed once.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 1 /* failed */, 0 /* successful */, 0 /* dropped */);
 }
 
 // Opting out, then in, then out of extended reporting should work as expected.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        OptedOut_ThenOptedIn_ThenOptedOut) {
   SetExpectedHistogramCountOnTeardown(1);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(),
       certificate_reporting_test_utils::EXTENDED_REPORTING_DO_NOT_OPT_IN);
@@ skipping 19 matching lines @@
   ChangeOptInAndWait(
       certificate_reporting_test_utils::EXTENDED_REPORTING_DO_NOT_OPT_IN);
 
   // Report should be cancelled since reporting is opted out.
   SendReport("report1");
   test_helper()->ExpectNoRequests(service());
 
   // Send pending reports. Nothing should be sent since there aren't any
   // pending reports. If any report is sent, test teardown will catch it.
   SendPendingReports();
+
+  // report0 was submitted once and failed once.
+  // report1 was never submitted.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 1 /* failed */, 0 /* successful */, 0 /* dropped */);
 }
 
 // Disabling SafeBrowsing should clear pending reports queue in
 // CertificateReportingService.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        DisableSafebrowsing) {
   SetExpectedHistogramCountOnTeardown(2);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(), certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
-  // Send a delayed report.
+  // Send a report.
   SendReport("report0");
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Disable SafeBrowsing. This should clear all pending reports.
   ToggleSafeBrowsingAndWaitForServiceReset(false);
 
   // Send pending reports. No reports should be observed.
   SendPendingReports();
   test_helper()->ExpectNoRequests(service());
 
   // Re-enable SafeBrowsing and trigger another report which will be queued.
   ToggleSafeBrowsingAndWaitForServiceReset(true);
   SendReport("report1");
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Failed({{"report1", RetryStatus::NOT_RETRIED}}));
 
   // Queued report should now be successfully sent.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
   SendPendingReports();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Successful({{"report1", RetryStatus::RETRIED}}));
+
+  // report0 was submitted once, failed once, then cleared.
+  // report1 was submitted twice, failed once, succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      3 /* submitted */, 2 /* failed */, 1 /* successful */, 0 /* dropped */);
 }
 
 // CertificateReportingService should ignore reports older than the report TTL.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        DontSendOldReports) {
   SetExpectedHistogramCountOnTeardown(5);
 
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   base::Time reference_time = base::Time::Now();
   clock->SetNow(reference_time);
@@ skipping 44 matching lines @@
   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).
   clock->Advance(base::TimeDelta::FromHours(20));
 
   // Send pending reports. report2 should be discarded since it's too old. No
   // other reports remain. If any report is sent, test teardown will catch it.
   SendPendingReports();
+
+  // report0 was submitted once, failed once, dropped once.
+  // report1 was submitted twice, failed twice, dropped once.
+  // report2 was submitted twice, failed twice, dropped once.
+  event_histogram_tester()->SetExpectedValues(
+      5 /* submitted */, 5 /* failed */, 0 /* successful */, 3 /* dropped */);
 }
 
 // CertificateReportingService should drop old reports from its pending report
 // queue, if the queue is full.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        DropOldReportsFromQueue) {
   SetExpectedHistogramCountOnTeardown(7);
 
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   base::Time reference_time = base::Time::Now();
@@ skipping 54 matching lines @@
   // report1 is 25 hours old.
   // report2 is 20 hours old.
   // report3 is 15 hours old.
   clock->Advance(base::TimeDelta::FromHours(15));
 
   // Send pending reports. Only reports 2 and 3 should be sent, report 1
   // should be ignored because it's too old.
   SendPendingReports();
   test_helper()->WaitForRequestsDestroyed(ReportExpectation::Successful(
       {{"report2", RetryStatus::RETRIED}, {"report3", RetryStatus::RETRIED}}));
+
+  // 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 */);
 }
 
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        Delayed_Resumed) {
   SetExpectedHistogramCountOnTeardown(0);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(), certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
   // Let all reports hang.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_DELAY);
 
   // Trigger a report that hangs.
   SendReport("report0");
   test_helper()->WaitForRequestsCreated(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Resume the report upload. The report upload should successfully complete.
   // The interceptor only observes request creations and not response
   // completions, so there is nothing to observe.
   test_helper()->ResumeDelayedRequest();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was submitted once and succeeded once.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 0 /* failed */, 1 /* successful */, 0 /* dropped */);
 }
 
 // Same as above, but the service is shut down before resuming the delayed
 // request. Should not crash.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest,
                        Delayed_Resumed_ServiceShutdown) {
   SetExpectedHistogramCountOnTeardown(0);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(), certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
   // Let all reports hang.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_DELAY);
 
   // Trigger a report that hangs.
   SendReport("report0");
   test_helper()->WaitForRequestsCreated(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Shutdown the service and resume the report upload. Shouldn't crash.
   service()->Shutdown();
   test_helper()->ResumeDelayedRequest();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was submitted once and never completed since the service shut down.
+  event_histogram_tester()->SetExpectedValues(
+      1 /* submitted */, 0 /* failed */, 0 /* successful */, 0 /* dropped */);
 }
 
 // Trigger a delayed report, then disable Safebrowsing. Certificate reporting
 // service should clear its in-flight reports list.
 IN_PROC_BROWSER_TEST_F(CertificateReportingServiceBrowserTest, Delayed_Reset) {
   SetExpectedHistogramCountOnTeardown(0);
 
   certificate_reporting_test_utils::SetCertReportingOptIn(
       browser(), certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
   // Let all reports hang.
@@ skipping 20 matching lines @@
 
   // Trigger a report that hangs.
   SendReport("report1");
   test_helper()->WaitForRequestsCreated(
       ReportExpectation::Delayed({{"report1", RetryStatus::NOT_RETRIED}}));
 
   // Resume the delayed report and wait for it to complete.
   test_helper()->ResumeDelayedRequest();
   test_helper()->WaitForRequestsDestroyed(
       ReportExpectation::Delayed({{"report1", RetryStatus::NOT_RETRIED}}));
+
+  // report0 was submitted once and delayed, then cleared.
+  // report1 was submitted once and delayed, then succeeded.
+  event_histogram_tester()->SetExpectedValues(
+      2 /* submitted */, 0 /* failed */, 1 /* successful */, 0 /* dropped */);
 }
 
 }  // namespace safe_browsing