Add metrics for certificate report uploads

chrome/browser/safe_browsing/certificate_reporting_service.cc

 // Copyright 2016 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/certificate_reporting_service.h"
 
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/time/clock.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 19 matching lines @@
                        const CertificateReportingService::Report& item2) {
   return item1.creation_time > item2.creation_time;
 }
 
 // Records an UMA histogram of the net errors when certificate reports
 // fail to send.
 void RecordUMAOnFailure(int net_error) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("SSL.CertificateErrorReportFailure", -net_error);
 }
 
+void RecordUMAEvent(CertificateReportingService::ReportOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION(CertificateReportingService::kReportEventHistogram,
+                            outcome,
+                            CertificateReportingService::REPORT_EVENT_COUNT);
+}
+
 void CleanupOnIOThread(
     std::unique_ptr<CertificateReportingService::Reporter> reporter) {
   reporter.reset();
 }
 
 }  // namespace
 
+const char CertificateReportingService::kReportEventHistogram[] =
+    "SSL.CertificateErrorReportEvent";
+
 CertificateReportingService::BoundedReportList::BoundedReportList(
     size_t max_size)
     : max_size_(max_size) {
   CHECK(max_size <= 20)
       << "Current implementation is not efficient for a large list.";
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 CertificateReportingService::BoundedReportList::~BoundedReportList() {}
 
 void CertificateReportingService::BoundedReportList::Add(const Report& item) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(items_.size() <= max_size_);
   if (items_.size() == max_size_) {
     const Report& last = items_.back();
     if (item.creation_time <= last.creation_time) {
       // Report older than the oldest item in the queue, ignore.
+      RecordUMAEvent(REPORT_DROPPED_OR_IGNORED);
       return;
     }
     // Reached the maximum item count, remove the oldest item.
     items_.pop_back();
+    RecordUMAEvent(REPORT_DROPPED_OR_IGNORED);
   }
   items_.push_back(item);
   std::sort(items_.begin(), items_.end(), ReportCompareFunc);
 }
 
 void CertificateReportingService::BoundedReportList::Clear() {
   items_.clear();
 }
 
 const std::vector<CertificateReportingService::Report>&
@@ skipping 29 matching lines @@
   if (!retries_enabled_) {
     return;
   }
   const base::Time now = clock_->Now();
   // Copy pending reports and clear the retry list.
   std::vector<Report> items = retry_list_->items();
   retry_list_->Clear();
   for (Report& report : items) {
     if (report.creation_time < now - report_ttl_) {
       // Report too old, ignore.
+      RecordUMAEvent(REPORT_DROPPED_OR_IGNORED);
       continue;
     }
     if (!report.is_retried) {
       // If this is the first retry, deserialize the report, set its retry bit
       // and serialize again.
       certificate_reporting::ErrorReport error_report;
       CHECK(error_report.InitializeFromString(report.serialized_report));
       error_report.SetIsRetryUpload(true);
       CHECK(error_report.Serialize(&report.serialized_report));
     }
@@ skipping 10 matching lines @@
 
 CertificateReportingService::BoundedReportList*
 CertificateReportingService::Reporter::GetQueueForTesting() const {
   return retry_list_.get();
 }
 
 void CertificateReportingService::Reporter::SendInternal(
     const CertificateReportingService::Report& report) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   inflight_reports_.insert(std::make_pair(report.report_id, report));
+  RecordUMAEvent(REPORT_SUBMITTED);
   error_reporter_->SendExtendedReportingReport(
       report.serialized_report,
       base::Bind(&CertificateReportingService::Reporter::SuccessCallback,
                  weak_factory_.GetWeakPtr(), report.report_id),
       base::Bind(&CertificateReportingService::Reporter::ErrorCallback,
                  weak_factory_.GetWeakPtr(), report.report_id));
 }
 
 void CertificateReportingService::Reporter::ErrorCallback(
     int report_id,
     const GURL& url,
     int net_error,
     int http_response_code) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   RecordUMAOnFailure(net_error);
+  RecordUMAEvent(REPORT_FAILED);
   if (retries_enabled_) {
     auto it = inflight_reports_.find(report_id);
     DCHECK(it != inflight_reports_.end());
     retry_list_->Add(it->second);
   }
   CHECK_GT(inflight_reports_.erase(report_id), 0u);
 }
 
 void CertificateReportingService::Reporter::SuccessCallback(int report_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  RecordUMAEvent(REPORT_SUCCESSFUL);
   CHECK_GT(inflight_reports_.erase(report_id), 0u);
 }
 
 CertificateReportingService::CertificateReportingService(
     safe_browsing::SafeBrowsingService* safe_browsing_service,
     scoped_refptr<net::URLRequestContextGetter> url_request_context_getter,
     Profile* profile,
     uint8_t server_public_key[/* 32 */],
     uint32_t server_public_key_version,
     size_t max_queued_report_count,
@@ skipping 140 matching lines @@
 }
 
 void CertificateReportingService::OnPreferenceChanged() {
   safe_browsing::SafeBrowsingService* safe_browsing_service_ =
       g_browser_process->safe_browsing_service();
   const bool enabled = safe_browsing_service_ &&
                        safe_browsing_service_->enabled_by_prefs() &&
                        safe_browsing::IsExtendedReportingEnabled(pref_service_);
   SetEnabled(enabled);
 }