Add report_id to ErrorReporter interface.

components/certificate_reporting/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 "components/certificate_reporting/error_reporter.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/sparse_histogram.h"
 #include "components/certificate_reporting/encrypted_cert_logger.pb.h"
 #include "crypto/aead.h"
 #include "crypto/curve25519.h"
 #include "crypto/hkdf.h"
 #include "crypto/random.h"
 #include "net/url_request/report_sender.h"
 
 namespace certificate_reporting {
 
 namespace {
@@ skipping 67 matching lines @@
 
   encrypted_report->set_encrypted_report(ciphertext);
   encrypted_report->set_server_public_key_version(server_public_key_version);
   encrypted_report->set_client_public_key(reinterpret_cast<char*>(public_key),
                                           sizeof(public_key));
   encrypted_report->set_algorithm(
       EncryptedCertLoggerRequest::AEAD_ECDH_AES_128_CTR_HMAC_SHA256);
   return true;
 }
 
-// Records an UMA histogram of the net errors when certificate reports
-// fail to send.
-void RecordUMAOnFailure(const GURL& report_uri, int net_error, int report_id) {
-  UMA_HISTOGRAM_SPARSE_SLOWLY("SSL.CertificateErrorReportFailure", -net_error);
-}
-
-void DoNothingOnSuccess(int report_id) {}
-
 }  // namespace
 
 ErrorReporter::ErrorReporter(
     net::URLRequestContext* request_context,
     const GURL& upload_url,
     net::ReportSender::CookiesPreference cookies_preference)
-    : ErrorReporter(
-          upload_url,
-          kServerPublicKey,
-          kServerPublicKeyVersion,
-          base::MakeUnique<net::ReportSender>(request_context,
-                                              cookies_preference,
-                                              base::Bind(RecordUMAOnFailure),
-                                              base::Bind(DoNothingOnSuccess))) {
-}
+    : ErrorReporter(upload_url,
+                    kServerPublicKey,
+                    kServerPublicKeyVersion,
+                    base::MakeUnique<net::ReportSender>(request_context,
+                                                        cookies_preference)) {}
 
 ErrorReporter::ErrorReporter(
     const GURL& upload_url,
     const uint8_t server_public_key[/* 32 */],
     const uint32_t server_public_key_version,
     std::unique_ptr<net::ReportSender> certificate_report_sender)
     : certificate_report_sender_(std::move(certificate_report_sender)),
       upload_url_(upload_url),
       server_public_key_(server_public_key),
       server_public_key_version_(server_public_key_version) {
   DCHECK(certificate_report_sender_);
   DCHECK(!upload_url.is_empty());
 }
 
 ErrorReporter::~ErrorReporter() {}
 
 void ErrorReporter::SendExtendedReportingReport(
-    const std::string& serialized_report) {
+    const std::string& serialized_report,
+    int report_id) {
   if (upload_url_.SchemeIsCryptographic()) {
     certificate_report_sender_->Send(upload_url_, "application/octet-stream",
-                                     serialized_report, 0);
-  } else {
-    EncryptedCertLoggerRequest encrypted_report;
-    if (!EncryptSerializedReport(server_public_key_, server_public_key_version_,
-                                 serialized_report, &encrypted_report)) {
-      LOG(ERROR) << "Failed to encrypt serialized report.";
-      return;
-    }
-    std::string serialized_encrypted_report;
-    encrypted_report.SerializeToString(&serialized_encrypted_report);
-    certificate_report_sender_->Send(upload_url_, "application/octet-stream",
-                                     serialized_encrypted_report, 0);
+                                     serialized_report, report_id);
+    return;
   }
+  EncryptedCertLoggerRequest encrypted_report;
+  if (!EncryptSerializedReport(server_public_key_, server_public_key_version_,
+                               serialized_report, &encrypted_report)) {
+    LOG(ERROR) << "Failed to encrypt serialized report.";
+    return;
+  }
+  std::string serialized_encrypted_report;
+  encrypted_report.SerializeToString(&serialized_encrypted_report);
+  certificate_report_sender_->Send(upload_url_, "application/octet-stream",
+                                   serialized_encrypted_report, report_id);
 }
 
 // Used only by tests.
 bool ErrorReporter::DecryptErrorReport(
     const uint8_t server_private_key[32],
     const EncryptedCertLoggerRequest& encrypted_report,
     std::string* decrypted_serialized_report) {
   crypto::Aead aead(crypto::Aead::AES_128_CTR_HMAC_SHA256);
   std::string key;
   if (!GetHkdfSubkeySecret(aead.KeyLength(), server_private_key,
                            reinterpret_cast<const uint8_t*>(
                                encrypted_report.client_public_key().data()),
                            &key)) {
     LOG(ERROR) << "Error getting subkey secret.";
     return false;
   }
   aead.Init(&key);
 
   // Use an all-zero nonce because the key is random per-message.
   std::string nonce(aead.NonceLength(), 0);
 
   return aead.Open(encrypted_report.encrypted_report(), nonce, std::string(),
                    decrypted_serialized_report);
 }
 
+void ErrorReporter::SetErrorCallback(
+    const base::Callback<void(const GURL&, int, int)>& callback) {
+  certificate_report_sender_->SetErrorCallback(callback);
+}
+
+void ErrorReporter::SetSuccessCallback(
+    const base::Callback<void(int)>& callback) {
+  certificate_report_sender_->SetSuccessCallback(callback);
+}
+
 }  // namespace certificate_reporting