Cancel posted write callbacks in Disconnect().

net/spdy/spdy_proxy_client_socket.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_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 18 matching lines @@
     const std::string& user_agent,
     const HostPortPair& endpoint,
     const GURL& url,
     const HostPortPair& proxy_server,
     const BoundNetLog& source_net_log,
     HttpAuthCache* auth_cache,
     HttpAuthHandlerFactory* auth_handler_factory)
     : next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
       endpoint_(endpoint),
-      auth_(
-          new HttpAuthController(HttpAuth::AUTH_PROXY,
-                                 GURL("https://" + proxy_server.ToString()),
-                                 auth_cache,
-                                 auth_handler_factory)),
+      auth_(new HttpAuthController(HttpAuth::AUTH_PROXY,
+                                   GURL("https://" + proxy_server.ToString()),
+                                   auth_cache,
+                                   auth_handler_factory)),
       user_buffer_len_(0),
       write_buffer_len_(0),
       was_ever_used_(false),
       redirect_has_load_timing_info_(false),
       net_log_(BoundNetLog::Make(spdy_stream->net_log().net_log(),
                                  NetLog::SOURCE_PROXY_CLIENT_SOCKET)),
-      weak_factory_(this) {
+      weak_factory_(this),
+      write_callback_weak_factory_(this) {
   request_.method = "CONNECT";
   request_.url = url;
   if (!user_agent.empty())
     request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                      user_agent);
 
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source_net_log.source().ToEventParametersCallback());
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION,
@@ skipping 69 matching lines @@
 }
 
 void SpdyProxyClientSocket::Disconnect() {
   read_buffer_queue_.Clear();
   user_buffer_ = NULL;
   user_buffer_len_ = 0;
   read_callback_.Reset();
 
   write_buffer_len_ = 0;
   write_callback_.Reset();
+  write_callback_weak_factory_.InvalidateWeakPtrs();
 
   next_state_ = STATE_DISCONNECTED;
 
   if (spdy_stream_.get()) {
     // This will cause OnClose to be invoked, which takes care of
     // cleaning up all the internal state.
     spdy_stream_->Cancel();
     DCHECK(!spdy_stream_.get());
   }
 }
@@ skipping 111 matching lines @@
   return spdy_stream_->GetLocalAddress(address);
 }
 
 void SpdyProxyClientSocket::LogBlockedTunnelResponse() const {
   ProxyClientSocket::LogBlockedTunnelResponse(
       response_.headers->response_code(),
       request_.url,
       /* is_https_proxy = */ true);
 }
 
+void SpdyProxyClientSocket::RunCallback(const CompletionCallback& callback,
+                                        int result) const {
+  callback.Run(result);
+}
+
 void SpdyProxyClientSocket::OnIOComplete(int result) {
   DCHECK_NE(STATE_DISCONNECTED, next_state_);
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING) {
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
     c.Run(rv);
   }
 }
 
@@ skipping 200 matching lines @@
 void SpdyProxyClientSocket::OnDataSent()  {
   DCHECK(!write_callback_.is_null());
 
   int rv = write_buffer_len_;
   write_buffer_len_ = 0;
 
   // Proxy write callbacks result in deep callback chains. Post to allow the
   // stream's write callback chain to unwind (see crbug.com/355511).
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(ResetAndReturn(&write_callback_), rv));
+      base::Bind(&SpdyProxyClientSocket::RunCallback,

[Ryan Hamilton, 2014/06/13 19:02:06]

If this is the only place RunCallback is called, how 'bout making the method
something like:

void RunWriteCallback(in rv) {
  ResetAdnReturn(&write_callback_).run(rv);
}

[wtc, 2014/06/14 00:31:52]

Ryan, did you suggest this because it is expensive to bind write_callback_ to a
"closure" task?

This should work. We can also leave write_buffer_len_ unchanged and define
RunWriteCallback as

void RunWriteCallback() {
  int rv = write_buffer_len_;
  write_buffer_len_ = 0;
  ResetAdnReturn(&write_callback_).run(rv);
}

Note: we still need a separate WeakPtrFactory so that this can be canceled in
Disconnect().

+                 write_callback_weak_factory_.GetWeakPtr(),
+                 ResetAndReturn(&write_callback_),
+                 rv));
 }
 
 void SpdyProxyClientSocket::OnClose(int status)  {
   was_ever_used_ = spdy_stream_->WasEverUsed();
   spdy_stream_.reset();
 
   bool connecting = next_state_ != STATE_DISCONNECTED &&
       next_state_ < STATE_OPEN;
   if (next_state_ == STATE_OPEN)
     next_state_ = STATE_CLOSED;
@@ skipping 15 matching lines @@
   } else if (!read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(scoped_ptr<SpdyBuffer>());
   }
   // This may have been deleted by read_callback_, so check first.
   if (weak_ptr.get() && !write_callback.is_null())
     write_callback.Run(ERR_CONNECTION_CLOSED);
 }
 
 }  // namespace net