Integrate the SpdyProxyClientSocket into the HttpStreamRequest...

net/spdy/spdy_proxy_client_socket.cc

 // Copyright (c) 2010 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_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 12 matching lines @@
 SpdyProxyClientSocket::SpdyProxyClientSocket(
     SpdyStream* spdy_stream,
     const std::string& user_agent,
     const HostPortPair& endpoint,
     const GURL& url,
     const HostPortPair& proxy_server,
     HttpAuthCache* auth_cache,
     HttpAuthHandlerFactory* auth_handler_factory)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &SpdyProxyClientSocket::OnIOComplete)),
-      next_state_(STATE_NONE),
+      next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
       read_callback_(NULL),
       write_callback_(NULL),
       endpoint_(endpoint),
       auth_(
           new HttpAuthController(HttpAuth::AUTH_PROXY,
                                  GURL("http://" + proxy_server.ToString()),
                                  auth_cache,
                                  auth_handler_factory)),
       user_buffer_(NULL),
@@ skipping 19 matching lines @@
 // a SYN_REPLY frame.  OK will be returned if the status is 200.
 // ERR_TUNNEL_CONNECTION_FAILED will be returned for any other status.
 // In any of these cases, Read() may be called to retrieve the HTTP
 // response body.  Any other return values should be considered fatal.
 // TODO(rch): handle 407 proxy auth requested correctly, perhaps
 // by creating a new stream for the subsequent request.
 // TODO(rch): create a more appropriate error code to disambiguate
 // the HTTPS Proxy tunnel failure from an HTTP Proxy tunnel failure.
 int SpdyProxyClientSocket::Connect(CompletionCallback* callback) {
   DCHECK(!read_callback_);
-  if (next_state_ == STATE_DONE)
+  if (next_state_ == STATE_OPEN)
     return OK;
 
-  DCHECK_EQ(STATE_NONE, next_state_);
+  DCHECK_EQ(STATE_DISCONNECTED, next_state_);
   next_state_ = STATE_GENERATE_AUTH_TOKEN;
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     read_callback_ = callback;
   return rv;
 }
 
 void SpdyProxyClientSocket::Disconnect() {
-  next_state_ = STATE_NONE;
+  read_buffer_.clear();
+  user_buffer_ = NULL;
+  read_callback_ = NULL;
+
+  write_buffer_len_ = 0;
+  write_bytes_outstanding_ = 0;
+  write_callback_ = NULL;
+
+  next_state_ = STATE_DISCONNECTED;
+
   if (spdy_stream_)
     // This will cause OnClose to be invoked, which takes care of
     // cleaning up all the internal state.
     spdy_stream_->Cancel();
 }
 
 bool SpdyProxyClientSocket::IsConnected() const {
-  return next_state_ == STATE_DONE && spdy_stream_ != NULL &&
-      !spdy_stream_->closed();
+  return next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED;
 }
 
 bool SpdyProxyClientSocket::IsConnectedAndIdle() const {
   return IsConnected() && !spdy_stream_->is_idle();
 }
 
 void SpdyProxyClientSocket::SetSubresourceSpeculation() {
   // TODO(rch): what should this implementation be?
 }
 
 void SpdyProxyClientSocket::SetOmniboxSpeculation() {
   // TODO(rch): what should this implementation be?
 }
 
 bool SpdyProxyClientSocket::WasEverUsed() const {
   return was_ever_used_ || (spdy_stream_ && spdy_stream_->WasEverUsed());
 }
 
 int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 CompletionCallback* callback) {
   DCHECK(!read_callback_);
   DCHECK(!user_buffer_);
 
-  if (!spdy_stream_) {
+  if (next_state_ == STATE_DISCONNECTED)
+    return ERR_SOCKET_NOT_CONNECTED;
+
+  if (!spdy_stream_ && read_buffer_.empty()) {
     if (eof_has_been_read_)
       return ERR_CONNECTION_CLOSED;
     eof_has_been_read_ = true;
     return 0;
   }
 
-  DCHECK(next_state_ == STATE_DONE);
+  DCHECK(next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED);
   DCHECK(buf);
   user_buffer_ = new DrainableIOBuffer(buf, buf_len);
   int result = PopulateUserReadBuffer();
   if (result == 0) {
     DCHECK(callback);
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
   user_buffer_ = NULL;
   return result;
 }
 
 int SpdyProxyClientSocket::PopulateUserReadBuffer() {
   if (!user_buffer_)
     return ERR_IO_PENDING;
 
   while (!read_buffer_.empty() && user_buffer_->BytesRemaining() > 0) {
     scoped_refptr<DrainableIOBuffer> data = read_buffer_.front();
     const int bytes_to_copy = std::min(user_buffer_->BytesRemaining(),
                                        data->BytesRemaining());
     memcpy(user_buffer_->data(), data->data(), bytes_to_copy);
     user_buffer_->DidConsume(bytes_to_copy);
-    if (data->BytesRemaining() == 0) {
+    if (data->BytesRemaining() == bytes_to_copy) {
       // Consumed all data from this buffer
       read_buffer_.pop_front();
     } else {
       data->DidConsume(bytes_to_copy);
     }
   }
 
   return user_buffer_->BytesConsumed();
 }
 
 int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(!write_callback_);
+  if (next_state_ == STATE_DISCONNECTED)
+    return ERR_SOCKET_NOT_CONNECTED;
+
   if (!spdy_stream_)
     return ERR_CONNECTION_CLOSED;
 
   write_bytes_outstanding_= buf_len;
   if (buf_len <= kMaxSpdyFrameChunkSize) {
     int rv = spdy_stream_->WriteStreamData(buf, buf_len, spdy::DATA_FLAG_NONE);
     if (rv == ERR_IO_PENDING) {
       write_callback_ = callback;
       write_buffer_len_ = buf_len;
     }
@@ skipping 34 matching lines @@
   return false;
 }
 
 int SpdyProxyClientSocket::GetPeerAddress(AddressList* address) const {
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
   return spdy_stream_->GetPeerAddress(address);
 }
 
 void SpdyProxyClientSocket::OnIOComplete(int result) {
-  DCHECK_NE(STATE_NONE, next_state_);
+  DCHECK_NE(STATE_DISCONNECTED, next_state_);
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING) {
     CompletionCallback* c = read_callback_;
     read_callback_ = NULL;
     c->Run(rv);
   }
 }
 
 int SpdyProxyClientSocket::DoLoop(int last_io_result) {
-  DCHECK_NE(next_state_, STATE_NONE);
+  DCHECK_NE(next_state_, STATE_DISCONNECTED);
   int rv = last_io_result;
   do {
     State state = next_state_;
-    next_state_ = STATE_NONE;
+    next_state_ = STATE_DISCONNECTED;
     switch (state) {
       case STATE_GENERATE_AUTH_TOKEN:
         DCHECK_EQ(OK, rv);
         rv = DoGenerateAuthToken();
         break;
       case STATE_GENERATE_AUTH_TOKEN_COMPLETE:
         rv = DoGenerateAuthTokenComplete(rv);
         break;
       case STATE_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
         net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST,
                             NULL);
         rv = DoSendRequest();
         break;
       case STATE_SEND_REQUEST_COMPLETE:
         rv = DoSendRequestComplete(rv);
         net_log_.EndEvent(NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST,
                           NULL);
         break;
       case STATE_READ_REPLY_COMPLETE:
         rv = DoReadReplyComplete(rv);
         net_log_.EndEvent(NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS,
                           NULL);
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
-  } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE &&
-           next_state_ != STATE_DONE);
+  } while (rv != ERR_IO_PENDING && next_state_ != STATE_DISCONNECTED &&
+           next_state_ != STATE_OPEN);
   return rv;
 }
 
 int SpdyProxyClientSocket::DoGenerateAuthToken() {
   next_state_ = STATE_GENERATE_AUTH_TOKEN_COMPLETE;
   return auth_->MaybeGenerateAuthToken(&request_, &io_callback_, net_log_);
 }
 
 int SpdyProxyClientSocket::DoGenerateAuthTokenComplete(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
@@ skipping 42 matching lines @@
   return ERR_IO_PENDING;
 }
 
 int SpdyProxyClientSocket::DoReadReplyComplete(int result) {
   // We enter this method directly from DoSendRequestComplete, since
   // we are notified by a callback when the SYN_REPLY frame arrives
 
   if (result < 0)
     return result;
 
-  next_state_ = STATE_DONE;
   // Require the "HTTP/1.x" status line for SSL CONNECT.
   if (response_.headers->GetParsedHttpVersion() < HttpVersion(1, 0))
     return ERR_TUNNEL_CONNECTION_FAILED;
 
+  next_state_ = STATE_OPEN;
   if (net_log_.IsLoggingAll()) {
     net_log_.AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
         new NetLogHttpResponseParameter(response_.headers));
   }
 
   if (response_.headers->response_code() == 200)
     return OK;
   else
     return ERR_TUNNEL_CONNECTION_FAILED;
@@ skipping 70 matching lines @@
     write_buffer_len_ = 0;
     write_bytes_outstanding_ = 0;
     CompletionCallback* c = write_callback_;
     write_callback_ = NULL;
     c->Run(rv);
   }
 }
 
 void SpdyProxyClientSocket::OnClose(int status)  {
   DCHECK(spdy_stream_);
+  was_ever_used_ = spdy_stream_->WasEverUsed();
+  spdy_stream_ = NULL;
+
+  bool connecting = next_state_ != STATE_DISCONNECTED &&
+      next_state_ < STATE_OPEN;
+  if (next_state_ == STATE_OPEN)
+    next_state_ = STATE_CLOSED;
+  else
+    next_state_ = STATE_DISCONNECTED;
+
+  CompletionCallback* write_callback = write_callback_;
+  write_callback_ = NULL;
+  write_buffer_len_ = 0;
+  write_bytes_outstanding_ = 0;
+
   // If we're in the middle of connecting, we need to make sure
   // we invoke the connect callback.
-  CompletionCallback* connect_callback = NULL;
-  if (next_state_ != STATE_NONE && next_state_ != STATE_DONE) {
+  if (connecting) {
     DCHECK(read_callback_);
-    connect_callback = read_callback_;
+    CompletionCallback* read_callback = read_callback_;
+    read_callback_ = NULL;
+    read_callback->Run(status);
+  } else if (read_callback_) {
+    // If we have a read_callback, the we need to make sure we call it back
+    OnDataReceived(NULL, 0);
   }
-  was_ever_used_ = spdy_stream_->WasEverUsed();
-  spdy_stream_ = NULL;
-  read_callback_ = NULL;
-  write_callback_ = NULL;
-  user_buffer_ = NULL;
-  read_buffer_.empty();
-  if (connect_callback)
-    connect_callback->Run(status);
+  if (write_callback)
+    write_callback->Run(ERR_CONNECTION_CLOSED);
 }
 
 }  // namespace net