SPDY - integration of spdy/3 code.

net/spdy/spdy_session.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_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 #pragma once
 
 #include <algorithm>
 #include <list>
@@ skipping 156 matching lines @@
   bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
 
   // Returns the OriginBoundCertService used by this Socket, or NULL
   // Origin Bound Certs are not supported in this session.
   OriginBoundCertService* GetOriginBoundCertService() const;
 
   // Returns the type of the origin bound cert that was sent, or
   // CLIENT_CERT_INVALID_TYPE if none was sent.
   SSLClientCertType GetOriginBoundCertType() const;
 
+  // Reset all static settings to initialized values. Used to init test suite.
+  static void ResetStaticSettingsToInit();
+
   // Enable or disable SSL.
   static void SetSSLMode(bool enable) { use_ssl_ = enable; }
   static bool SSLMode() { return use_ssl_; }
 
   // Enable or disable flow control used by unit tests. This only applies for
   // new SpdySessions.
   static void set_use_flow_control(FlowControl flow_control) {
     use_flow_control_ = flow_control;
   }
 
+  // Specify the SPDY protocol to be used for SPDY session which do not use NPN
+  // to negotiate a particular protocol.
+  static void set_default_protocol(
+      SSLClientSocket::NextProto default_protocol) {
+    default_protocol_ = default_protocol;
+  }
+
   // Sets the max concurrent streams per session, as a ceiling on any server
   // specific SETTINGS value.
   static void set_max_concurrent_streams(size_t value) {
     max_concurrent_stream_limit_ = value;
   }
   static size_t max_concurrent_streams() {
     return max_concurrent_stream_limit_;
   }
 
   // Enable sending of PING frame with each request.
@@ skipping 150 matching lines @@
   // IO Callbacks
   void OnReadComplete(int result);
   void OnWriteComplete(int result);
 
   // Send relevant SETTINGS.  This is generally called on connection setup.
   void SendSettings();
 
   // Handle SETTINGS.  Either when we send settings, or when we receive a
   // SETTINGS control frame, update our SpdySession accordingly.
   void HandleSettings(const spdy::SpdySettings& settings);
+  void HandleSetting(uint32 id, uint32 value);
 
   // Adjust the send window size of all ActiveStreams and PendingCreateStreams.
   void UpdateStreamsSendWindowSize(int32 delta_window_size);
 
   // Send the PING (preface-PING and trailing-PING) frames.
   void SendPrefacePingIfNoneInFlight();
 
   // Send PING if there are no PINGs in flight and we haven't heard from server.
   void SendPrefacePing();
 
@@ skipping 63 matching lines @@
   void InvokeUserStreamCreationCallback(scoped_refptr<SpdyStream>* stream);
 
   // BufferedSpdyFramerVisitorInterface:
   virtual void OnError(int error_code) OVERRIDE;
   virtual void OnStreamError(spdy::SpdyStreamId stream_id,
                              const std::string& description) OVERRIDE;
   virtual void OnRstStream(
       const spdy::SpdyRstStreamControlFrame& frame) OVERRIDE;
   virtual void OnGoAway(const spdy::SpdyGoAwayControlFrame& frame) OVERRIDE;
   virtual void OnPing(const spdy::SpdyPingControlFrame& frame) OVERRIDE;
-  virtual void OnSettings(const spdy::SpdySettingsControlFrame& frame) OVERRIDE;
   virtual void OnWindowUpdate(
       const spdy::SpdyWindowUpdateControlFrame& frame) OVERRIDE;
   virtual void OnStreamFrameData(spdy::SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len) OVERRIDE;
+  virtual void OnSetting(
+      spdy::SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
   virtual void OnSynStream(
       const spdy::SpdySynStreamControlFrame& frame,
       const linked_ptr<spdy::SpdyHeaderBlock>& headers) OVERRIDE;
   virtual void OnSynReply(
       const spdy::SpdySynReplyControlFrame& frame,
       const linked_ptr<spdy::SpdyHeaderBlock>& headers) OVERRIDE;
   virtual void OnHeaders(
       const spdy::SpdyHeadersControlFrame& frame,
       const linked_ptr<spdy::SpdyHeaderBlock>& headers) OVERRIDE;
 
@@ skipping 160 matching lines @@
 
   BoundNetLog net_log_;
 
   // Outside of tests, this should always be true.
   bool verify_domain_authentication_;
 
   SpdyCredentialState credential_state_;
 
   static bool use_ssl_;
   static FlowControl use_flow_control_;
+  static SSLClientSocket::NextProto default_protocol_;
   static size_t init_max_concurrent_streams_;
   static size_t max_concurrent_stream_limit_;
 
   // This enables or disables connection health checking system.
   static bool enable_ping_based_connection_checking_;
 
   // |connection_at_risk_of_loss_seconds_| is an optimization to avoid sending
   // wasteful preface pings (when we just got some data).
   //
   // If it is zero (the most conservative figure), then we always send the
@@ skipping 74 matching lines @@
 
   const int status_;
   const std::string description_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySessionCloseParameter);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_