Use struct AlternativeService in OnAltSvc() and OnSpdyAltSvc() methods.

net/spdy/spdy_protocol.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.
 
 // This file contains some protocol structures for use with SPDY 2 and 3
 // The SPDY 2 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
 #ifndef NET_SPDY_SPDY_PROTOCOL_H_
 #define NET_SPDY_SPDY_PROTOCOL_H_
 
 #include <limits>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/sys_byteorder.h"
 #include "net/base/net_export.h"
+#include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_bitmasks.h"
 
 namespace net {
 
 // The major versions of SPDY. Major version differences indicate
 // framer-layer incompatibility, as opposed to minor version numbers
 // which indicate application-layer incompatibility. Do not rely on
 // the mapping from enum value SPDYn to the integer n.
 enum SpdyMajorVersion {
   SPDY2 = 2,
@@ skipping 926 matching lines @@
 };
 
 // TODO(bnc): Add probability.
 // TODO(bnc): Separate (protocol, port, host, max_age, probability) tuple into
 // struct, have a vector of that struct.  A single HTTP/1.1 header field or
 // HTTP/2 or QUIC frame can define multiple such tuples.
 class NET_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
  public:
   explicit SpdyAltSvcIR(SpdyStreamId stream_id);
 
-  uint32 max_age() const { return max_age_; }
-  uint16 port() const { return port_; }
-  SpdyProtocolId protocol_id() const {
-    return protocol_id_;
+  std::string origin() const { return origin_; }
+  const SpdyAltSvcWireFormat::AlternativeService& altsvc() const {
+    return altsvc_;
   }
-  std::string host() const { return host_; }
-  std::string origin() const { return origin_; }
+  SpdyProtocolId protocol_id() const { return altsvc_.protocol_id; }
+  std::string host() const { return altsvc_.host; }
+  uint16 port() const { return altsvc_.port; }
+  uint32 max_age() const { return altsvc_.max_age; }
+  double p() const { return altsvc_.p; }
 
-  void set_max_age(uint32 max_age) { max_age_ = max_age; }
-  void set_port(uint16 port) { port_ = port; }
+  void set_origin(std::string origin) { origin_ = origin; }
   void set_protocol_id(SpdyProtocolId protocol_id) {
-    protocol_id_ = protocol_id;
+    altsvc_.protocol_id = protocol_id;
   }
-  void set_host(std::string host) { host_ = host; }
-  void set_origin(std::string origin) { origin_ = origin; }
+  void set_host(std::string host) { altsvc_.host = host; }
+  void set_port(uint16 port) { altsvc_.port = port; }
+  void set_max_age(uint32 max_age) { altsvc_.max_age = max_age; }
+  void set_p(double p) { altsvc_.p = p; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
-  uint32 max_age_;
-  uint16 port_;
-  SpdyProtocolId protocol_id_;
-  std::string host_;
   std::string origin_;
+  SpdyAltSvcWireFormat::AlternativeService altsvc_;
   DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR);
 };
 
 class NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
  public:
   explicit SpdyPriorityIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id),
         parent_stream_id_(0),
         weight_(1),
         exclusive_(false) {}
@@ skipping 89 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_