Visualize status of port forwarding sockets in chrome:inspect Devices tab

chrome/browser/devtools/tethering_adb_filter.cc

 // Copyright (c) 2013 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/tethering_adb_filter.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 13 matching lines @@
 #include "net/dns/host_resolver.h"
 #include "net/socket/tcp_client_socket.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const int kAdbPort = 5037;
 const int kBufferSize = 16 * 1024;
 
+const int kStatusError = -2;
+const int kStatusConnecting = -1;
+const int kStatusOK = 0;

[pfeldman, 2013/08/08 16:43:22]

kStatusOk. Is that enum?

[Vladislav Kaznacheev, 2013/08/09 08:24:58]

Done
On 2013/08/08 16:43:22, pfeldman wrote:

+
 static const char kPortAttribute[] = "port";
 static const char kConnectionIdAttribute[] = "connectionId";
 static const char kTetheringAccepted[] = "Tethering.accepted";
 static const char kTetheringBind[] = "Tethering.bind";
 static const char kTetheringUnbind[] = "Tethering.unbind";
 static const char kLocalAbstractCommand[] = "localabstract:%s";
 
 static const char kDevToolsRemoteSocketName[] = "chrome_devtools_remote";
 static const char kDevToolsRemoteBrowserTarget[] = "/devtools/browser";
 
 class SocketTunnel {
  public:
-  explicit SocketTunnel(const std::string& location)
+  typedef base::Callback<void(int)> CounterCallback;
+
+  SocketTunnel(const std::string& location, const CounterCallback& callback)
       : location_(location),
         pending_writes_(0),
-        pending_destruction_(false) {
+        pending_destruction_(false),
+        callback_(callback) {
+    callback_.Run(1);
   }
 
   void Start(int result, net::StreamSocket* socket) {
     if (result < 0) {
       SelfDestruct();
       return;
     }
     remote_socket_.reset(socket);
 
     std::vector<std::string> tokens;
@@ skipping 28 matching lines @@
                                               base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       OnConnected(result);
   }
 
   ~SocketTunnel() {
     if (host_socket_)
       host_socket_->Disconnect();
     if (remote_socket_)
       remote_socket_->Disconnect();
+    callback_.Run(-1);
   }
 
   void OnConnected(int result) {
     if (result < 0) {
       SelfDestruct();
       return;
     }
 
     Pump(host_socket_.get(), remote_socket_.get());
     Pump(remote_socket_.get(), host_socket_.get());
@@ skipping 75 matching lines @@
     delete this;
   }
 
   std::string location_;
   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_;
   bool pending_destruction_;
+  CounterCallback callback_;
 };
 
 }  // namespace
 
 TetheringAdbFilter::TetheringAdbFilter(int adb_port,
                                        const std::string& serial,
                                        base::MessageLoop* adb_message_loop,
                                        PrefService* pref_service,
                                        scoped_refptr<AdbWebSocket> web_socket)
     : adb_port_(adb_port),
@@ skipping 66 matching lines @@
 
     SendCommand(method, port);
   }
 }
 
 void TetheringAdbFilter::SendCommand(const std::string& method, int port) {
   base::DictionaryValue params;
   params.SetInteger(kPortAttribute, port);
   DevToolsProtocol::Command command(++command_id_, method, &params);
   web_socket_->SendFrameOnHandlerThread(command.Serialize());
+
+  if (method == kTetheringBind) {
+    pending_responses_[command.id()] =
+        base::Bind(&TetheringAdbFilter::ProcessBindResponseOnUIThread,
+                   weak_factory_.GetWeakPtr(), port);
+#if defined(DEBUG_DEVTOOLS)
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+       base::Bind(&TetheringAdbFilter::ProcessBindResponseOnUIThread,
+                          weak_factory_.GetWeakPtr(), port, kStatusConnecting));
+#endif  // defined(DEBUG_DEVTOOLS)
+  } else {
+    DCHECK_EQ(kTetheringUnbind, method);
+    pending_responses_[command.id()] =
+        base::Bind(&TetheringAdbFilter::ProcessUnbindResponseOnUIThread,
+                   weak_factory_.GetWeakPtr(), port);
+  }
+}
+
+bool TetheringAdbFilter::ProcessResponse(const std::string& message) {

[pfeldman, 2013/08/08 16:43:22]

Sounds like a part of devtools_protocol.

[Vladislav Kaznacheev, 2013/08/09 08:24:58]

You mean move the pending_responses_ part into DevToolsProtocol? Lets wait for
the second usage before generalizing.

On 2013/08/08 16:43:22, pfeldman wrote:

+  scoped_ptr<DevToolsProtocol::Response> response(
+      DevToolsProtocol::ParseResponse(message));
+  if (!response)
+    return false;
+
+  CommandCallbackMap::iterator it = pending_responses_.find(response->id());
+  if (it == pending_responses_.end())
+    return false;
+
+  CommandCallback callback = it->second;
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(callback, response->error_code() ? kStatusError : kStatusOK));
+  pending_responses_.erase(it);
+  return true;
+}
+
+void TetheringAdbFilter::ProcessBindResponseOnUIThread(
+    int port, PortStatus status) {
+  port_status_[port] = status;
+}
+
+void TetheringAdbFilter::ProcessUnbindResponseOnUIThread(
+    int port, PortStatus status) {
+  PortStatusMap::iterator it = port_status_.find(port);
+  if (it == port_status_.end())
+    return;
+  if (status == kStatusError)
+    it->second = status;
+  else
+    port_status_.erase(it);
+}
+
+void TetheringAdbFilter::UpdateSocketCount(int port, int increment) {
+#if defined(DEBUG_DEVTOOLS)
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+     base::Bind(&TetheringAdbFilter::UpdateSocketCountOnUIThread,
+        weak_factory_.GetWeakPtr(), port, increment));
+#endif  // defined(DEBUG_DEVTOOLS)
+}
+
+void TetheringAdbFilter::UpdateSocketCountOnUIThread(int port, int increment) {
+  PortStatusMap::iterator it = port_status_.find(port);
+  if (it == port_status_.end())
+    return;
+  if (it->second < 0 || (it->second == 0 && increment < 0))
+    return;
+  it->second += increment;
 }
 
 bool TetheringAdbFilter::ProcessIncomingMessage(const std::string& message) {
   DCHECK_EQ(base::MessageLoop::current(), adb_message_loop_);
 
-  // Only parse messages that might be Tethering.accepted event.
-  if (message.length() > 200 ||
-      message.find(kTetheringAccepted) == std::string::npos)
+  if (message.length() > 200)

[pfeldman, 2013/08/08 16:43:22]

This check is no longer needed - you are the only protocol client.

[Vladislav Kaznacheev, 2013/08/09 08:24:58]

Removed this check and the one looking for kTetheringAccepted string.
On 2013/08/08 16:43:22, pfeldman wrote:

+    return false;
+
+  if (ProcessResponse(message))
+    return true;
+
+  if (message.find(kTetheringAccepted) == std::string::npos)
     return false;
 
   scoped_ptr<DevToolsProtocol::Notification> notification(
       DevToolsProtocol::ParseNotification(message));
   if (!notification)
     return false;
 
   if (notification->method() != kTetheringAccepted)
     return false;
 
   DictionaryValue* params = notification->params();
   if (!params)
     return false;
 
   int port;
   std::string connection_id;
   if (!params->GetInteger(kPortAttribute, &port) ||
       !params->GetString(kConnectionIdAttribute, &connection_id))
     return false;
 
   std::map<int, std::string>::iterator it = forwarding_map_.find(port);
   if (it == forwarding_map_.end())
     return false;
 
   std::string location = it->second;
 
-  SocketTunnel* tunnel = new SocketTunnel(location);
+  SocketTunnel* tunnel = new SocketTunnel(location,
+      base::Bind(&TetheringAdbFilter::UpdateSocketCount,
+                weak_factory_.GetWeakPtr(),
+                port));
+
   std::string command = base::StringPrintf(kLocalAbstractCommand,
                                            connection_id.c_str());
   AdbClientSocket::TransportQuery(
       adb_port_, serial_, command,
       base::Bind(&SocketTunnel::Start, base::Unretained(tunnel)));
   return true;
 }
 
 class PortForwardingController::Connection : public AdbWebSocket::Delegate {
  public:
   Connection(
       Registry* registry,
       scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
       base::MessageLoop* adb_message_loop,
       PrefService* pref_service);
 
   void Shutdown();
 
+  TetheringAdbFilter::PortStatusMap port_status();
+
  private:
   virtual ~Connection();
 
   virtual void OnSocketOpened() OVERRIDE;
   virtual void OnFrameRead(const std::string& message) OVERRIDE;
   virtual void OnSocketClosed(bool closed_by_device) OVERRIDE;
   virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE;
 
   Registry* registry_;
   const std::string serial_;
@@ skipping 18 matching lines @@
         device, kDevToolsRemoteSocketName, kDevToolsRemoteBrowserTarget,
         adb_message_loop_, this);
 }
 
 void PortForwardingController::Connection::Shutdown() {
   registry_ = NULL;
   // This will have no effect if the socket is not connected yet.
   web_socket_->Disconnect();
 }
 
+TetheringAdbFilter::PortStatusMap
+PortForwardingController::Connection::port_status() {
+  if (tethering_adb_filter_)
+    return tethering_adb_filter_->port_status();
+  else
+    return TetheringAdbFilter::PortStatusMap();
+}
+
 PortForwardingController::Connection::~Connection() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (registry_) {
     DCHECK(registry_->find(serial_) != registry_->end());
     registry_->erase(serial_);
   }
 }
 
 void PortForwardingController::Connection::OnSocketOpened() {
   if (!registry_) {
@@ skipping 27 matching lines @@
     : adb_message_loop_(adb_message_loop),
       pref_service_(pref_service) {
 }
 
 PortForwardingController::~PortForwardingController() {
   for (Registry::iterator it = registry_.begin(); it != registry_.end(); ++it)
     it->second->Shutdown();
 }
 
 void PortForwardingController::UpdateDeviceList(
-    const DevToolsAdbBridge::RemoteDevices& devices) {
-  for (DevToolsAdbBridge::RemoteDevices::const_iterator it = devices.begin();
+    DevToolsAdbBridge::RemoteDevices& devices) {
+  for (DevToolsAdbBridge::RemoteDevices::iterator it = devices.begin();
        it != devices.end(); ++it) {
-    if (registry_.find((*it)->serial()) == registry_.end()) {
+    Registry::iterator rit = registry_.find((*it)->serial());
+    if (rit == registry_.end()) {
       // Will delete itself when disconnected.
       new Connection(
           &registry_, (*it)->device(), adb_message_loop_, pref_service_);
+    } else {
+      (*it)->SetPortStatus((*rit).second->port_status());
     }
   }
 }