Initial (partial) implementation of HPKP violation reporting

chrome/browser/ssl/certificate_reporting_test_utils.cc

 // Copyright 2015 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/ssl/certificate_reporting_test_utils.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/browser/ssl/cert_report_helper.h"
 #include "chrome/browser/ssl/certificate_error_report.h"
 #include "chrome/browser/ssl/ssl_cert_reporter.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "components/variations/variations_associated_data.h"
+#include "net/http/certificate_report_sender.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using chrome_browser_net::CertificateErrorReporter;
 
 namespace {
 
 void SetMockReporter(SafeBrowsingService* safe_browsing_service,
                      scoped_ptr<CertificateErrorReporter> reporter) {
   safe_browsing_service->ping_manager()->SetCertificateErrorReporterForTesting(
       reporter.Pass());
 }
 
 }  // namespace
 
 namespace CertificateReportingTestUtils {
 
 // This class is used to test invalid certificate chain reporting when
 // the user opts in to do so on the interstitial. It keeps track of the
 // most recent hostname for which a report would have been sent over the
 // network.
 class MockReporter : public chrome_browser_net::CertificateErrorReporter {
  public:
-  MockReporter(net::URLRequestContext* request_context,
-               const GURL& upload_url,
-               CookiesPreference cookies_preference);
+  MockReporter(
+      net::URLRequestContext* request_context,
+      const GURL& upload_url,
+      net::CertificateReportSender::CookiesPreference cookies_preference);
 
   // CertificateErrorReporter implementation
   void SendReport(CertificateErrorReporter::ReportType type,
                   const std::string& serialized_report) override;
 
   // Returns the hostname in the report for the last call to
   // |SendReport|.
   const std::string& latest_hostname_reported() {
     return latest_hostname_reported_;
   }
 
  private:
   std::string latest_hostname_reported_;
 
   DISALLOW_COPY_AND_ASSIGN(MockReporter);
 };
 
-MockReporter::MockReporter(net::URLRequestContext* request_context,
-                           const GURL& upload_url,
-                           CookiesPreference cookies_preference)
+MockReporter::MockReporter(
+    net::URLRequestContext* request_context,
+    const GURL& upload_url,
+    net::CertificateReportSender::CookiesPreference cookies_preference)
     : CertificateErrorReporter(request_context,
                                upload_url,
                                cookies_preference) {
 }
 
 void MockReporter::SendReport(CertificateErrorReporter::ReportType type,
                               const std::string& serialized_report) {
   CertificateErrorReport report;
   ASSERT_TRUE(report.InitializeFromString(serialized_report));
   EXPECT_EQ(CertificateErrorReporter::REPORT_TYPE_EXTENDED_REPORTING, type);
   latest_hostname_reported_ = report.hostname();
 }
 
 void CertificateReportingTest::SetUpMockReporter() {
   // Set up the mock reporter to track the hostnames that reports get
   // sent for. The request_context argument is null here
   // because the MockReporter doesn't actually use a
   // request_context. (In order to pass a real request_context, the
   // reporter would have to be constructed on the IO thread.)
-  reporter_ = new MockReporter(nullptr, GURL("http://example.test"),
-                               MockReporter::DO_NOT_SEND_COOKIES);
+  reporter_ =
+      new MockReporter(nullptr, GURL("http://example.test"),
+                       net::CertificateReportSender::DO_NOT_SEND_COOKIES);
 
   scoped_refptr<SafeBrowsingService> safe_browsing_service =
       g_browser_process->safe_browsing_service();
   ASSERT_TRUE(safe_browsing_service);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(
           SetMockReporter, safe_browsing_service,
           base::Passed(scoped_ptr<CertificateErrorReporter>(reporter_))));
@@ skipping 74 matching lines @@
                                          group_name, params);
   }
 }
 
 // Helper function to set the Finch options in case we have no parameter.
 void SetCertReportingFinchConfig(const std::string& group_name) {
   SetCertReportingFinchConfig(group_name, std::string());
 }
 
 }  // namespace CertificateReportingTestUtils