Add retry information to certificate reports.

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 20 matching lines @@
 #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::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 176 matching lines @@
   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"}));
+      ReportExpectation::Successful({{"report0", RetryStatus::NOT_RETRIED}}));
 }
 
 // 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(
       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"}));
+      ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Send another failed report.
   SendReport("report1");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1"}));
+      ReportExpectation::Failed({{"report1", RetryStatus::NOT_RETRIED}}));
 
   // Let all report uploads complete successfully now.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   // Send another report. This time the report should be successfully sent.
   SendReport("report2");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Successful({"report2"}));
+      ReportExpectation::Successful({{"report2", RetryStatus::NOT_RETRIED}}));
 
   // 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", "report1"}));
+  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();
 }
 
 // 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"}));
+      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();
 }
 
 // Opting out, then in, then out of extended reporting should work as expected.
@@ skipping 12 matching lines @@
   SendReport("no-report");
   test_helper()->ExpectNoRequests(service());
 
   // Enable reporting.
   ChangeOptInAndWait(
       certificate_reporting_test_utils::EXTENDED_REPORTING_OPT_IN);
 
   // A failed report should be observed.
   SendReport("report0");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0"}));
+      ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Disable reporting. This should reset the reporting service and
   // clear all pending reports.
   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());
 
@@ skipping 10 matching lines @@
 
   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.
   SendReport("report0");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0"}));
+      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"}));
+      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"}));
+      ReportExpectation::Successful({{"report1", RetryStatus::RETRIED}}));
 }
 
 // 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);
   factory()->SetClockForTesting(std::unique_ptr<base::Clock>(clock));
 
   // The service should ignore reports older than 24 hours.
   factory()->SetQueuedReportTTLForTesting(base::TimeDelta::FromHours(24));
 
   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"}));
+      ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Advance the clock a bit and trigger another failed report.
   clock->Advance(base::TimeDelta::FromHours(5));
   SendReport("report1");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1"}));
+      ReportExpectation::Failed({{"report1", RetryStatus::NOT_RETRIED}}));
 
   // Advance the clock to 20 hours, putting it 25 hours ahead of the reference
   // time. This makes report0 older than 24 hours. report1 is now 20 hours.
   clock->Advance(base::TimeDelta::FromHours(20));
 
   // Send pending reports. report0 should be discarded since it's too old.
   // report1 should be queued again.
   SendPendingReports();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1"}));
+      ReportExpectation::Failed({{"report1", RetryStatus::RETRIED}}));
 
   // Trigger another failed report.
   SendReport("report2");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report2"}));
+      ReportExpectation::Failed({{"report2", RetryStatus::NOT_RETRIED}}));
 
   // Advance the clock 5 hours. report1 will now be 25 hours old.
   clock->Advance(base::TimeDelta::FromHours(5));
 
   // Send pending reports. report1 should be discarded since it's too old.
   // report2 should be queued again.
   SendPendingReports();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report2"}));
+      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();
 }
 
@@ skipping 16 matching lines @@
   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);
 
   // Trigger a failed report.
   SendReport("report0");
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0"}));
+      ReportExpectation::Failed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Trigger three more reports within five hours of each other. After this:
   // report0 is 0 hours after reference time (15 hours old).
   // report1 is 5 hours after reference time (10 hours old).
   // report2 is 10 hours after reference time (5 hours old).
   // report3 is 15 hours after reference time (0 hours old).
   clock->Advance(base::TimeDelta::FromHours(5));
   SendReport("report1");
 
   clock->Advance(base::TimeDelta::FromHours(5));
   SendReport("report2");
 
   clock->Advance(base::TimeDelta::FromHours(5));
   SendReport("report3");
 
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1", "report2", "report3"}));
+      ReportExpectation::Failed({{"report1", RetryStatus::NOT_RETRIED},
+                                 {"report2", RetryStatus::NOT_RETRIED},
+                                 {"report3", RetryStatus::NOT_RETRIED}}));
 
   // Send pending reports. Four reports were generated above, but the service
   // only queues three reports, so report0 should be dropped since it's the
   // oldest.
   SendPendingReports();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1", "report2", "report3"}));
+      ReportExpectation::Failed({{"report1", RetryStatus::RETRIED},
+                                 {"report2", RetryStatus::RETRIED},
+                                 {"report3", RetryStatus::RETRIED}}));
 
   // Let all reports succeed.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   // Advance the clock 15 hours. Current time is now 30 hours after reference
   // time, and the ages of reports are now as follows:
   // 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", "report3"}));
+  test_helper()->WaitForRequestsDestroyed(ReportExpectation::Successful(
+      {{"report2", RetryStatus::RETRIED}, {"report3", RetryStatus::RETRIED}}));
 }
 
 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"}));
+      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"}));
+      ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
 }
 
 // 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"}));
+      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"}));
+      ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
 }
 
 // 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.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_DELAY);
 
   // Trigger a report that hangs.
   SendReport("report0");
   test_helper()->WaitForRequestsCreated(
-      ReportExpectation::Delayed({"report0"}));
+      ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Disable SafeBrowsing. This should clear all pending reports.
   ToggleSafeBrowsingAndWaitForServiceReset(false);
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Delayed({"report0"}));
+      ReportExpectation::Delayed({{"report0", RetryStatus::NOT_RETRIED}}));
 
   // Resume delayed report. No response should be observed since all pending
   // reports should be cleared.
   test_helper()->ResumeDelayedRequest();
   test_helper()->ExpectNoRequests(service());
 
   // Re-enable SafeBrowsing.
   ToggleSafeBrowsingAndWaitForServiceReset(true);
 
   // Trigger a report that hangs.
   SendReport("report1");
   test_helper()->WaitForRequestsCreated(
-      ReportExpectation::Delayed({"report1"}));
+      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"}));
+      ReportExpectation::Delayed({{"report1", RetryStatus::NOT_RETRIED}}));
 }
 
 }  // namespace safe_browsing