Add report_id to ErrorReporter interface.

chrome/browser/safe_browsing/ping_manager.cc

 // Copyright (c) 2012 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/safe_browsing/ping_manager.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/safe_browsing/permission_reporter.h"
 #include "components/certificate_reporting/error_reporter.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
@@ skipping 38 matching lines @@
     const net::URLRequestStatus& status,
     net::NetLogCaptureMode) {
   std::unique_ptr<base::DictionaryValue> event_params(
       new base::DictionaryValue());
   event_params->SetInteger("status", status.status());
   event_params->SetInteger("error", status.error());
   net_log.source().AddToEventParameters(event_params.get());
   return std::move(event_params);
 }
 
+// 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);
+}
+
 }  // namespace
 
 namespace safe_browsing {
 
 // SafeBrowsingPingManager implementation ----------------------------------
 
 // static
 std::unique_ptr<SafeBrowsingPingManager> SafeBrowsingPingManager::Create(
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config) {
@@ skipping 12 matching lines @@
 
   if (request_context_getter) {
     net::ReportSender::CookiesPreference cookies_preference;
     GURL certificate_upload_url;
     cookies_preference = net::ReportSender::DO_NOT_SEND_COOKIES;
     certificate_upload_url = GURL(kExtendedReportingUploadUrlInsecure);
 
     certificate_error_reporter_.reset(new certificate_reporting::ErrorReporter(
         request_context_getter->GetURLRequestContext(), certificate_upload_url,
         cookies_preference));
+    certificate_error_reporter_->SetErrorCallback(
+        base::Bind(&RecordUMAOnFailure));
 
     permission_reporter_.reset(
         new PermissionReporter(request_context_getter->GetURLRequestContext()));
 
     net_log_ = net::NetLogWithSource::Make(
         request_context_getter->GetURLRequestContext()->net_log(),
         net::NetLogSourceType::SAFE_BROWSING);
   }
 
   version_ = SafeBrowsingProtocolManagerHelper::Version();
@@ skipping 67 matching lines @@
       base::Bind(&NetLogPingStartCallback, net_log_, fetcher->GetOriginalURL(),
                  report_base64));
 
   fetcher->Start();
   safebrowsing_reports_.insert(std::move(fetcher));
 }
 
 void SafeBrowsingPingManager::ReportInvalidCertificateChain(
     const std::string& serialized_report) {
   DCHECK(certificate_error_reporter_);
-  certificate_error_reporter_->SendExtendedReportingReport(serialized_report);
+  certificate_error_reporter_->SendExtendedReportingReport(serialized_report,
+                                                           0);
 }
 
 void SafeBrowsingPingManager::SetCertificateErrorReporterForTesting(
     std::unique_ptr<certificate_reporting::ErrorReporter>
         certificate_error_reporter) {
   certificate_error_reporter_ = std::move(certificate_error_reporter);
 }
 
 void SafeBrowsingPingManager::ReportPermissionAction(
     const PermissionReportInfo& report_info) {
@@ skipping 90 matching lines @@
           version_.c_str());
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return GURL(url);
 }
 
 }  // namespace safe_browsing