Change SupportsSpdy dict, SpdySettingsMap, ServerNetworkStatsMap, AlternativeServiceMap and disk da…

net/http/http_server_properties.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_HTTP_SERVER_PROPERTIES_H_
 #define NET_HTTP_HTTP_SERVER_PROPERTIES_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <tuple>
 #include <vector>
 
 #include "base/containers/mru_cache.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_bandwidth.h"
 #include "net/quic/quic_server_id.h"
 #include "net/socket/next_proto.h"
 #include "net/spdy/spdy_framer.h"  // TODO(willchan): Reconsider this.
 #include "net/spdy/spdy_protocol.h"
+#include "url/scheme_host_port.h"
 
 namespace base {
 class Value;
 }
 
 namespace net {
 
 class IPAddress;
 struct SSLConfig;
 
@@ skipping 160 matching lines @@
   bool operator!=(const ServerNetworkStats& other) const {
     return !this->operator==(other);
   }
 
   base::TimeDelta srtt;
   QuicBandwidth bandwidth_estimate;
 };
 
 typedef std::vector<AlternativeService> AlternativeServiceVector;
 typedef std::vector<AlternativeServiceInfo> AlternativeServiceInfoVector;
-typedef base::MRUCache<HostPortPair, AlternativeServiceInfoVector>
+typedef base::MRUCache<url::SchemeHostPort, AlternativeServiceInfoVector>
     AlternativeServiceMap;
-typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
-typedef base::MRUCache<HostPortPair, ServerNetworkStats> ServerNetworkStatsMap;
+typedef base::MRUCache<url::SchemeHostPort, SettingsMap> SpdySettingsMap;
+typedef base::MRUCache<url::SchemeHostPort, ServerNetworkStats>
+    ServerNetworkStatsMap;
 typedef base::MRUCache<QuicServerId, std::string> QuicServerInfoMap;
 
 // Persist 5 QUIC Servers. This is mainly used by cronet.
 const int kMaxQuicServersToPersist = 5;
 
 extern const char kAlternateProtocolHeader[];
 extern const char kAlternativeServiceHeader[];
 
 // The interface for setting/retrieving the HTTP server properties.
 // Currently, this class manages servers':
@@ skipping 10 matching lines @@
   virtual ~HttpServerProperties() {}
 
   // Gets a weak pointer for this object.
   virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
 
   // Deletes all data.
   virtual void Clear() = 0;
 
   // Returns true if |server| supports a network protocol which honors
   // request prioritization.
-  virtual bool SupportsRequestPriority(const HostPortPair& server) = 0;
+  virtual bool SupportsRequestPriority(const url::SchemeHostPort& server) = 0;
 
   // Returns the value set by SetSupportsSpdy(). If not set, returns false.
-  virtual bool GetSupportsSpdy(const HostPortPair& server) = 0;
+  virtual bool GetSupportsSpdy(const url::SchemeHostPort& server) = 0;
 
   // Add |server| into the persistent store. Should only be called from IO
   // thread.
-  virtual void SetSupportsSpdy(const HostPortPair& server,
+  virtual void SetSupportsSpdy(const url::SchemeHostPort& server,
                                bool support_spdy) = 0;
 
   // Returns true if |server| has required HTTP/1.1 via HTTP/2 error code.
   virtual bool RequiresHTTP11(const HostPortPair& server) = 0;
 
   // Require HTTP/1.1 on subsequent connections.  Not persisted.
   virtual void SetHTTP11Required(const HostPortPair& server) = 0;
 
   // Modify SSLConfig to force HTTP/1.1.
   static void ForceHTTP11(SSLConfig* ssl_config);
 
   // Modify SSLConfig to force HTTP/1.1 if necessary.
   virtual void MaybeForceHTTP11(const HostPortPair& server,
                                 SSLConfig* ssl_config) = 0;
 
   // Return all alternative services for |origin|, including broken ones.
   // Returned alternative services never have empty hostnames.
   virtual AlternativeServiceVector GetAlternativeServices(
-      const HostPortPair& origin) = 0;
+      const url::SchemeHostPort& origin) = 0;
 
   // Set a single alternative service for |origin|.  Previous alternative
   // services for |origin| are discarded.
   // |alternative_service.host| may be empty.
   // Return true if |alternative_service_map_| is changed.
   virtual bool SetAlternativeService(
-      const HostPortPair& origin,
+      const url::SchemeHostPort& origin,
       const AlternativeService& alternative_service,
       base::Time expiration) = 0;
 
   // Set alternative services for |origin|.  Previous alternative services for
   // |origin| are discarded.
   // Hostnames in |alternative_service_info_vector| may be empty.
   // Return true if |alternative_service_map_| is changed.
   virtual bool SetAlternativeServices(
-      const HostPortPair& origin,
+      const url::SchemeHostPort& origin,
       const AlternativeServiceInfoVector& alternative_service_info_vector) = 0;
 
   // Marks |alternative_service| as broken.
   // |alternative_service.host| must not be empty.
   virtual void MarkAlternativeServiceBroken(
       const AlternativeService& alternative_service) = 0;
 
   // Marks |alternative_service| as recently broken.
   // |alternative_service.host| must not be empty.
   virtual void MarkAlternativeServiceRecentlyBroken(
       const AlternativeService& alternative_service) = 0;
 
   // Returns true iff |alternative_service| is currently broken.
   // |alternative_service.host| must not be empty.
   virtual bool IsAlternativeServiceBroken(
       const AlternativeService& alternative_service) const = 0;
 
   // Returns true iff |alternative_service| was recently broken.
   // |alternative_service.host| must not be empty.
   virtual bool WasAlternativeServiceRecentlyBroken(
       const AlternativeService& alternative_service) = 0;
 
   // Confirms that |alternative_service| is working.
   // |alternative_service.host| must not be empty.
   virtual void ConfirmAlternativeService(
       const AlternativeService& alternative_service) = 0;
 
   // Clear all alternative services for |origin|.
-  virtual void ClearAlternativeServices(const HostPortPair& origin) = 0;
+  virtual void ClearAlternativeServices(const url::SchemeHostPort& origin) = 0;
 
   // Returns all alternative service mappings.
   // Returned alternative services may have empty hostnames.
   virtual const AlternativeServiceMap& alternative_service_map() const = 0;
 
   // Returns all alternative service mappings as human readable strings.
   // Empty alternative service hostnames will be printed as such.
   virtual std::unique_ptr<base::Value> GetAlternativeServiceInfoAsValue()
       const = 0;
 
   // Gets a reference to the SettingsMap stored for a host.
   // If no settings are stored, returns an empty SettingsMap.
   virtual const SettingsMap& GetSpdySettings(
-      const HostPortPair& host_port_pair) = 0;
+      const url::SchemeHostPort& server) = 0;
 
   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
   // is to be persisted.
-  virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
+  virtual bool SetSpdySetting(const url::SchemeHostPort& server,
                               SpdySettingsIds id,
                               SpdySettingsFlags flags,
                               uint32_t value) = 0;
 
   // Clears all SPDY settings for a host.
-  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) = 0;
+  virtual void ClearSpdySettings(const url::SchemeHostPort& server) = 0;
 
   // Clears all SPDY settings for all hosts.
   virtual void ClearAllSpdySettings() = 0;
 
   // Returns all persistent SPDY settings.
   virtual const SpdySettingsMap& spdy_settings_map() const = 0;
 
   virtual bool GetSupportsQuic(IPAddress* last_address) const = 0;
 
   virtual void SetSupportsQuic(bool used_quic,
                                const IPAddress& last_address) = 0;
 
   // Sets |stats| for |host_port_pair|.
-  virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
+  virtual void SetServerNetworkStats(const url::SchemeHostPort& server,
                                      ServerNetworkStats stats) = 0;
 
   virtual const ServerNetworkStats* GetServerNetworkStats(
-      const HostPortPair& host_port_pair) = 0;
+      const url::SchemeHostPort& server) = 0;
 
   virtual const ServerNetworkStatsMap& server_network_stats_map() const = 0;
 
   // Save QuicServerInfo (in std::string form) for the given |server_id|.
   // Returns true if the value has changed otherwise it returns false.
   virtual bool SetQuicServerInfo(const QuicServerId& server_id,
                                  const std::string& server_info) = 0;
 
   // Get QuicServerInfo (in std::string form) for the given |server_id|.
   virtual const std::string* GetQuicServerInfo(
       const QuicServerId& server_id) = 0;
 
   // Returns all persistent QuicServerInfo objects.
   virtual const QuicServerInfoMap& quic_server_info_map() const = 0;
 
   // Returns the number of server configs (QuicServerInfo objects) persisted.
   virtual size_t max_server_configs_stored_in_properties() const = 0;
 
   // Sets the number of server configs (QuicServerInfo objects) to be persisted.
   virtual void SetMaxServerConfigsStoredInProperties(
       size_t max_server_configs_stored_in_properties) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_