Refactor state machines in HttpPipelinedConnectionImpl.

net/http/http_pipelined_connection_impl.h

 // Copyright (c) 2011 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_HTTP_HTTP_PIPELINED_CONNECTION_IMPL_H_
 #define NET_HTTP_HTTP_PIPELINED_CONNECTION_IMPL_H_
 #pragma once
 
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/location.h"
 #include "base/memory/linked_ptr.h"
 #include "base/task.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_pipelined_connection.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_parser.h"
@@ skipping 94 matching lines @@
 
  private:
   enum StreamState {
     STREAM_CREATED,
     STREAM_BOUND,
     STREAM_SENDING,
     STREAM_SENT,
     STREAM_READ_PENDING,
     STREAM_ACTIVE,
     STREAM_CLOSED,
+    STREAM_READ_EVICTED,
     STREAM_UNUSED,
   };
   enum SendRequestState {
-    SEND_STATE_NEXT_REQUEST,
+    SEND_STATE_START_IMMEDIATELY,
+    SEND_STATE_START_NEXT_DEFERRED_REQUEST,
+    SEND_STATE_SEND_ACTIVE_REQUEST,
     SEND_STATE_COMPLETE,
+    SEND_STATE_EVICT_PENDING_REQUESTS,
     SEND_STATE_NONE,
-    SEND_STATE_UNUSABLE,
   };
   enum ReadHeadersState {
-    READ_STATE_NEXT_HEADERS,
-    READ_STATE_COMPLETE,
+    READ_STATE_START_IMMEDIATELY,
+    READ_STATE_START_NEXT_DEFERRED_READ,
+    READ_STATE_READ_HEADERS,
+    READ_STATE_READ_HEADERS_COMPLETE,
     READ_STATE_WAITING_FOR_CLOSE,
     READ_STATE_STREAM_CLOSED,
     READ_STATE_NONE,
-    READ_STATE_UNUSABLE,
+    READ_STATE_EVICT_PENDING_READS,
   };
 
-  struct DeferredSendRequest {
-    DeferredSendRequest();
-    ~DeferredSendRequest();
+  struct PendingSendRequest {
+    PendingSendRequest();
+    ~PendingSendRequest();
 
     int pipeline_id;
     std::string request_line;
     HttpRequestHeaders headers;
     UploadDataStream* request_body;
     HttpResponseInfo* response;
     OldCompletionCallback* callback;
   };
 
   struct StreamInfo {
@@ skipping 15 matching lines @@
   // requests.
   void ActivatePipeline();
 
   // Responsible for sending one request at a time and waiting until each
   // comepletes.
   int DoSendRequestLoop(int result);
 
   // Called when an asynchronous Send() completes.
   void OnSendIOCallback(int result);
 
-  // Sends the next deferred request. This may be called immediately after
-  // SendRequest(), or it may be in a new task after a prior send completes in
-  // DoSendComplete().
-  int DoSendNextRequest(int result);
+  // Activates the only request in |pending_send_request_queue_|. This should
+  // only be called via SendRequest() when the send loop is idle.
+  int DoStartRequestImmediately(int result);
+
+  // Activates the first request in |pending_send_request_queue_| that hasn't
+  // been closed, if any. This is called via DoSendComplete() after a prior
+  // request complets.
+  int DoStartNextDeferredRequest(int result);
+
+  // Sends the active request.
+  int DoSendActiveRequest(int result);
 
   // Notifies the user that the send has completed. This may be called directly
   // after SendRequest() for a synchronous request, or it may be called in
   // response to OnSendIOCallback for an asynchronous request.
   int DoSendComplete(int result);
 
   // Evicts all unsent deferred requests. This is called if there is a Send()
   // error or one of our streams informs us the connection is no longer
   // reusable.
   int DoEvictPendingSendRequests(int result);
 
   // Ensures that only the active request's HttpPipelinedSocket can read from
   // the underlying socket until it completes. A HttpPipelinedSocket informs us
   // that it's done by calling Close().
   int DoReadHeadersLoop(int result);
 
   // Called when the pending asynchronous ReadResponseHeaders() completes.
   void OnReadIOCallback(int result);
 
-  // Determines if the next response in the pipeline is ready to be read.
-  // If it's ready, then we call ReadResponseHeaders() on the underlying parser.
-  // HttpPipelinedSocket indicates its readiness by calling
-  // ReadResponseHeaders(). This function may be called immediately after
-  // ReadResponseHeaders(), or it may be called in a new task after a previous
-  // HttpPipelinedSocket finishes its work.
-  int DoReadNextHeaders(int result);
+  // Invokes DoStartNextDeferredRead() if the read loop is idle. This is called
+  // via a task queued when the previous |active_read_id_| closes its stream
+  // after a succesful response.
+  void StartNextDeferredRead();
+
+  // Activates the next read request immediately. This is called via
+  // ReadResponseHeaders() if that stream is at the front of |request_order_|
+  // and the read loop is idle.
+  int DoStartReadImmediately(int result);
+
+  // Activates the next read request in |request_order_| if it's ready to go.
+  // This is called via StartNextDeferredRead().
+  int DoStartNextDeferredRead(int result);
+
+  // Calls ReadResponseHeaders() on the active request's parser.
+  int DoReadHeaders(int result);
 
   // Notifies the user that reading the headers has completed. This may happen
   // directly after DoReadNextHeaders() if the response is already available.
   // Otherwise, it is called in response to OnReadIOCallback().
   int DoReadHeadersComplete(int result);
 
-  // This is a holding state. It does not do anything, except exit the
-  // DoReadHeadersLoop(). It is called after DoReadHeadersComplete().
-  int DoReadWaitingForClose(int result);
+  // Halts the read loop until Close() is called by the active stream.
+  int DoReadWaitForClose(int result);
 
   // Cleans up the state associated with the active request. Invokes
   // DoReadNextHeaders() in a new task to start the next response. This is
   // called after the active request's HttpPipelinedSocket calls Close().
   int DoReadStreamClosed();
 
   // Removes all pending ReadResponseHeaders() requests from the queue. This may
   // happen if there is an error with the pipeline or one of our
   // HttpPipelinedSockets indicates the connection was suddenly closed.
   int DoEvictPendingReadHeaders(int result);
 
-  // Invokes the user's callback in response to SendRequest() or
+  // Posts a task to fire the user's callback in response to SendRequest() or
   // ReadResponseHeaders() completing on an underlying parser. This might be
   // invoked in response to our own IO callbacks, or it may be invoked if the
   // underlying parser completes SendRequest() or ReadResponseHeaders()
   // synchronously, but we've already returned ERR_IO_PENDING to the user's
   // SendRequest() or ReadResponseHeaders() call into us.
+  void QueueUserCallback(int pipeline_id,
+                         OldCompletionCallback* callback,
+                         int rv,
+                         const tracked_objects::Location& from_here);
+
+  // Invokes the callback queued in QueueUserCallback().
   void FireUserCallback(int pipeline_id, int result);
 
   Delegate* delegate_;
   scoped_ptr<ClientSocketHandle> connection_;
   SSLConfig used_ssl_config_;
   ProxyInfo used_proxy_info_;
   BoundNetLog net_log_;
   bool was_npn_negotiated_;
   scoped_refptr<GrowableIOBuffer> read_buf_;
   int next_pipeline_id_;
   bool active_;
   bool usable_;
   bool completed_one_request_;
   ScopedRunnableMethodFactory<HttpPipelinedConnectionImpl> method_factory_;
 
   StreamInfoMap stream_info_map_;
 
   std::queue<int> request_order_;
 
-  std::queue<DeferredSendRequest> deferred_request_queue_;
+  std::queue<PendingSendRequest*> pending_send_request_queue_;
+  scoped_ptr<PendingSendRequest> active_send_request_;
   SendRequestState send_next_state_;
+  bool send_still_on_call_stack_;
   OldCompletionCallbackImpl<HttpPipelinedConnectionImpl> send_io_callback_;
-  OldCompletionCallback* send_user_callback_;
 
   ReadHeadersState read_next_state_;
+  int active_read_id_;
+  bool read_still_on_call_stack_;
   OldCompletionCallbackImpl<HttpPipelinedConnectionImpl> read_io_callback_;
-  OldCompletionCallback* read_user_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpPipelinedConnectionImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_PIPELINED_CONNECTION_IMPL_H_