[SPDY] Close SPDY sessions on session flow control errors

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_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 42 matching lines @@
 const int kMaxReadBytes = 32 * 1024;
 
 // The initial receive window size for both streams and sessions.
 const int32 kDefaultInitialRecvWindowSize = 10 * 1024 * 1024;  // 10MB
 
 class BoundNetLog;
 struct LoadTimingInfo;
 class SpdyStream;
 class SSLInfo;
 
+// NOTE: There's an enum of the same name (also with numeric suffixes)
+// in histograms.xml.

[jar (doing other things), 2013/04/19 23:12:38]

Please add warning: DO NOT INSERT ENUMS INTO THIS LIST! Add only to the end.

 enum SpdyProtocolErrorDetails {
   // SpdyFramer::SpdyErrors
   SPDY_ERROR_NO_ERROR,
   SPDY_ERROR_INVALID_CONTROL_FRAME,
   SPDY_ERROR_CONTROL_PAYLOAD_TOO_LARGE,
   SPDY_ERROR_ZLIB_INIT_FAILURE,
   SPDY_ERROR_UNSUPPORTED_VERSION,
   SPDY_ERROR_DECOMPRESS_FAILURE,
   SPDY_ERROR_COMPRESS_FAILURE,
   SPDY_ERROR_CREDENTIAL_FRAME_CORRUPT,
   SPDY_ERROR_INVALID_DATA_FRAME_FLAGS,
   SPDY_ERROR_INVALID_CONTROL_FRAME_FLAGS,
 
   // SpdyRstStreamStatus
   STATUS_CODE_INVALID,
   STATUS_CODE_PROTOCOL_ERROR,
   STATUS_CODE_INVALID_STREAM,
   STATUS_CODE_REFUSED_STREAM,
   STATUS_CODE_UNSUPPORTED_VERSION,
   STATUS_CODE_CANCEL,
   STATUS_CODE_INTERNAL_ERROR,
   STATUS_CODE_FLOW_CONTROL_ERROR,
   STATUS_CODE_STREAM_IN_USE,
   STATUS_CODE_STREAM_ALREADY_CLOSED,
   STATUS_CODE_INVALID_CREDENTIALS,
   STATUS_CODE_FRAME_TOO_LARGE,
 
   // SpdySession errors

[jar (doing other things), 2013/04/19 23:12:38]

nit: I'd put this at the end of line 93, to discourage folks from inserting more
enums on blank lines above (delete the blank line spacing).

   PROTOCOL_ERROR_UNEXPECTED_PING,
   PROTOCOL_ERROR_RST_STREAM_FOR_NON_ACTIVE_STREAM,
   PROTOCOL_ERROR_SPDY_COMPRESSION_FAILURE,
   PROTOCOL_ERROR_REQUEST_FOR_SECURE_CONTENT_OVER_INSECURE_SESSION,
   PROTOCOL_ERROR_SYN_REPLY_NOT_RECEIVED,
+  PROTOCOL_ERROR_INVALID_WINDOW_UPDATE_SIZE,
+  PROTOCOL_ERROR_RECEIVE_WINDOW_VIOLATION,
   NUM_SPDY_PROTOCOL_ERROR_DETAILS
 };
 
 COMPILE_ASSERT(STATUS_CODE_INVALID ==
                static_cast<SpdyProtocolErrorDetails>(SpdyFramer::LAST_ERROR),
                SpdyProtocolErrorDetails_SpdyErrors_mismatch);
 
 COMPILE_ASSERT(PROTOCOL_ERROR_UNEXPECTED_PING ==
                static_cast<SpdyProtocolErrorDetails>(
                    RST_STREAM_NUM_STATUS_CODES + STATUS_CODE_INVALID),
@@ skipping 112 matching lines @@
   // ERR_IO_PENDING) otherwise.
   int GetPushStream(
       const GURL& url,
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
   // Used by SpdySessionPool to initialize with a pre-existing SSL socket. For
   // testing, setting is_secure to false allows initialization with a
   // pre-existing TCP socket.
   // Returns OK on success, or an error on failure.
-  net::Error InitializeWithSocket(ClientSocketHandle* connection,
-                                  bool is_secure,
-                                  int certificate_error_code);
+  Error InitializeWithSocket(ClientSocketHandle* connection,
+                             bool is_secure,
+                             int certificate_error_code);
 
   // Check to see if this SPDY session can support an additional domain.
   // If the session is un-authenticated, then this call always returns true.
   // For SSL-based sessions, verifies that the server certificate in use by
   // this session provides authentication for the domain and no client
   // certificate or channel ID was sent to the original server during the SSL
   // handshake.  NOTE:  This function can have false negatives on some
   // platforms.
   // TODO(wtc): rename this function and the Net.SpdyIPPoolDomainMatch
   // histogram because this function does more than verifying domain
@@ skipping 26 matching lines @@
                             scoped_ptr<SpdyFrame>* credential_frame);
 
   // Creates and returns a HEADERS frame.
   scoped_ptr<SpdyFrame> CreateHeadersFrame(SpdyStreamId stream_id,
                                            const SpdyHeaderBlock& headers,
                                            SpdyControlFlags flags);
 
   // Creates and returns a SpdyBuffer holding a data frame with the
   // given data. May return NULL if stalled by flow control.
   scoped_ptr<SpdyBuffer> CreateDataBuffer(SpdyStreamId stream_id,
-                                          net::IOBuffer* data,
+                                          IOBuffer* data,
                                           int len,
                                           SpdyDataFlags flags);
 
   // Close a stream.
   void CloseStream(SpdyStreamId stream_id, int status);
 
   // Close a stream that has been created but is not yet active.
   void CloseCreatedStream(SpdyStream* stream, int status);
 
   // Reset a stream by sending a RST_STREAM frame with given status code.
@@ skipping 31 matching lines @@
   // If session is closed, no new streams/transactions should be created.
   bool IsClosed() const { return state_ == STATE_CLOSED; }
 
   // Closes this session.  This will close all active streams and mark
   // the session as permanently closed.
   // |err| should not be OK; this function is intended to be called on
   // error.
   // |remove_from_pool| indicates whether to also remove the session from the
   // session pool.
   // |description| indicates the reason for the error.
-  void CloseSessionOnError(net::Error err,
+  void CloseSessionOnError(Error err,
                            bool remove_from_pool,
                            const std::string& description);
 
   // Retrieves information on the current state of the SPDY session as a
   // Value.  Caller takes possession of the returned value.
   base::Value* GetInfoAsValue() const;
 
   // Indicates whether the session is being reused after having successfully
   // used to send/receive data in the past.
   bool IsReused() const;
@@ skipping 261 matching lines @@
                const scoped_refptr<SpdyStream> stream);
 
   void RecordPingRTTHistogram(base::TimeDelta duration);
   void RecordHistograms();
   void RecordProtocolErrorHistogram(SpdyProtocolErrorDetails details);
 
   // Closes all active streams with stream id's greater than
   // |last_good_stream_id|, as well as any created or pending streams.
   // Does not close unclaimed push streams.
   void CloseAllStreamsAfter(SpdyStreamId last_good_stream_id,
-                            net::Error status);
+                            Error status);
 
   // Closes all streams, including unclaimed push streams.  Used as part of
   // shutdown.
-  void CloseAllStreams(net::Error status);
+  void CloseAllStreams(Error status);
 
   void LogAbandonedStream(const scoped_refptr<SpdyStream>& stream,
-                          net::Error status);
+                          Error status);
 
   // Invokes a user callback for stream creation.  We provide this method so it
   // can be deferred to the MessageLoop, so we avoid re-entrancy problems.
   void CompleteStreamRequest(SpdyStreamRequest* pending_request);
 
   // Remove old unclaimed pushed streams.
   void DeleteExpiredPushedStreams();
 
   // BufferedSpdyFramerVisitorInterface:
   virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE;
@@ skipping 197 matching lines @@
 
   // Certificate error code when using a secure connection.
   int certificate_error_code_;
 
   // Spdy Frame state.
   scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
 
   // If an error has occurred on the session, the session is effectively
   // dead.  Record this error here.  When no error has occurred, |error_| will
   // be OK.
-  net::Error error_;
+  Error error_;
   State state_;
 
   // Limits
   size_t max_concurrent_streams_;  // 0 if no limit
   size_t max_concurrent_streams_limit_;
 
   // Some statistics counters for the session.
   int streams_initiated_count_;
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
@@ skipping 94 matching lines @@
   // This SPDY proxy is allowed to push resources from origins that are
   // different from those of their associated streams.
   HostPortPair trusted_spdy_proxy_;
 
   TimeFunc time_func_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_