Refactor CertificateReportSender

net/http/transport_security_state.h

 // 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.
 
 #ifndef NET_HTTP_TRANSPORT_SECURITY_STATE_H_
 #define NET_HTTP_TRANSPORT_SECURITY_STATE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 198 matching lines @@
     std::string domain;
 
     // The URI reports are sent to if a valid OCSP response is not stapled
     GURL report_uri;
 
     // True if subdomains are subject to this policy
     bool include_subdomains;
   };
 
   // An interface for asynchronously sending HPKP violation reports.
-  class NET_EXPORT ReportSender {
+  class NET_EXPORT ReportSenderInterface {
    public:
     // Sends the given serialized |report| to |report_uri|.
     virtual void Send(const GURL& report_uri, const std::string& report) = 0;
 
     // Sets a callback to be called when report sending fails.
     virtual void SetErrorCallback(
         const base::Callback<void(const GURL&, int)>& error_callback) = 0;
 
    protected:
-    virtual ~ReportSender() {}
+    virtual ~ReportSenderInterface() {}
   };
 
   // An interface for building and asynchronously sending reports when a
   // site expects valid Certificate Transparency information but it
   // wasn't supplied.
   class NET_EXPORT ExpectCTReporter {
    public:
     // Called when the host in |host_port_pair| has opted in to have
     // reports about Expect CT policy violations sent to |report_uri|,
     // and such a violation has occurred.
@@ skipping 27 matching lines @@
                           std::string* failure_log);
   bool HasPublicKeyPins(const std::string& host);
 
   // Assign a |Delegate| for persisting the transport security state. If
   // |NULL|, state will not be persisted. The caller retains
   // ownership of |delegate|.
   // Note: This is only used for serializing/deserializing the
   // TransportSecurityState.
   void SetDelegate(Delegate* delegate);
 
-  void SetReportSender(ReportSender* report_sender);
+  void SetReportSender(ReportSenderInterface* report_sender);
 
   void SetExpectCTReporter(ExpectCTReporter* expect_ct_reporter);
 
   // Clears all dynamic data (e.g. HSTS and HPKP data).
   //
   // Does NOT persist changes using the Delegate, as this function is only
   // used to clear any dynamic data prior to re-loading it from a file.
   // Note: This is only used for serializing/deserializing the
   // TransportSecurityState.
   void ClearDynamicData();
@@ skipping 187 matching lines @@
   // The sets of hosts that have enabled TransportSecurity. |domain| will always
   // be empty for a STSState or PKPState in these maps; the domain
   // comes from the map keys instead. In addition, |upgrade_mode| in the
   // STSState is never MODE_DEFAULT and |HasPublicKeyPins| in the PKPState
   // always returns true.
   STSStateMap enabled_sts_hosts_;
   PKPStateMap enabled_pkp_hosts_;
 
   Delegate* delegate_;
 
-  ReportSender* report_sender_;
+  ReportSenderInterface* report_sender_;
 
   // True if static pins should be used.
   bool enable_static_pins_;
 
   // True if static expect-CT state should be used.
   bool enable_static_expect_ct_;
 
   // True if static expect-staple state should be used.
   bool enable_static_expect_staple_;
 
   ExpectCTReporter* expect_ct_reporter_;
 
   // Keeps track of reports that have been sent recently for
   // rate-limiting.
   ExpiringCache<std::string, bool, base::TimeTicks, std::less<base::TimeTicks>>
       sent_reports_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportSecurityState);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_TRANSPORT_SECURITY_STATE_H_