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/memory/weak_ptr.h"
  12 #include "net/base/host_port_pair.h"
  13 #include "net/base/net_export.h"
  14 #include "net/http/http_pipelined_host_capability.h"
  15 #include "net/socket/next_proto.h"
  16 #include "net/spdy/spdy_framer.h"  // TODO(willchan): Reconsider this.
  17
  18 namespace net {
  19
  20 enum AlternateProtocol {
  21   DEPRECATED_NPN_SPDY_2 = 0,
  22   ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION = DEPRECATED_NPN_SPDY_2,
  23   NPN_SPDY_MINIMUM_VERSION = DEPRECATED_NPN_SPDY_2,
  24   NPN_SPDY_3,
  25   NPN_SPDY_3_1,
  26   NPN_SPDY_4A2,
  27   // We lump in HTTP/2 with the SPDY protocols for now.
  28   NPN_HTTP2_DRAFT_04,
  29   NPN_SPDY_MAXIMUM_VERSION = NPN_HTTP2_DRAFT_04,
  30   QUIC,
  31   ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION = QUIC,
  32   ALTERNATE_PROTOCOL_BROKEN,  // The alternate protocol is known to be broken.
  33   UNINITIALIZED_ALTERNATE_PROTOCOL,
  34 };
  35
  36 // Simply returns whether |protocol| is between
  37 // ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION and
  38 // ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION (inclusive).
  39 NET_EXPORT bool IsAlternateProtocolValid(AlternateProtocol protocol);
  40
  41 enum AlternateProtocolSize {
  42   NUM_VALID_ALTERNATE_PROTOCOLS =
  43     ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION -
  44     ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION + 1,
  45 };
  46
  47 NET_EXPORT const char* AlternateProtocolToString(AlternateProtocol protocol);
  48 NET_EXPORT AlternateProtocol AlternateProtocolFromString(
  49     const std::string& str);
  50 NET_EXPORT_PRIVATE AlternateProtocol AlternateProtocolFromNextProto(
  51     NextProto next_proto);
  52
  53 struct NET_EXPORT PortAlternateProtocolPair {
  54   bool Equals(const PortAlternateProtocolPair& other) const {
  55     return port == other.port && protocol == other.protocol;
  56   }
  57
  58   std::string ToString() const;
  59
  60   uint16 port;
  61   AlternateProtocol protocol;
  62 };
  63
  64 typedef std::map<HostPortPair, PortAlternateProtocolPair> AlternateProtocolMap;
  65 typedef std::map<HostPortPair, SettingsMap> SpdySettingsMap;
  66 typedef std::map<HostPortPair,
  67         HttpPipelinedHostCapability> PipelineCapabilityMap;
  68
  69 extern const char kAlternateProtocolHeader[];
  70
  71 // The interface for setting/retrieving the HTTP server properties.
  72 // Currently, this class manages servers':
  73 // * SPDY support (based on NPN results)
  74 // * Alternate-Protocol support
  75 // * Spdy Settings (like CWND ID field)
  76 class NET_EXPORT HttpServerProperties {
  77  public:
  78   HttpServerProperties() {}
  79   virtual ~HttpServerProperties() {}
  80
  81   // Gets a weak pointer for this object.
  82   virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
  83
  84   // Deletes all data.
  85   virtual void Clear() = 0;
  86
  87   // Returns true if |server| supports SPDY.
  88   virtual bool SupportsSpdy(const HostPortPair& server) const = 0;
  89
  90   // Add |server| into the persistent store. Should only be called from IO
  91   // thread.
  92   virtual void SetSupportsSpdy(const HostPortPair& server,
  93                                bool support_spdy) = 0;
  94
  95   // Returns true if |server| has an Alternate-Protocol header.
  96   virtual bool HasAlternateProtocol(const HostPortPair& server) const = 0;
  97
  98   // Returns the Alternate-Protocol and port for |server|.
  99   // HasAlternateProtocol(server) must be true.
 100   virtual PortAlternateProtocolPair GetAlternateProtocol(
 101       const HostPortPair& server) const = 0;
 102
 103   // Sets the Alternate-Protocol for |server|.
 104   virtual void SetAlternateProtocol(const HostPortPair& server,
 105                                     uint16 alternate_port,
 106                                     AlternateProtocol alternate_protocol) = 0;
 107
 108   // Sets the Alternate-Protocol for |server| to be BROKEN.
 109   virtual void SetBrokenAlternateProtocol(const HostPortPair& server) = 0;
 110
 111   // Returns all Alternate-Protocol mappings.
 112   virtual const AlternateProtocolMap& alternate_protocol_map() const = 0;
 113
 114   // Gets a reference to the SettingsMap stored for a host.
 115   // If no settings are stored, returns an empty SettingsMap.
 116   virtual const SettingsMap& GetSpdySettings(
 117       const HostPortPair& host_port_pair) const = 0;
 118
 119   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
 120   // is to be persisted.
 121   virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
 122                               SpdySettingsIds id,
 123                               SpdySettingsFlags flags,
 124                               uint32 value) = 0;
 125
 126   // Clears all SPDY settings for a host.
 127   virtual void ClearSpdySettings(const HostPortPair& host_port_pair) = 0;
 128
 129   // Clears all SPDY settings for all hosts.
 130   virtual void ClearAllSpdySettings() = 0;
 131
 132   // Returns all persistent SPDY settings.
 133   virtual const SpdySettingsMap& spdy_settings_map() const = 0;
 134
 135   virtual HttpPipelinedHostCapability GetPipelineCapability(
 136       const HostPortPair& origin) = 0;
 137
 138   virtual void SetPipelineCapability(
 139       const HostPortPair& origin,
 140       HttpPipelinedHostCapability capability) = 0;
 141
 142   virtual void ClearPipelineCapabilities() = 0;
 143
 144   virtual PipelineCapabilityMap GetPipelineCapabilityMap() const = 0;
 145
 146  private:
 147   DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
 148 };
 149
 150 }  // namespace net
 151
 152 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_