SPDY - Added back code that deleted read_pending_.

net/spdy/spdy_session.cc

 // 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.
 
 #include "net/spdy/spdy_session.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 215 matching lines @@
                          size_t max_concurrent_streams_limit,
                          TimeFunc time_func,
                          const HostPortPair& trusted_spdy_proxy,
                          NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       host_port_proxy_pair_(host_port_proxy_pair),
       spdy_session_pool_(spdy_session_pool),
       http_server_properties_(http_server_properties),
       connection_(new ClientSocketHandle),
       read_buffer_(new IOBuffer(kReadBufferSize)),
+      read_pending_(false),
       stream_hi_water_mark_(kFirstStreamId),
       write_pending_(false),
       delayed_write_pending_(false),
       is_secure_(false),
       certificate_error_code_(OK),
       error_(OK),
       state_(STATE_IDLE),
       max_concurrent_streams_(initial_max_concurrent_streams == 0 ?
                               kInitialMaxConcurrentStreams :
                               initial_max_concurrent_streams),
@@ skipping 528 matching lines @@
   if (state_ == STATE_CONNECTING)
     return connection_->GetLoadState();
 
   // Just report that we're idle since the session could be doing
   // many things concurrently.
   return LOAD_STATE_IDLE;
 }
 
 void SpdySession::OnReadComplete(int bytes_read) {
   DCHECK_NE(state_, STATE_DO_READ);
+  read_pending_ = false;
   DoLoop(bytes_read);
 }
 
 void SpdySession::StartRead() {
   DCHECK_NE(state_, STATE_DO_READ_COMPLETE);
+  read_pending_ = false;
   DoLoop(OK);
 }
 
 int SpdySession::DoLoop(int result) {
   bytes_read_ = 0;
   do {
+    if (read_pending_)
+      return OK;
+
     switch (state_) {
       case STATE_DO_READ:
         DCHECK_EQ(result, OK);
         result = DoRead();
         break;
       case STATE_DO_READ_COMPLETE:
         result = DoReadComplete(result);
         break;
       case STATE_CLOSED:
         result = ERR_CONNECTION_CLOSED;
         break;
       default:
         NOTREACHED() << "state_: " << state_;
         break;
     }
   } while (result != ERR_IO_PENDING && result != ERR_CONNECTION_CLOSED);
 
   return result;
 }
 
 int SpdySession::DoRead() {
+  DCHECK(!read_pending_);
   if (bytes_read_ > kMaxReadBytes) {
     state_ = STATE_DO_READ;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&SpdySession::StartRead,
                    weak_factory_.GetWeakPtr()));
     return ERR_IO_PENDING;
   }
 
   CHECK(connection_.get());
   CHECK(connection_->socket());
   state_ = STATE_DO_READ_COMPLETE;
-  return connection_->socket()->Read(
+  int result = connection_->socket()->Read(
       read_buffer_.get(),
       kReadBufferSize,
       base::Bind(&SpdySession::OnReadComplete, base::Unretained(this)));
+  if (result == net::ERR_IO_PENDING)
+    read_pending_ = true;
+  return result;
 }
 
 int SpdySession::DoReadComplete(int result) {
   // Parse a frame.  For now this code requires that the frame fit into our
   // buffer (32KB).
   // TODO(mbelshe): support arbitrarily large frames!
 
+  DCHECK(!read_pending_);
+
   if (result <= 0) {
     // Session is tearing down.
     net::Error error = static_cast<net::Error>(result);
     if (result == 0)
       error = ERR_CONNECTION_CLOSED;
     CloseSessionOnError(error, true, "result is <= 0.");
     return ERR_CONNECTION_CLOSED;
   }
 
   total_bytes_received_ += result;
@@ skipping 1135 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net