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 246 matching lines @@
 
   // Returns the ServerBoundCertService used by this Socket, or NULL
   // if server bound certs are not supported in this session.
   ServerBoundCertService* GetServerBoundCertService() const;
 
   // Send WINDOW_UPDATE frame, called by a stream whenever receive window
   // size is increased.
   void SendWindowUpdate(SpdyStreamId stream_id, int32 delta_window_size);
 
   // If session is closed, no new streams/transactions should be created.
-  bool IsClosed() const { return state_ == CLOSED; }
+  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,
                            bool remove_from_pool,
@@ skipping 120 matching lines @@
     ~CallbackResultPair();
 
     CompletionCallback callback;
     int result;
   };
 
   typedef std::map<const scoped_refptr<SpdyStream>*, CallbackResultPair>
       PendingCallbackMap;
 
   enum State {
-    IDLE,
-    CONNECTING,
-    CONNECTED,
-    CLOSED
+    STATE_IDLE,
+    STATE_CONNECTING,
+    STATE_DO_READ,
+    STATE_DO_READ_COMPLETE,
+    STATE_CLOSED
   };
 
   virtual ~SpdySession();
 
   void ProcessPendingCreateStreams();
   int CreateStreamImpl(
       const GURL& url,
       RequestPriority priority,
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
+  // Start the DoLoop to read data from socket.
+  void StartRead();
+
+  // Try to make progress by reading and processing data.
+  int DoLoop(int result);
+  // The implementations of STATE_DO_READ/STATE_DO_READ_COMPLETE state changes
+  // of the state machine.
+  int DoRead();
+  int DoReadComplete(int bytes_read);
+
+  // Check if session is connected or not.
+  bool IsConnected() const {
+    return state_ == STATE_DO_READ || state_ == STATE_DO_READ_COMPLETE;
+  }
+
   // 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 177 matching lines @@
 
   // 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 total_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_