DevTools: Fixed suspected bug in port forwarding

chrome/browser/devtools/device/port_forwarding_controller.cc

 // Copyright 2014 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 "chrome/browser/devtools/device/port_forwarding_controller.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 50 matching lines @@
                           int result,
                           net::StreamSocket* socket) {
     if (result < 0)
       return;
     SocketTunnel* tunnel = new SocketTunnel(callback);
     tunnel->Start(socket, host, port);
   }
 
  private:
   explicit SocketTunnel(const CounterCallback& callback)
-      : pending_writes_(0),
+      : pending_io_(0),
         pending_destruction_(false),
         callback_(callback),
         about_to_destroy_(false) {
     callback_.Run(1);
   }
 
   void Start(net::StreamSocket* socket, const std::string& host, int port) {
     remote_socket_.reset(socket);
 
     host_resolver_ = net::HostResolver::CreateDefaultResolver(NULL);
@@ skipping 37 matching lines @@
       SelfDestruct();
       return;
     }
 
     Pump(host_socket_.get(), remote_socket_.get());
     Pump(remote_socket_.get(), host_socket_.get());
   }
 
   void Pump(net::StreamSocket* from, net::StreamSocket* to) {
     scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
+    pending_io_++;
     int result = from->Read(
         buffer.get(),
         kBufferSize,
         base::Bind(
             &SocketTunnel::OnRead, base::Unretained(this), from, to, buffer));
     if (result != net::ERR_IO_PENDING)
       OnRead(from, to, buffer, result);
   }
 
   void OnRead(net::StreamSocket* from,
               net::StreamSocket* to,
               scoped_refptr<net::IOBuffer> buffer,
               int result) {
+    pending_io_--;

[pfeldman, 2014/05/18 06:17:06]

To recap offline discussion: we don't have read timeout, which means we can wait
forever on pending reads. It seems like every solution that makes this object
live longer fixes the test problem.

     if (result <= 0) {
       SelfDestruct();
       return;
     }
 
     int total = result;
     scoped_refptr<net::DrainableIOBuffer> drainable =
         new net::DrainableIOBuffer(buffer.get(), total);
 
-    ++pending_writes_;
+    ++pending_io_;
     result = to->Write(drainable.get(),
                        total,
                        base::Bind(&SocketTunnel::OnWritten,
                                   base::Unretained(this),
                                   drainable,
                                   from,
                                   to));
     if (result != net::ERR_IO_PENDING)
       OnWritten(drainable, from, to, result);
   }
 
   void OnWritten(scoped_refptr<net::DrainableIOBuffer> drainable,
                  net::StreamSocket* from,
                  net::StreamSocket* to,
                  int result) {
-    --pending_writes_;
+    --pending_io_;
     if (result < 0) {
       SelfDestruct();
       return;
     }
 
     drainable->DidConsume(result);
     if (drainable->BytesRemaining() > 0) {
-      ++pending_writes_;
+      ++pending_io_;
       result = to->Write(drainable.get(),
                          drainable->BytesRemaining(),
                          base::Bind(&SocketTunnel::OnWritten,
                                     base::Unretained(this),
                                     drainable,
                                     from,
                                     to));
       if (result != net::ERR_IO_PENDING)
         OnWritten(drainable, from, to, result);
       return;
     }
 
     if (pending_destruction_) {
       SelfDestruct();
       return;
     }
     Pump(from, to);
   }
 
   void SelfDestruct() {
     // In case one of the connections closes, we could get here
     // from another one due to Disconnect firing back on all
     // read callbacks.
     if (about_to_destroy_)
       return;
-    if (pending_writes_ > 0) {
+    if (pending_io_ > 0) {
       pending_destruction_ = true;
       return;
     }
     delete this;
   }
 
   scoped_ptr<net::StreamSocket> remote_socket_;
   scoped_ptr<net::StreamSocket> host_socket_;
   scoped_ptr<net::HostResolver> host_resolver_;
   net::AddressList address_list_;
-  int pending_writes_;
+  int pending_io_;
   bool pending_destruction_;
   CounterCallback callback_;
   bool about_to_destroy_;
 };
 
 typedef DevToolsAndroidBridge::RemoteBrowser::ParsedVersion ParsedVersion;
 
 static bool IsVersionLower(const ParsedVersion& left,
                            const ParsedVersion& right) {
   return std::lexicographical_compare(
@@ skipping 440 matching lines @@
           "PortForwardingController",
           BrowserContextDependencyManager::GetInstance()) {}
 
 PortForwardingController::Factory::~Factory() {}
 
 KeyedService* PortForwardingController::Factory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   Profile* profile = Profile::FromBrowserContext(context);
   return new PortForwardingController(profile);
 }