Include cert status in invalid certificate reports

chrome/browser/net/certificate_error_reporter_unittest.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/net/certificate_error_reporter.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/net/cert_logger.pb.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/curve25519.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/test_data_directory.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_element_reader.h"
+#include "net/cert/cert_status_flags.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/test/url_request/url_request_mock_data_job.h"
 #include "net/test/url_request/url_request_mock_http_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 chrome_browser_net::CertificateErrorReporter;
 using content::BrowserThread;
+using net::CertStatus;
 using net::CompletionCallback;
 using net::SSLInfo;
 using net::NetworkDelegateImpl;
 using net::TestURLRequestContext;
 using net::URLRequest;
 
 namespace {
 
 const char kHostname[] = "test.mail.google.com";
 const char kSecondRequestHostname[] = "test2.mail.google.com";
 const char kDummyFailureLog[] = "dummy failure log";
 const char kTestCertFilename[] = "test_mail_google_com.pem";
 const uint32 kServerPublicKeyVersion = 1;
+const CertStatus kCertStatus =
+    net::CERT_STATUS_COMMON_NAME_INVALID | net::CERT_STATUS_REVOKED;
+const size_t kNumCertErrors = 2;
+const chrome_browser_net::CertLoggerRequest::CertError kFirstReportedCertError =
+    chrome_browser_net::CertLoggerRequest::ERR_CERT_COMMON_NAME_INVALID;
+const chrome_browser_net::CertLoggerRequest::CertError
+    kSecondReportedCertError =
+        chrome_browser_net::CertLoggerRequest::ERR_CERT_REVOKED;
 
 SSLInfo GetTestSSLInfo() {
   SSLInfo info;
   info.cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), kTestCertFilename);
   info.is_issued_by_known_root = true;
+  info.cert_status = kCertStatus;
   info.pinning_failure_log = kDummyFailureLog;
   return info;
 }
 
 std::string GetPEMEncodedChain() {
   base::FilePath cert_path =
       net::GetTestCertsDirectory().AppendASCII(kTestCertFilename);
   std::string cert_data;
   EXPECT_TRUE(base::ReadFileToString(cert_path, &cert_data));
   return cert_data;
@@ skipping 50 matching lines @@
 #else
   ASSERT_TRUE(uploaded_request.ParseFromString(upload_data));
 #endif
 
   EXPECT_EQ(1u, expect_hostnames->count(uploaded_request.hostname()));
   expect_hostnames->erase(uploaded_request.hostname());
 
   EXPECT_EQ(GetPEMEncodedChain(), uploaded_request.cert_chain());
   EXPECT_EQ(1, uploaded_request.pin().size());
   EXPECT_EQ(kDummyFailureLog, uploaded_request.pin().Get(0));
+  EXPECT_EQ(2, uploaded_request.cert_error().size());
+
+  std::set<chrome_browser_net::CertLoggerRequest::CertError> reported_errors;
+  reported_errors.insert(
+      static_cast<chrome_browser_net::CertLoggerRequest::CertError>(
+          uploaded_request.cert_error().Get(0)));
+  reported_errors.insert(
+      static_cast<chrome_browser_net::CertLoggerRequest::CertError>(
+          uploaded_request.cert_error().Get(1)));
+  EXPECT_EQ(kNumCertErrors, reported_errors.size());
+  EXPECT_EQ(1u, reported_errors.count(kFirstReportedCertError));
+  EXPECT_EQ(1u, reported_errors.count(kSecondReportedCertError));
 }
 
 // A network delegate that lets tests check that a certificate error
 // report was sent. It counts the number of requests and lets tests
 // register a callback to run when the request is destroyed. It also
 // checks that the uploaded data is as expected (a report for
 // |kHostname| and |GetTestSSLInfo()|).
 class TestCertificateErrorReporterNetworkDelegate : public NetworkDelegateImpl {
  public:
   TestCertificateErrorReporterNetworkDelegate()
@@ skipping 243 matching lines @@
   GURL url = net::URLRequestMockDataJob::GetMockHttpsUrl("dummy data", 1);
   CertificateErrorReporter reporter(
       context(), url, CertificateErrorReporter::DO_NOT_SEND_COOKIES);
 
   network_delegate()->set_expect_cookies(false);
   SendReport(&reporter, network_delegate(), kHostname, url, 0,
              CertificateErrorReporter::REPORT_TYPE_PINNING_VIOLATION);
 }
 
 }  // namespace