Home | History | Annotate | Download | only in http 
      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_
    254