Add URLRequest unit tests for HPKP violation reports

net/test/spawned_test_server/base_test_server.cc

 // Copyright 2013 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 "net/test/spawned_test_server/base_test_server.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/port_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/test_root_certs.h"
+#include "net/cert/x509_certificate.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/net_log.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 std::string GetHostname(BaseTestServer::Type type,
                         const BaseTestServer::SSLOptions& options) {
@@ skipping 56 matching lines @@
     case BaseTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE:
       return new base::StringValue("close");
     case BaseTestServer::SSLOptions::TLS_INTOLERANCE_RESET:
       return new base::StringValue("reset");
     default:
       NOTREACHED();
       return new base::StringValue("");
   }
 }
 
+bool GetLocalCertificatesDir(const base::FilePath& certificates_dir,
+                             base::FilePath* local_certificates_dir) {
+  if (certificates_dir.IsAbsolute()) {
+    *local_certificates_dir = certificates_dir;
+    return true;
+  }
+
+  base::FilePath src_dir;
+  if (!PathService::Get(base::DIR_SOURCE_ROOT, &src_dir))
+    return false;
+
+  *local_certificates_dir = src_dir.Append(certificates_dir);
+  return true;
+}
+
 }  // namespace
 
 BaseTestServer::SSLOptions::SSLOptions()
     : server_certificate(CERT_OK),
       ocsp_status(OCSP_OK),
       cert_serial(0),
       request_client_certificate(false),
       key_exchanges(SSLOptions::KEY_EXCHANGE_ANY),
       bulk_ciphers(SSLOptions::BULK_CIPHER_ANY),
       record_resume(false),
@@ skipping 208 matching lines @@
   *replacement_path = new_file_path;
   return true;
 }
 
 bool BaseTestServer::LoadTestRootCert() const {
   TestRootCerts* root_certs = TestRootCerts::GetInstance();
   if (!root_certs)
     return false;
 
   // Should always use absolute path to load the root certificate.
-  base::FilePath root_certificate_path = certificates_dir_;
-  if (!certificates_dir_.IsAbsolute()) {
-    base::FilePath src_dir;
-    if (!PathService::Get(base::DIR_SOURCE_ROOT, &src_dir))
-      return false;
-    root_certificate_path = src_dir.Append(certificates_dir_);
-  }
+  base::FilePath root_certificate_path;
+  if (!GetLocalCertificatesDir(certificates_dir_, &root_certificate_path))
+    return false;
 
   return root_certs->AddFromFile(
       root_certificate_path.AppendASCII("root_ca_cert.pem"));
 }
 
+scoped_refptr<X509Certificate> BaseTestServer::GetCertificate() const {
+  base::FilePath certificate_path;
+  if (!GetLocalCertificatesDir(certificates_dir_, &certificate_path))
+    return nullptr;
+
+  base::FilePath certificate_file(ssl_options_.GetCertificateFile());
+  if (certificate_file.value().empty())
+    return nullptr;
+
+  certificate_path = certificate_path.Append(certificate_file);
+
+  std::string cert_data;
+  if (!base::ReadFileToString(certificate_path, &cert_data))
+    return nullptr;
+
+  CertificateList certs_in_file =
+      X509Certificate::CreateCertificateListFromBytes(
+          cert_data.data(), cert_data.size(),
+          X509Certificate::FORMAT_PEM_CERT_SEQUENCE);
+  if (certs_in_file.empty())
+    return nullptr;
+  return certs_in_file[0];
+}
+
 void BaseTestServer::Init(const std::string& host) {
   host_port_pair_ = HostPortPair(host, 0);
 
   // TODO(battre) Remove this after figuring out why the TestServer is flaky.
   // http://crbug.com/96594
   log_to_console_ = true;
 }
 
 void BaseTestServer::SetResourcePath(const base::FilePath& document_root,
                                      const base::FilePath& certificates_dir) {
@@ skipping 166 matching lines @@
 
   return GenerateAdditionalArguments(arguments);
 }
 
 bool BaseTestServer::GenerateAdditionalArguments(
     base::DictionaryValue* arguments) const {
   return true;
 }
 
 }  // namespace net