Wire up CertificateReportingService to handle 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 <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/certificate_reporting_service_test_utils.h"
+#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
+#include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/network_delegate_impl.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"
 
 namespace {
 void ClearURLHandlers() {
   net::URLRequestFilter::GetInstance()->ClearHandlers();
 }
-
-// Maximum number of reports kept in the certificate reporting service's retry
-// queue.
-const size_t kMaxReportCountInQueue = 3;
-
 }  // namespace
 
 TEST(CertificateReportingServiceReportListTest, BoundedReportList) {
   // 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),
@@ skipping 192 matching lines @@
   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());
 }
 
+namespace {
+
+const size_t kMaxReportCountInQueue = 3;
+
+}  // namespace
+
 class CertificateReportingServiceTest
     : public ::testing::Test,
       public certificate_reporting_test_utils::
           CertificateReportingServiceTestBase {
  public:
-  enum ReportSendStatus {
-    // Indicates that the send attempt is completed.
-    EXPECT_SEND_ATTEMPT_COMPLETED,
-    // Indicates that the send attempt is cancelled (e.g. extended reporting was
-    // not opted in).
-    EXPECT_SEND_ATTEMPT_CANCELLED,
-  };
-
   CertificateReportingServiceTest()
       : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD),
         io_task_runner_(content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::IO)),
         url_request_context_getter_(
             new net::TestURLRequestContextGetter(io_task_runner_)) {}
 
   ~CertificateReportingServiceTest() override {}
 
   void SetUp() override {
     SetUpInterceptor();
 
+    safe_browsing::SafeBrowsingService::RegisterFactory(&sb_service_factory);
+    sb_service_ = sb_service_factory.CreateSafeBrowsingService();
+
     // Create an event observer to wait for a single "Reset" event that happens
     // on service initialization.
     certificate_reporting_test_utils::ReportEventObserver* observer =
         new certificate_reporting_test_utils::ReportEventObserver(1);
 
     service_.reset(new CertificateReportingService(
-        url_request_context_getter_,
+        sb_service_, url_request_context_getter_, &profile_,
         std::unique_ptr<certificate_reporting_test_utils::ReportEventObserver>(
             observer),
         kMaxReportCountInQueue, base::TimeDelta::FromHours(24), &clock_));
     // Wait for reporting service initialization.
     observer->WaitForEvents();
   }
 
   void TearDown() override {
     // Wait for reporting service shutdown.
     certificate_reporting_test_utils::ReportEventObserver* event_observer =
@@ skipping 16 matching lines @@
         new certificate_reporting_test_utils::ReportEventObserver(
             num_events_to_wait_for);
     service_->SetEventObserverForTesting(
         std::unique_ptr<CertificateReportingService::EventObserver>(observer));
     return observer;
   }
 
   CertificateReportingService* service() { return service_.get(); }
 
   // Sends a test report and checks expected events.
-  void SendReport(ReportSendStatus expected_send_attempt_status,
+  void SendReport(ObservedReportEvent expected_observed_event,
                   const std::set<int>& expected_successful_report_ids,
                   const std::set<int>& expected_failed_report_ids) {
     // Observe events: 1 event for send completion or cancellation,
     // the rest for observed reports after send completion.
     certificate_reporting_test_utils::ReportEventObserver* report_observer =
         NewEventObserver(1u + expected_successful_report_ids.size() +
                          expected_failed_report_ids.size());
     service()->Send("test_report");
     report_observer->WaitForEvents();
 
-    EXPECT_EQ(0u, report_observer->num_resets());
-    if (expected_send_attempt_status == EXPECT_SEND_ATTEMPT_COMPLETED) {
-      EXPECT_EQ(1u, report_observer->num_completed_attempts());
-      EXPECT_EQ(0u, report_observer->num_cancelled_attempts());
-    } else {
-      EXPECT_EQ(0u, report_observer->num_completed_attempts());
-      EXPECT_EQ(1u, report_observer->num_cancelled_attempts());
-    }
-    EXPECT_EQ(expected_successful_report_ids,
-              report_observer->successful_report_ids());
-    EXPECT_EQ(expected_failed_report_ids, report_observer->failed_report_ids());
+    EXPECT_NE(EXPECT_SERVICE_RESET, expected_observed_event);
+    CheckExpectedResults(*report_observer, expected_observed_event,
+                         expected_successful_report_ids,
+                         expected_failed_report_ids);
   }
 
   // Sends pending reports and checks expected events.
-  void SendPendingReports(ReportSendStatus expected_send_attempt_status,
+  void SendPendingReports(ObservedReportEvent expected_observed_event,
                           const std::set<int>& expected_successful_report_ids,
                           const std::set<int>& expected_failed_report_ids) {
     // Observe events: 1 event for send completion or cancellation,
     // the rest for observed reports after send completion.
     certificate_reporting_test_utils::ReportEventObserver* report_observer =
         NewEventObserver(1u + expected_successful_report_ids.size() +
                          expected_failed_report_ids.size());
     service()->SendPending();
     report_observer->WaitForEvents();
 
-    EXPECT_EQ(0u, report_observer->num_resets());
-    if (expected_send_attempt_status == EXPECT_SEND_ATTEMPT_COMPLETED) {
-      EXPECT_EQ(1u, report_observer->num_completed_attempts());
-      EXPECT_EQ(0u, report_observer->num_cancelled_attempts());
-    } else {
-      EXPECT_EQ(0u, report_observer->num_completed_attempts());
-      EXPECT_EQ(1u, report_observer->num_cancelled_attempts());
-    }
-    EXPECT_EQ(expected_successful_report_ids,
-              report_observer->successful_report_ids());
-    EXPECT_EQ(expected_failed_report_ids, report_observer->failed_report_ids());
+    EXPECT_NE(EXPECT_SERVICE_RESET, expected_observed_event);
+    CheckExpectedResults(*report_observer, expected_observed_event,
+                         expected_successful_report_ids,
+                         expected_failed_report_ids);
   }
 
   // Sets service enabled state and waits for a reset event.
   void SetServiceEnabledAndWait(bool enabled) {
     certificate_reporting_test_utils::ReportEventObserver* report_observer =
         NewEventObserver(1u);
     service()->SetEnabled(enabled);
     report_observer->WaitForEvents();
-    EXPECT_EQ(1u, report_observer->num_resets());
-    EXPECT_EQ(0u, report_observer->num_cancelled_attempts());
-    EXPECT_EQ(0u, report_observer->num_completed_attempts());
-    EXPECT_EQ(std::set<int>(), report_observer->successful_report_ids());
-    EXPECT_EQ(std::set<int>(), report_observer->failed_report_ids());
+
+    CheckExpectedResults(*report_observer, EXPECT_SERVICE_RESET,
+                         std::set<int>(), std::set<int>());
   }
 
   // Resumes delayed requests and checks expected events.
   void ResumeDelayedRequests(
       size_t num_expected_events,
       const std::set<int>& expected_successful_report_ids,
       const std::set<int>& expected_failed_report_ids) {
     certificate_reporting_test_utils::ReportEventObserver* report_observer =
         NewEventObserver(num_expected_events);
     ResumeDelayedRequest();
     report_observer->WaitForEvents();
-    EXPECT_EQ(0u, report_observer->num_completed_attempts());
-    EXPECT_EQ(0u, report_observer->num_cancelled_attempts());
-    EXPECT_EQ(0u, report_observer->num_resets());
-    EXPECT_EQ(expected_successful_report_ids,
-              report_observer->successful_report_ids());
-    EXPECT_EQ(expected_failed_report_ids, report_observer->failed_report_ids());
+
+    CheckExpectedResults(*report_observer, EXPECT_NONE,
+                         expected_successful_report_ids,
+                         expected_failed_report_ids);
   }
 
   base::SimpleTestClock* clock() { return &clock_; }
 
  private:
   // 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_;
   base::SimpleTestClock clock_;
+
+  safe_browsing::SafeBrowsingService* sb_service_;
+  safe_browsing::TestSafeBrowsingServiceFactory sb_service_factory;
+  TestingProfile profile_;
 };
 
 TEST_F(CertificateReportingServiceTest, Send) {
   // Let all reports fail.
   SetFailureMode(
       certificate_reporting_test_utils::ReportSendingResult::REPORTS_FAIL);
 
   // Send a report. A failed report with id = 0 should be observed.
   SendReport(EXPECT_SEND_ATTEMPT_COMPLETED,
              std::set<int>() /* expected_successful_report_ids */,
@@ skipping 228 matching lines @@
   // report queue has been cleared above.
   SendReport(EXPECT_SEND_ATTEMPT_COMPLETED,
              std::set<int>() /* expected_successful_report_ids */,
              std::set<int>() /* expected_failed_report_ids */);
 
   // Resume delayed report. The report should be observed.
   ResumeDelayedRequests(1u /* num_expected_events */,
                         std::set<int>{0} /* expected_successful_report_ids */,
                         std::set<int>() /* expected_failed_report_ids */);
 }