Add response code to the success callback of ReportSender

net/http/transport_security_state.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 "net/http/transport_security_state.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 50 matching lines @@
     DCHECK_EQ(HASH_VALUE_SHA256, rhs.tag);
     return memcmp(lhs.data, rhs.data(), rhs.size()) < 0;
   }
 
   bool operator()(const HashValue& lhs, const SHA256HashValue& rhs) const {
     DCHECK_EQ(HASH_VALUE_SHA256, lhs.tag);
     return memcmp(lhs.data(), rhs.data, lhs.size()) < 0;
   }
 };
 
-void RecordUMAForHPKPReportFailure(const GURL& report_uri, int net_error) {
+void RecordUMAForHPKPReportFailure(const GURL& report_uri,
+                                   int net_error,
+                                   int response_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.PublicKeyPinReportSendingFailure2",
                               -net_error);
 }
 
 std::string TimeToISO8601(const base::Time& t) {
   base::Time::Exploded exploded;
   t.UTCExplode(&exploded);
   return base::StringPrintf(
       "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", exploded.year, exploded.month,
       exploded.day_of_month, exploded.hour, exploded.minute, exploded.second,
@@ skipping 736 matching lines @@
     return;
   }
 
   std::string serialized_report;
   if (!SerializeExpectStapleReport(host_port_pair, ssl_info, ocsp_response,
                                    &serialized_report)) {
     return;
   }
   report_sender_->Send(expect_staple_state.report_uri,
                        "application/json; charset=utf-8", serialized_report,
-                       base::Closure(),
+                       base::Callback<void(int)>(),
                        base::Bind(RecordUMAForHPKPReportFailure));
 }
 
 bool TransportSecurityState::HasPublicKeyPins(const std::string& host) {
   PKPState dynamic_state;
   if (GetDynamicPKPState(host, &dynamic_state))
     return dynamic_state.HasPublicKeyPins();
 
   STSState unused;
   PKPState static_pkp_state;
@@ skipping 237 matching lines @@
   // also prevents accidental loops (a.com triggers a report to b.com
   // which triggers a report to a.com). See section 2.1.4 of RFC 7469.
   if (sent_reports_cache_.Get(report_cache_key, base::TimeTicks::Now()))
     return PKPStatus::VIOLATED;
   sent_reports_cache_.Put(
       report_cache_key, true, base::TimeTicks::Now(),
       base::TimeTicks::Now() +
           base::TimeDelta::FromMinutes(kTimeToRememberHPKPReportsMins));
 
   report_sender_->Send(pkp_state.report_uri, "application/json; charset=utf-8",
-                       serialized_report, base::Closure(),
+                       serialized_report, base::Callback<void(int)>(),
                        base::Bind(RecordUMAForHPKPReportFailure));
   return PKPStatus::VIOLATED;
 }
 
 bool TransportSecurityState::GetStaticExpectCTState(
     const std::string& host,
     ExpectCTState* expect_ct_state) const {
   DCHECK(CalledOnValidThread());
 
   if (!IsBuildTimely())
@@ skipping 557 matching lines @@
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace