Add retry information to certificate reports.

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::ObservedReport;
 using certificate_reporting_test_utils::ReportExpectation;
 
 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 20 matching lines @@
 std::string MakeReport(const std::string& hostname) {
   net::SSLInfo ssl_info;
   ssl_info.cert = ssl_info.unverified_cert = CreateFakeCert();
 
   certificate_reporting::ErrorReport report(hostname, ssl_info);
   std::string serialized_report;
   EXPECT_TRUE(report.Serialize(&serialized_report));
   return serialized_report;
 }
 
+void AssertReport(const CertificateReportingService::Report& report,

[estark, 2017/01/13 23:26:22]

CheckReport?

[meacer, 2017/01/17 22:24:27]

Done.

+                  const std::string& expected_hostname,
+                  bool expected_is_retry_upload,
+                  const base::Time& expected_creation_time) {
+  certificate_reporting::ErrorReport error_report;
+  EXPECT_TRUE(error_report.InitializeFromString(report.serialized_report));
+  EXPECT_EQ(expected_hostname, error_report.hostname());
+  EXPECT_EQ(expected_is_retry_upload, error_report.is_retry_upload());
+  EXPECT_EQ(expected_creation_time, report.creation_time);
+}
+
 void ClearURLHandlers() {
   net::URLRequestFilter::GetInstance()->ClearHandlers();
 }
 
 // Class for histogram testing. The failed report histogram is checked once
 // after teardown to ensure all in flight requests have completed.
 class ReportHistogramTestHelper {
  public:
   // Sets the expected histogram value to be checked during teardown.
   void SetExpectedFailedReportCount(unsigned int num_expected_failed_report) {
@@ skipping 90 matching lines @@
 
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   ReportHistogramTestHelper histogram_test_helper_;
 };
 
 TEST_F(CertificateReportingServiceReporterOnIOThreadTest,
        Reporter_RetriesEnabled) {
   SetExpectedFailedReportCountOnTearDown(6);
 
   std::unique_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock());
-  base::Time reference_time = base::Time::Now();
+  const base::Time reference_time = base::Time::Now();
   clock->SetNow(reference_time);
 
   const GURL kFailureURL =
       net::URLRequestFailedJob::GetMockHttpsUrl(net::ERR_SSL_PROTOCOL_ERROR);
   certificate_reporting::ErrorReporter* certificate_error_reporter =
       new certificate_reporting::ErrorReporter(
           url_request_context_getter()->GetURLRequestContext(), kFailureURL,
           net::ReportSender::DO_NOT_SEND_COOKIES);
 
   CertificateReportingService::BoundedReportList* list =
       new CertificateReportingService::BoundedReportList(2);
 
   // Create a reporter with retries enabled.
   CertificateReportingService::Reporter reporter(
       std::unique_ptr<certificate_reporting::ErrorReporter>(
           certificate_error_reporter),
       std::unique_ptr<CertificateReportingService::BoundedReportList>(list),
       clock.get(), base::TimeDelta::FromSeconds(100),
       true /* retries_enabled */);
   EXPECT_EQ(0u, list->items().size());
   EXPECT_EQ(0u, reporter.inflight_report_count_for_testing());
 
   // Sending a failed report will put the report in the retry list.
-  reporter.Send("report1");
+  reporter.Send(MakeReport("report1"));
   EXPECT_EQ(1u, reporter.inflight_report_count_for_testing());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0u, reporter.inflight_report_count_for_testing());
   ASSERT_EQ(1u, list->items().size());
-  EXPECT_EQ("report1", list->items()[0].serialized_report);
-  EXPECT_EQ(reference_time, list->items()[0].creation_time);
+  AssertReport(list->items()[0], "report1", false, reference_time);
 
   // Sending a second failed report will also put it in the retry list.
   clock->Advance(base::TimeDelta::FromSeconds(10));
-  reporter.Send("report2");
+  reporter.Send(MakeReport("report2"));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(2u, list->items().size());
-  EXPECT_EQ("report2", list->items()[0].serialized_report);
-  EXPECT_EQ(reference_time + base::TimeDelta::FromSeconds(10),
-            list->items()[0].creation_time);
-  EXPECT_EQ("report1", list->items()[1].serialized_report);
-  EXPECT_EQ(reference_time, list->items()[1].creation_time);
+  AssertReport(list->items()[0], "report2", false,
+               reference_time + base::TimeDelta::FromSeconds(10));
+  AssertReport(list->items()[1], "report1", false, reference_time);
 
   // Sending a third report should remove the first report from the retry list.
   clock->Advance(base::TimeDelta::FromSeconds(10));
-  reporter.Send("report3");
+  reporter.Send(MakeReport("report3"));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(2u, list->items().size());
-  EXPECT_EQ("report3", list->items()[0].serialized_report);
-  EXPECT_EQ(reference_time + base::TimeDelta::FromSeconds(20),
-            list->items()[0].creation_time);
-  EXPECT_EQ("report2", list->items()[1].serialized_report);
-  EXPECT_EQ(reference_time + base::TimeDelta::FromSeconds(10),
-            list->items()[1].creation_time);
+  AssertReport(list->items()[0], "report3", false,
+               reference_time + base::TimeDelta::FromSeconds(20));
+  AssertReport(list->items()[1], "report2", false,
+               reference_time + base::TimeDelta::FromSeconds(10));
 
   // Retry sending all pending reports. All should fail and get added to the
   // retry list again. Report creation time doesn't change for retried reports.
   clock->Advance(base::TimeDelta::FromSeconds(10));
   reporter.SendPending();
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(2u, list->items().size());
-  EXPECT_EQ("report3", list->items()[0].serialized_report);
-  EXPECT_EQ(reference_time + base::TimeDelta::FromSeconds(20),
-            list->items()[0].creation_time);
-  EXPECT_EQ("report2", list->items()[1].serialized_report);
-  EXPECT_EQ(reference_time + base::TimeDelta::FromSeconds(10),
-            list->items()[1].creation_time);
+  AssertReport(list->items()[0], "report3", true,
+               reference_time + base::TimeDelta::FromSeconds(20));
+  AssertReport(list->items()[1], "report2", true,
+               reference_time + base::TimeDelta::FromSeconds(10));
 
   // Advance the clock to 115 seconds. This makes report3 95 seconds old, and
   // report2 105 seconds old. report2 should be dropped because it's older than
   // max age (100 seconds).
   clock->SetNow(reference_time + base::TimeDelta::FromSeconds(115));
   reporter.SendPending();
   EXPECT_EQ(1u, reporter.inflight_report_count_for_testing());
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(1u, list->items().size());
-  EXPECT_EQ("report3", list->items()[0].serialized_report);
-  EXPECT_EQ(reference_time + base::TimeDelta::FromSeconds(20),
-            list->items()[0].creation_time);
+  AssertReport(list->items()[0], "report3", true,
+               reference_time + base::TimeDelta::FromSeconds(20));
 
-  // Retry again, this time successfully. There should be no pending reports
-  // left.
+  // 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());
 }
 
@@ skipping 164 matching lines @@
 
   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_;
 };
 
-TEST_F(CertificateReportingServiceTest, Send) {
+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({ObservedReport::NotRetried("report0"),
+                                     ObservedReport::NotRetried("report1")}));
+}
+
+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.
   service()->Send(MakeReport("report0"));
   service()->Send(MakeReport("report1"));
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0", "report1"}));
+      ReportExpectation::Failed({ObservedReport::NotRetried("report0"),
+                                 ObservedReport::NotRetried("report1")}));
 
   // Send pending reports. Previously queued reports should be queued again.
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0", "report1"}));
+      ReportExpectation::Failed({ObservedReport::Retried("report0"),
+                                 ObservedReport::Retried("report1")}));
 
   // Let all reports succeed.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   // Send a third report. This should not be queued.
   service()->Send(MakeReport("report2"));
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Successful({"report2"}));
+      ReportExpectation::Successful({ObservedReport::NotRetried("report2")}));
 
   // Send pending reports. Previously failed and queued two reports should be
   // observed.
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Successful({"report0", "report1"}));
+      ReportExpectation::Successful({ObservedReport::Retried("report0"),
+                                     ObservedReport::Retried("report1")}));
 }
 
 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"}));
+      ReportExpectation::Successful({ObservedReport::NotRetried("report1")}));
 }
 
 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"}));
+      ReportExpectation::Failed({ObservedReport::NotRetried("report0")}));
 
   // 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();
 }
 
 TEST_F(CertificateReportingServiceTest, DontSendOldReports) {
   SetExpectedFailedReportCountOnTearDown(5);
 
   SetNow(base::Time::Now());
   // Let all reports fail.
   test_helper()->SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
   // Send a report, then advance the clock and send another report.
   service()->Send(MakeReport("report0"));
   AdvanceClock(base::TimeDelta::FromHours(5));
   service()->Send(MakeReport("report1"));
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0", "report1"}));
+      ReportExpectation::Failed({ObservedReport::NotRetried("report0"),
+                                 ObservedReport::NotRetried("report1")}));
 
   // Advance the clock to 20 hours, putting it 25 hours ahead of the reference
   // time. This makes the report0 older than max age (24 hours). The report1 is
   // now 20 hours old.
   AdvanceClock(base::TimeDelta::FromHours(20));
   // Send pending reports. report0 should be discarded since it's too old.
   // report1 should be queued again.
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1"}));
+      ReportExpectation::Failed({ObservedReport::Retried("report1")}));
 
   // Send a third report.
   service()->Send(MakeReport("report2"));
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report2"}));
+      ReportExpectation::Failed({ObservedReport::NotRetried("report2")}));
 
   // Advance the clock 5 hours. The report1 will now be 25 hours old.
   AdvanceClock(base::TimeDelta::FromHours(5));
   // Send pending reports. report1 should be discarded since it's too old.
   // report2 should be queued again.
   service()->SendPending();
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report2"}));
+      ReportExpectation::Failed({ObservedReport::Retried("report2")}));
 
   // 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();
 }
 
 TEST_F(CertificateReportingServiceTest, DiscardOldReports) {
@@ skipping 13 matching lines @@
 
   AdvanceClock(base::TimeDelta::FromHours(5));
   service()->Send(MakeReport("report1"));
 
   AdvanceClock(base::TimeDelta::FromHours(5));
   service()->Send(MakeReport("report2"));
 
   AdvanceClock(base::TimeDelta::FromHours(5));
   service()->Send(MakeReport("report3"));
   test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report0", "report1", "report2", "report3"}));
+      ReportExpectation::Failed({ObservedReport::NotRetried("report0"),
+                                 ObservedReport::NotRetried("report1"),
+                                 ObservedReport::NotRetried("report2"),
+                                 ObservedReport::NotRetried("report3")}));
 
   // Send pending reports. Four reports were generated above, but the service
   // only queues three reports, so the very first one should be dropped since
   // it's the oldest.
   service()->SendPending();
-  test_helper()->WaitForRequestsDestroyed(
-      ReportExpectation::Failed({"report1", "report2", "report3"}));
+  test_helper()->WaitForRequestsDestroyed(ReportExpectation::Failed(
+      {ObservedReport::Retried("report1"), ObservedReport::Retried("report2"),
+       ObservedReport::Retried("report3")}));
 
   // Let all reports succeed.
   test_helper()->SetFailureMode(certificate_reporting_test_utils::
                                     ReportSendingResult::REPORTS_SUCCESSFUL);
 
   // Advance the clock by 15 hours. Current time is now 30 hours after reference
   // time. The ages of reports are now as follows:
   // report1 is 25 hours old.
   // report2 is 20 hours old.
   // 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", "report3"}));
+      ReportExpectation::Successful({ObservedReport::Retried("report2"),
+                                     ObservedReport::Retried("report3")}));
 
   // Do a final send. No reports should be sent.
   service()->SendPending();
 }
 
 // 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"}));
+      ReportExpectation::Delayed({ObservedReport::NotRetried("report0")}));
 }
 
 // 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 13 matching lines @@
   SetServiceEnabledAndWait(true);
 
   // 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", "report1"}));
+      ReportExpectation::Delayed({ObservedReport::NotRetried("report0"),
+                                  ObservedReport::NotRetried("report1")}));
 }