Implement main CertificateReportingService code and add unit tests.

chrome/browser/safe_browsing/certificate_reporting_service_test_utils.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_test_utils.h"
+
+#include "base/threading/thread_task_runner_handle.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_utils.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 "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+void SetUpURLHandlersOnIOThread(
+    std::unique_ptr<net::URLRequestInterceptor> url_request_interceptor) {
+  net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
+  filter->AddUrlInterceptor(
+      GURL(CertificateReportingService::kExtendedReportingUploadUrlInsecure),
+      std::move(url_request_interceptor));
+}
+}
+
+namespace certificate_reporting_test_utils {
+
+ReportEventObserver::ReportEventObserver(int num_events_to_wait_for)
+    : num_events_to_wait_for_(num_events_to_wait_for) {}
+
+ReportEventObserver::~ReportEventObserver() {}
+
+void ReportEventObserver::OnSendAttempt(bool completed) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (completed) {
+    num_completed_attempts_++;
+  } else {
+    num_cancelled_attempts_++;
+  }
+  OnEventReceived(EVENT_SEND_ATTEMPT);
+}
+
+void ReportEventObserver::OnSendComplete(int report_id, bool success) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (success) {
+    successful_report_ids_.insert(report_id);
+  } else {
+    failed_report_ids_.insert(report_id);
+  }
+  OnEventReceived(EVENT_SEND_COMPLETE);
+}
+
+void ReportEventObserver::OnReset() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  num_resets_++;
+  OnEventReceived(EVENT_RESET);
+}
+
+void ReportEventObserver::WaitForEvents() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (num_events_received_ < num_events_to_wait_for_) {
+    waiting_ = true;
+    content::RunMessageLoop();
+    EXPECT_FALSE(waiting_);
+  }
+  EXPECT_EQ(num_events_to_wait_for_, num_events_received_);
+}
+
+void ReportEventObserver::OnEventReceived(EventType event_type) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  num_events_received_++;
+  EXPECT_LE(num_events_received_, num_events_to_wait_for_)
+      << "An unexpected event arrived of type " << event_type;
+  if (waiting_ && num_events_received_ == num_events_to_wait_for_) {
+    waiting_ = false;
+    base::MessageLoop::current()->QuitWhenIdle();
+  }
+}
+
+DelayableCertReportURLRequestJob::DelayableCertReportURLRequestJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate)
+    : net::URLRequestJob(request, network_delegate), weak_factory_(this) {}
+
+DelayableCertReportURLRequestJob::~DelayableCertReportURLRequestJob() {}
+
+void DelayableCertReportURLRequestJob::Start() {
+  started_ = true;
+  if (delayed_) {
+    // Do nothing until Resume() is called.
+    return;
+  }
+  Resume();
+}
+
+int DelayableCertReportURLRequestJob::ReadRawData(net::IOBuffer* buf,
+                                                  int buf_size) {
+  return 0;
+}
+
+int DelayableCertReportURLRequestJob::GetResponseCode() const {
+  return 200;
+}
+
+void DelayableCertReportURLRequestJob::GetResponseInfo(
+    net::HttpResponseInfo* info) {}
+
+void DelayableCertReportURLRequestJob::Resume() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(delayed_);
+  if (!started_) {
+    // If Start() hasn't been called yet, then unset |delayed_| so
+    // that when Start() is called, the request will begin
+    // immediately.
+    delayed_ = false;
+    return;
+  }
+  // Start reading asynchronously as would a normal network request.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&DelayableCertReportURLRequestJob::NotifyHeadersComplete,
+                 weak_factory_.GetWeakPtr()));
+}
+
+CertReportJobInterceptor::CertReportJobInterceptor(
+    ReportSendingResult expected_report_result)
+    : expected_report_result_(expected_report_result), weak_factory_(this) {}
+
+CertReportJobInterceptor::~CertReportJobInterceptor() {}
+
+net::URLRequestJob* CertReportJobInterceptor::MaybeInterceptRequest(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  if (expected_report_result_ == REPORTS_FAIL) {
+    return new net::URLRequestFailedJob(request, network_delegate,
+                                        net::ERR_SSL_PROTOCOL_ERROR);
+  } else if (expected_report_result_ == REPORTS_DELAY) {
+    DCHECK(!delayed_request_) << "Supports only one delayed request at a time";
+    DelayableCertReportURLRequestJob* job =
+        new DelayableCertReportURLRequestJob(request, network_delegate);
+    delayed_request_ = job->GetWeakPtr();
+    return job;
+  }
+  // Successful url request job.
+  return new net::URLRequestMockDataJob(request, network_delegate, "some data",
+                                        1, false);
+}
+
+void CertReportJobInterceptor::SetFailureMode(
+    ReportSendingResult expected_report_result) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&CertReportJobInterceptor::SetFailureModeOnIOThread,
+                 weak_factory_.GetWeakPtr(), expected_report_result));
+}
+
+void CertReportJobInterceptor::Resume() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&CertReportJobInterceptor::ResumeOnIOThread,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void CertReportJobInterceptor::SetFailureModeOnIOThread(
+    ReportSendingResult expected_report_result) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  expected_report_result_ = expected_report_result;
+}
+
+void CertReportJobInterceptor::ResumeOnIOThread() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  EXPECT_EQ(REPORTS_DELAY, expected_report_result_);
+  if (delayed_request_)
+    delayed_request_->Resume();
+}
+
+CertificateReportingServiceTestBase::CertificateReportingServiceTestBase() {}
+
+CertificateReportingServiceTestBase::~CertificateReportingServiceTestBase() {}
+
+void CertificateReportingServiceTestBase::SetUpInterceptor() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  url_request_interceptor_ =
+      new certificate_reporting_test_utils::CertReportJobInterceptor(
+          certificate_reporting_test_utils::REPORTS_FAIL);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&SetUpURLHandlersOnIOThread,
+                 base::Passed(std::unique_ptr<net::URLRequestInterceptor>(
+                     url_request_interceptor_))));
+}
+
+// Changes the behavior of report uploads to fail or succeed.
+void CertificateReportingServiceTestBase::SetFailureMode(
+    certificate_reporting_test_utils::ReportSendingResult
+        expected_report_result) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  url_request_interceptor_->SetFailureMode(expected_report_result);
+}
+
+void CertificateReportingServiceTestBase::ResumeDelayedRequest() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  url_request_interceptor_->Resume();
+}
+
+}  // namespace certificate_reporting_test_utils