Add interstitial info to certificate reports

chrome/browser/net/certificate_error_reporter.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 "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 19 matching lines @@
   DCHECK(!upload_url.is_empty());
 }
 
 CertificateErrorReporter::~CertificateErrorReporter() {
   STLDeleteElements(&inflight_requests_);
 }
 
 void CertificateErrorReporter::SendReport(ReportType type,
                                           const std::string& hostname,
                                           const net::SSLInfo& ssl_info) {
-  CertLoggerRequest request;
-  std::string out;
-
-  BuildReport(hostname, ssl_info, &request);
-
-  switch (type) {
-    case REPORT_TYPE_PINNING_VIOLATION:
-      SendCertLoggerRequest(request);
-      break;
-    case REPORT_TYPE_EXTENDED_REPORTING:
-      // TODO(estark): Encrypt the report if not sending over HTTPS
-      DCHECK(upload_url_.SchemeIsSecure());
-      SendCertLoggerRequest(request);
-      break;
-    default:
-      NOTREACHED();
-  }
+  CertLoggerRequest report;
+  BuildReport(hostname, ssl_info, &report);
+  SendReport(type, report);
 }
 
-void CertificateErrorReporter::OnResponseStarted(net::URLRequest* request) {
-  const net::URLRequestStatus& status(request->status());
-  if (!status.is_success()) {
-    LOG(WARNING) << "Certificate upload failed"
-                 << " status:" << status.status()
-                 << " error:" << status.error();
-  } else if (request->GetResponseCode() != 200) {
-    LOG(WARNING) << "Certificate upload HTTP status: "
-                 << request->GetResponseCode();
-  }
-  RequestComplete(request);
+void CertificateErrorReporter::SendReport(ReportType type,
+                                          const CertLoggerRequest& report) {
+  if (type == REPORT_TYPE_EXTENDED_REPORTING) {
+    // TODO(estark): Encrypt the report if not sending over HTTPS

[Ryan Sleevi, 2015/04/16 01:44:10]

FWIW, a tracking bug for this is handy, even if it doesn't have a milestone for
it.

+    DCHECK(upload_url_.SchemeIsSecure());
 }
 
-void CertificateErrorReporter::OnReadCompleted(net::URLRequest* request,
-                                               int bytes_read) {
-}
-
-scoped_ptr<net::URLRequest> CertificateErrorReporter::CreateURLRequest(
-    net::URLRequestContext* context) {
-  scoped_ptr<net::URLRequest> request =
-      context->CreateRequest(upload_url_, net::DEFAULT_PRIORITY, this);
-  if (cookies_preference_ != SEND_COOKIES) {
-    request->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
-                          net::LOAD_DO_NOT_SAVE_COOKIES);
-  }
-  return request.Pass();
-}
-
-void CertificateErrorReporter::SendCertLoggerRequest(
-    const CertLoggerRequest& request) {
-  std::string serialized_request;
-  request.SerializeToString(&serialized_request);
+std::string serialized_report;
+report.SerializeToString(&serialized_report);
 
   scoped_ptr<net::URLRequest> url_request = CreateURLRequest(request_context_);
   url_request->set_method("POST");
 
   scoped_ptr<net::UploadElementReader> reader(
-      net::UploadOwnedBytesElementReader::CreateWithString(serialized_request));
+      net::UploadOwnedBytesElementReader::CreateWithString(serialized_report));
   url_request->set_upload(
       net::ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
 
   net::HttpRequestHeaders headers;
   headers.SetHeader(net::HttpRequestHeaders::kContentType,
                     "x-application/chrome-fraudulent-cert-report");
   url_request->SetExtraRequestHeaders(headers);
 
   net::URLRequest* raw_url_request = url_request.get();
   inflight_requests_.insert(url_request.release());
   raw_url_request->Start();
 }
 
+void CertificateErrorReporter::OnResponseStarted(net::URLRequest* request) {
+  const net::URLRequestStatus& status(request->status());
+  if (!status.is_success()) {
+    LOG(WARNING) << "Certificate upload failed"
+                 << " status:" << status.status()
+                 << " error:" << status.error();
+  } else if (request->GetResponseCode() != 200) {
+    LOG(WARNING) << "Certificate upload HTTP status: "
+                 << request->GetResponseCode();
+  }
+  RequestComplete(request);
+}
+
+void CertificateErrorReporter::OnReadCompleted(net::URLRequest* request,
+                                               int bytes_read) {
+}
+
+void CertificateErrorReporter::BuildReport(const std::string& hostname,
+                                           const net::SSLInfo& ssl_info,
+                                           uint32 validation_result,
+                                           uint32 interstitial_reason,
+                                           ProceedDecision proceed_decision,
+                                           Overridable overridable,
+                                           CertLoggerRequest* out_request) {
+  BuildReport(hostname, ssl_info, out_request);
+  out_request->mutable_interstitial_info()->set_validation_result(
+      validation_result);
+  out_request->mutable_interstitial_info()->set_interstitial_reason(
+      interstitial_reason);
+  out_request->mutable_interstitial_info()->set_user_proceeded(
+      proceed_decision == USER_PROCEEDED);
+  out_request->mutable_interstitial_info()->set_overridable(overridable ==
+                                                            OVERRIDABLE);
+}
+
 void CertificateErrorReporter::BuildReport(const std::string& hostname,
                                            const net::SSLInfo& ssl_info,
                                            CertLoggerRequest* out_request) {
   base::Time now = base::Time::Now();
   out_request->set_time_usec(now.ToInternalValue());
   out_request->set_hostname(hostname);
 
   std::vector<std::string> pem_encoded_chain;
   if (!ssl_info.cert->GetPEMEncodedChain(&pem_encoded_chain))
     LOG(ERROR) << "Could not get PEM encoded chain.";
 
   std::string* cert_chain = out_request->mutable_cert_chain();
   for (size_t i = 0; i < pem_encoded_chain.size(); ++i)
     *cert_chain += pem_encoded_chain[i];
 
   out_request->add_pin(ssl_info.pinning_failure_log);
 }
 
+scoped_ptr<net::URLRequest> CertificateErrorReporter::CreateURLRequest(
+    net::URLRequestContext* context) {
+  scoped_ptr<net::URLRequest> request =
+      context->CreateRequest(upload_url_, net::DEFAULT_PRIORITY, this);
+  if (cookies_preference_ != SEND_COOKIES) {
+    request->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                          net::LOAD_DO_NOT_SAVE_COOKIES);
+  }
+  return request.Pass();
+}
+
+void CertificateErrorReporter::SendCertLoggerRequest(
+    const CertLoggerRequest& request) {
+}

[Ryan Sleevi, 2015/04/16 01:44:10]

Dead code? Broken?

+
 void CertificateErrorReporter::RequestComplete(net::URLRequest* request) {
   std::set<net::URLRequest*>::iterator i = inflight_requests_.find(request);
   DCHECK(i != inflight_requests_.end());
   scoped_ptr<net::URLRequest> url_request(*i);
   inflight_requests_.erase(i);
 }
 
 }  // namespace chrome_browser_net