src/net/http/http_server_properties.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_HTTP_HTTP_SERVER_PROPERTIES_H_
   6 #define NET_HTTP_HTTP_SERVER_PROPERTIES_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include "base/basictypes.h"
  11 #include "base/containers/mru_cache.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/time/time.h"
  14 #include "net/base/host_port_pair.h"
  15 #include "net/base/net_export.h"
  16 #include "net/socket/next_proto.h"
  17 #include "net/spdy/spdy_framer.h"  // TODO(willchan): Reconsider this.
  18
  19 namespace net {
  20
  21 enum AlternateProtocolExperiment {
  22   // 200 alternate_protocol servers are loaded (persisted 200 MRU servers).
  23   ALTERNATE_PROTOCOL_NOT_PART_OF_EXPERIMENT = 0,
  24   // 200 alternate_protocol servers are loaded (persisted 1000 MRU servers).
  25   ALTERNATE_PROTOCOL_TRUNCATED_200_SERVERS,
  26   // 1000 alternate_protocol servers are loaded (persisted 1000 MRU servers).
  27   ALTERNATE_PROTOCOL_TRUNCATED_1000_SERVERS,
  28 };
  29
  30 enum AlternateProtocolUsage {
  31   // Alternate Protocol was used without racing a normal connection.
  32   ALTERNATE_PROTOCOL_USAGE_NO_RACE = 0,
  33   // Alternate Protocol was used by winning a race with a normal connection.
  34   ALTERNATE_PROTOCOL_USAGE_WON_RACE = 1,
  35   // Alternate Protocol was not used by losing a race with a normal connection.
  36   ALTERNATE_PROTOCOL_USAGE_LOST_RACE = 2,
  37   // Alternate Protocol was not used because no Alternate-Protocol information
  38   // was available when the request was issued, but an Alternate-Protocol header
  39   // was present in the response.
  40   ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING = 3,
  41   // Alternate Protocol was not used because it was marked broken.
  42   ALTERNATE_PROTOCOL_USAGE_BROKEN = 4,
  43   // Maximum value for the enum.
  44   ALTERNATE_PROTOCOL_USAGE_MAX,
  45 };
  46
  47 // Log a histogram to reflect |usage| and |alternate_protocol_experiment|.
  48 NET_EXPORT void HistogramAlternateProtocolUsage(
  49     AlternateProtocolUsage usage,
  50     AlternateProtocolExperiment alternate_protocol_experiment);
  51
  52 enum BrokenAlternateProtocolLocation {
  53   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB = 0,
  54   BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY = 1,
  55   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT = 2,
  56   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN = 3,
  57   BROKEN_ALTERNATE_PROTOCOL_LOCATION_MAX,
  58 };
  59
  60 // Log a histogram to reflect |location|.
  61 NET_EXPORT void HistogramBrokenAlternateProtocolLocation(
  62     BrokenAlternateProtocolLocation location);
  63
  64 enum AlternateProtocol {
  65   DEPRECATED_NPN_SPDY_2 = 0,
  66   ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION = DEPRECATED_NPN_SPDY_2,
  67   NPN_SPDY_MINIMUM_VERSION = DEPRECATED_NPN_SPDY_2,
  68   NPN_SPDY_3,
  69   NPN_SPDY_3_1,
  70   NPN_SPDY_4,  // SPDY4 is HTTP/2.
  71   NPN_SPDY_MAXIMUM_VERSION = NPN_SPDY_4,
  72   QUIC,
  73   ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION = QUIC,
  74   ALTERNATE_PROTOCOL_BROKEN,  // The alternate protocol is known to be broken.
  75   UNINITIALIZED_ALTERNATE_PROTOCOL,
  76 };
  77
  78 // Simply returns whether |protocol| is between
  79 // ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION and
  80 // ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION (inclusive).
  81 NET_EXPORT bool IsAlternateProtocolValid(AlternateProtocol protocol);
  82
  83 enum AlternateProtocolSize {
  84   NUM_VALID_ALTERNATE_PROTOCOLS =
  85     ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION -
  86     ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION + 1,
  87 };
  88
  89 NET_EXPORT const char* AlternateProtocolToString(AlternateProtocol protocol);
  90 NET_EXPORT AlternateProtocol AlternateProtocolFromString(
  91     const std::string& str);
  92 NET_EXPORT_PRIVATE AlternateProtocol AlternateProtocolFromNextProto(
  93     NextProto next_proto);
  94
  95 struct NET_EXPORT AlternateProtocolInfo {
  96   AlternateProtocolInfo(uint16 port,
  97                         AlternateProtocol protocol,
  98                         double probability)
  99       : port(port),
 100         protocol(protocol),
 101         probability(probability) {}
 102
 103   bool Equals(const AlternateProtocolInfo& other) const {
 104     return port == other.port &&
 105         protocol == other.protocol &&
 106         probability == other.probability;
 107   }
 108
 109   std::string ToString() const;
 110
 111   uint16 port;
 112   AlternateProtocol protocol;
 113   double probability;
 114 };
 115
 116 struct NET_EXPORT SupportsQuic {
 117   SupportsQuic() : used_quic(false) {}
 118   SupportsQuic(bool used_quic, const std::string& address)
 119       : used_quic(used_quic),
 120         address(address) {}
 121
 122   bool Equals(const SupportsQuic& other) const {
 123     return used_quic == other.used_quic && address == other.address;
 124   }
 125
 126   bool used_quic;
 127   std::string address;
 128 };
 129
 130 typedef base::MRUCache<
 131     HostPortPair, AlternateProtocolInfo> AlternateProtocolMap;
 132 typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
 133 typedef std::map<HostPortPair, SupportsQuic> SupportsQuicMap;
 134
 135 extern const char kAlternateProtocolHeader[];
 136
 137 // The interface for setting/retrieving the HTTP server properties.
 138 // Currently, this class manages servers':
 139 // * SPDY support (based on NPN results)
 140 // * Alternate-Protocol support
 141 // * Spdy Settings (like CWND ID field)
 142 class NET_EXPORT HttpServerProperties {
 143  public:
 144   struct NetworkStats {
 145     base::TimeDelta srtt;
 146     uint64 bandwidth_estimate;
 147   };
 148
 149   HttpServerProperties() {}
 150   virtual ~HttpServerProperties() {}
 151
 152   // Gets a weak pointer for this object.
 153   virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
 154
 155   // Deletes all data.
 156   virtual void Clear() = 0;
 157
 158   // Returns true if |server| supports SPDY.
 159   virtual bool SupportsSpdy(const HostPortPair& server) = 0;
 160
 161   // Add |server| into the persistent store. Should only be called from IO
 162   // thread.
 163   virtual void SetSupportsSpdy(const HostPortPair& server,
 164                                bool support_spdy) = 0;
 165
 166   // Returns true if |server| has an Alternate-Protocol header.
 167   virtual bool HasAlternateProtocol(const HostPortPair& server) = 0;
 168
 169   // Returns the Alternate-Protocol and port for |server|.
 170   // HasAlternateProtocol(server) must be true.
 171   virtual AlternateProtocolInfo GetAlternateProtocol(
 172       const HostPortPair& server) = 0;
 173
 174   // Sets the Alternate-Protocol for |server|.
 175   virtual void SetAlternateProtocol(const HostPortPair& server,
 176                                     uint16 alternate_port,
 177                                     AlternateProtocol alternate_protocol,
 178                                     double probability) = 0;
 179
 180   // Sets the Alternate-Protocol for |server| to be BROKEN.
 181   virtual void SetBrokenAlternateProtocol(const HostPortPair& server) = 0;
 182
 183   // Returns true if Alternate-Protocol for |server| was recently BROKEN.
 184   virtual bool WasAlternateProtocolRecentlyBroken(
 185       const HostPortPair& server) = 0;
 186
 187   // Confirms that Alternate-Protocol for |server| is working.
 188   virtual void ConfirmAlternateProtocol(const HostPortPair& server) = 0;
 189
 190   // Clears the Alternate-Protocol for |server|.
 191   virtual void ClearAlternateProtocol(const HostPortPair& server) = 0;
 192
 193   // Returns all Alternate-Protocol mappings.
 194   virtual const AlternateProtocolMap& alternate_protocol_map() const = 0;
 195
 196   virtual void SetAlternateProtocolExperiment(
 197       AlternateProtocolExperiment experiment) = 0;
 198
 199   // Sets the threshold to be used when evaluating Alternate-Protocol
 200   // advertisments. Only advertisements with a with a probability
 201   // greater than |threshold| will be honored. |threshold| must be
 202   // between 0 and 1 inclusive. Hence, a threshold of 0 implies that
 203   // all advertisements will be honored.
 204   virtual void SetAlternateProtocolProbabilityThreshold(
 205       double threshold) = 0;
 206
 207   virtual AlternateProtocolExperiment GetAlternateProtocolExperiment()
 208       const = 0;
 209
 210   // Gets a reference to the SettingsMap stored for a host.
 211   // If no settings are stored, returns an empty SettingsMap.
 212   virtual const SettingsMap& GetSpdySettings(
 213       const HostPortPair& host_port_pair) = 0;
 214
 215   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
 216   // is to be persisted.
 217   virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
 218                               SpdySettingsIds id,
 219                               SpdySettingsFlags flags,
 220                               uint32 value) = 0;
 221
 222   // Clears all SPDY settings for a host.
 223   virtual void ClearSpdySettings(const HostPortPair& host_port_pair) = 0;
 224
 225   // Clears all SPDY settings for all hosts.
 226   virtual void ClearAllSpdySettings() = 0;
 227
 228   // Returns all persistent SPDY settings.
 229   virtual const SpdySettingsMap& spdy_settings_map() const = 0;
 230
 231   // TODO(rtenneti): Make SupportsQuic a global (instead of per host_port_pair).
 232   virtual SupportsQuic GetSupportsQuic(
 233       const HostPortPair& host_port_pair) const = 0;
 234
 235   virtual void SetSupportsQuic(const HostPortPair& host_port_pair,
 236                                bool used_quic,
 237                                const std::string& address) = 0;
 238
 239   virtual const SupportsQuicMap& supports_quic_map() const = 0;
 240
 241   virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
 242                                      NetworkStats stats) = 0;
 243
 244   virtual const NetworkStats* GetServerNetworkStats(
 245       const HostPortPair& host_port_pair) const = 0;
 246
 247  private:
 248   DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
 249 };
 250
 251 }  // namespace net
 252
 253 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_