base::Bind: Convert StreamSocket::Connect.

net/spdy/spdy_proxy_client_socket.cc

 // 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.
 
 #include "net/spdy/spdy_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 15 matching lines @@
     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_DISCONNECTED),
       spdy_stream_(spdy_stream),
-      read_callback_(NULL),
+      old_read_callback_(NULL),
       write_callback_(NULL),
       endpoint_(endpoint),
       auth_(
           new HttpAuthController(HttpAuth::AUTH_PROXY,
                                  GURL("https://" + proxy_server.ToString()),
                                  auth_cache,
                                  auth_handler_factory)),
       user_buffer_(NULL),
       write_buffer_len_(0),
       write_bytes_outstanding_(0),
@@ skipping 38 matching lines @@
 // for the specified endpoint.  Waits for the server to send back
 // 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(OldCompletionCallback* callback) {
-  DCHECK(!read_callback_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
   if (next_state_ == STATE_OPEN)
     return OK;
 
+  DCHECK_EQ(STATE_DISCONNECTED, next_state_);
+  next_state_ = STATE_GENERATE_AUTH_TOKEN;
+
+  int rv = DoLoop(OK);
+  if (rv == ERR_IO_PENDING)
+    old_read_callback_ = callback;
+  return rv;
+}
+int SpdyProxyClientSocket::Connect(const CompletionCallback& callback) {
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  if (next_state_ == STATE_OPEN)
+    return OK;
+
   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() {
   read_buffer_.clear();
   user_buffer_ = NULL;
-  read_callback_ = NULL;
+  old_read_callback_ = NULL;
+  read_callback_.Reset();
 
   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.
@@ skipping 31 matching lines @@
 int64 SpdyProxyClientSocket::NumBytesRead() const {
   return -1;
 }
 
 base::TimeDelta SpdyProxyClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 OldCompletionCallback* callback) {
-  DCHECK(!read_callback_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
   DCHECK(!user_buffer_);
 
   if (next_state_ == STATE_DISCONNECTED)
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (next_state_ == STATE_CLOSED && read_buffer_.empty()) {
     return 0;
   }
 
   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;
+    old_read_callback_ = callback;
     return ERR_IO_PENDING;
   }
   user_buffer_ = NULL;
   return result;
 }
 
 int SpdyProxyClientSocket::PopulateUserReadBuffer() {
   if (!user_buffer_)
     return ERR_IO_PENDING;
 
@@ skipping 74 matching lines @@
 int SpdyProxyClientSocket::GetLocalAddress(IPEndPoint* address) const {
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
   return spdy_stream_->GetLocalAddress(address);
 }
 
 void SpdyProxyClientSocket::OnIOComplete(int result) {
   DCHECK_NE(STATE_DISCONNECTED, next_state_);
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING) {
-    OldCompletionCallback* c = read_callback_;
-    read_callback_ = NULL;
-    c->Run(rv);
+    if (old_read_callback_) {
+      OldCompletionCallback* c = old_read_callback_;
+      old_read_callback_ = NULL;
+      c->Run(rv);
+    } else {
+      CompletionCallback c = read_callback_;
+      read_callback_.Reset();
+      c.Run(rv);
+    }
   }
 }
 
 int SpdyProxyClientSocket::DoLoop(int last_io_result) {
   DCHECK_NE(next_state_, STATE_DISCONNECTED);
   int rv = last_io_result;
   do {
     State state = next_state_;
     next_state_ = STATE_DISCONNECTED;
     switch (state) {
@@ skipping 178 matching lines @@
 // Called when data is received.
 void SpdyProxyClientSocket::OnDataReceived(const char* data, int length) {
   if (length > 0) {
     // Save the received data.
     scoped_refptr<IOBuffer> io_buffer(new IOBuffer(length));
     memcpy(io_buffer->data(), data, length);
     read_buffer_.push_back(
         make_scoped_refptr(new DrainableIOBuffer(io_buffer, length)));
   }
 
-  if (read_callback_) {
+  if (old_read_callback_) {
     int rv = PopulateUserReadBuffer();
-    OldCompletionCallback* c = read_callback_;
-    read_callback_ = NULL;
+    OldCompletionCallback* c = old_read_callback_;
+    old_read_callback_ = NULL;
     user_buffer_ = NULL;
     c->Run(rv);
+  } else if (!read_callback_.is_null()) {
+    int rv = PopulateUserReadBuffer();
+    CompletionCallback c = read_callback_;
+    read_callback_.Reset();
+    user_buffer_ = NULL;
+    c.Run(rv);
   }
 }
 
 void SpdyProxyClientSocket::OnDataSent(int length)  {
   DCHECK(write_callback_);
 
   write_bytes_outstanding_ -= length;
 
   DCHECK_GE(write_bytes_outstanding_, 0);
 
@@ skipping 21 matching lines @@
 
   base::WeakPtr<SpdyProxyClientSocket> weak_ptr = weak_factory_.GetWeakPtr();
   OldCompletionCallback* 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.
   if (connecting) {
-    DCHECK(read_callback_);
-    OldCompletionCallback* read_callback = read_callback_;
-    read_callback_ = NULL;
-    read_callback->Run(status);
-  } else if (read_callback_) {
+    DCHECK(old_read_callback_ || !read_callback_.is_null());
+    if (old_read_callback_) {
+      OldCompletionCallback* read_callback = old_read_callback_;
+      old_read_callback_ = NULL;
+      read_callback->Run(status);
+    } else {
+      CompletionCallback read_callback = read_callback_;
+      read_callback_.Reset();
+      read_callback.Run(status);
+    }
+  } else if (old_read_callback_ || !read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(NULL, 0);
   }
   // This may have been deleted by read_callback_, so check first.
   if (weak_ptr && write_callback)
     write_callback->Run(ERR_CONNECTION_CLOSED);
 }
 
 void SpdyProxyClientSocket::set_chunk_callback(ChunkCallback* /*callback*/) {
 }
 
 }  // namespace net