SPDY - implement greedy approach to read all the data and process it

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 <algorithm>
 #include <list>
 #include <map>
@@ skipping 393 matching lines @@
   typedef std::map<const scoped_refptr<SpdyStream>*, CallbackResultPair>
       PendingCallbackMap;
 
   enum State {
     IDLE,
     CONNECTING,
     CONNECTED,
     CLOSED
   };
 
+  enum IoState {
+    STATE_NONE,
+    STATE_DO_READ,
+    STATE_DO_READ_COMPLETE
+  };
+
   virtual ~SpdySession();
 
   void ProcessPendingCreateStreams();
   int CreateStreamImpl(
       const GURL& url,
       RequestPriority priority,
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
+  // Try to make progress by reading and processing data.
+  int DoLoop(int rv);
+  // The implementations of each io_state_ of the IoState machine.
+  int DoRead();
+  int DoReadComplete(int bytes_read);
+
   // IO Callbacks
   void OnReadComplete(int result);
   void OnWriteComplete(int result);
 
   // Send relevant SETTINGS.  This is generally called on connection setup.
   void SendInitialSettings();
 
   // Helper method to send SETTINGS a frame.
   void SendSettings(const SettingsMap& settings);
 
@@ skipping 14 matching lines @@
   void WritePingFrame(uint32 unique_id);
 
   // Post a CheckPingStatus call after delay. Don't post if there is already
   // CheckPingStatus running.
   void PlanToCheckPingStatus();
 
   // Check the status of the connection. It calls |CloseSessionOnError| if we
   // haven't received any data in |kHungInterval| time period.
   void CheckPingStatus(base::TimeTicks last_check_time);
 
-  // Start reading from the socket.
-  // Returns OK on success, or an error on failure.
-  net::Error ReadSocket();
-
   // Write current data to the socket.
   void WriteSocketLater();
   void WriteSocket();
 
   // Get a new stream id.
   int GetNewStreamId();
 
   // Queue a frame for sending.
   // |frame| is the frame to send.
   // |priority| is the priority for insertion into the queue.
@@ skipping 167 matching lines @@
   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_;
   State state_;
+  IoState io_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_;
   int streams_abandoned_count_;
   int bytes_received_;
+  int bytes_read_;
   bool sent_settings_;      // Did this session send settings when it started.
   bool received_settings_;  // Did this session receive at least one settings
                             // frame.
   int stalled_streams_;     // Count of streams that were ever stalled.
 
   // Count of all pings on the wire, for which we have not gotten a response.
   int64 pings_in_flight_;
 
   // This is the next ping_id (unique_id) to be sent in PING frame.
   uint32 next_ping_id_;
@@ skipping 63 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_