Merge TetheringAdbFilter into PortForwardingController::Connection class.

chrome/browser/devtools/port_forwarding_controller.cc

 // Copyright 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/port_forwarding_controller.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 244 matching lines @@
         IsVersionLower(newest_version, current_version)) {
       socket = browser->socket();
       newest_version = current_version;
     }
   }
   return socket;
 }
 
 }  // namespace
 
-class TetheringAdbFilter : public base::RefCountedThreadSafe<
-    TetheringAdbFilter,
-    content::BrowserThread::DeleteOnUIThread> {
+class PortForwardingController::Connection
+    : public AdbWebSocket::Delegate,
+      public base::RefCountedThreadSafe<
+          Connection,
+          content::BrowserThread::DeleteOnUIThread> {
  public:
   typedef DevToolsAdbBridge::RemoteDevice::PortStatus PortStatus;
   typedef DevToolsAdbBridge::RemoteDevice::PortStatusMap PortStatusMap;
 
-  TetheringAdbFilter(scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
-                     base::MessageLoop* adb_message_loop,
-                     PrefService* pref_service,
-                     scoped_refptr<AdbWebSocket> web_socket);
+  Connection(Registry* registry,
+             scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+             const std::string& socket,
+             scoped_refptr<DevToolsAdbBridge> bridge,
+             PrefService* pref_service);
 
   const PortStatusMap& GetPortStatusMap();
 
-  bool ProcessIncomingMessage(const std::string& message);
+  void Shutdown();
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
-  friend class base::DeleteHelper<TetheringAdbFilter>;
+  friend class base::DeleteHelper<Connection>;
 
-  virtual ~TetheringAdbFilter();
+  virtual ~Connection();
 
   typedef std::map<int, std::string> ForwardingMap;
 
   typedef base::Callback<void(PortStatus)> CommandCallback;
   typedef std::map<int, CommandCallback> CommandCallbackMap;
 
   void OnPrefsChange();
 
   void ChangeForwardingMap(ForwardingMap map);
 
   void SerializeChanges(const std::string& method,
                         const ForwardingMap& old_map,
                         const ForwardingMap& new_map);
 
   void SendCommand(const std::string& method, int port);
   bool ProcessResponse(const std::string& json);
 
   void ProcessBindResponse(int port, PortStatus status);
   void ProcessUnbindResponse(int port, PortStatus status);
   void UpdateSocketCount(int port, int increment);
   void UpdatePortStatusMap();
   void UpdatePortStatusMapOnUIThread(const PortStatusMap& status_map);
 
+  // AdbWebSocket::Delegate implementation:
+  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;
+
+  PortForwardingController::Registry* registry_;
   scoped_refptr<DevToolsAdbBridge::AndroidDevice> device_;
-  base::MessageLoop* adb_message_loop_;
+  scoped_refptr<DevToolsAdbBridge> bridge_;
   PrefChangeRegistrar pref_change_registrar_;
   scoped_refptr<AdbWebSocket> web_socket_;
   int command_id_;
   ForwardingMap forwarding_map_;
   CommandCallbackMap pending_responses_;
   PortStatusMap port_status_;
   PortStatusMap port_status_on_ui_thread_;
 
-  DISALLOW_COPY_AND_ASSIGN(TetheringAdbFilter);
+  DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
-TetheringAdbFilter::TetheringAdbFilter(
+PortForwardingController::Connection::Connection(
+    Registry* registry,
     scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
-    base::MessageLoop* adb_message_loop,
-    PrefService* pref_service,
-    scoped_refptr<AdbWebSocket> web_socket)
-    : device_(device),
-      adb_message_loop_(adb_message_loop),
-      web_socket_(web_socket),
+    const std::string& socket,
+    scoped_refptr<DevToolsAdbBridge> bridge,
+    PrefService* pref_service)
+    : registry_(registry),
+      device_(device),
+      bridge_(bridge),
       command_id_(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   pref_change_registrar_.Init(pref_service);
-
-  OnPrefsChange();
-
-  base::Closure pref_callback = base::Bind(
-      &TetheringAdbFilter::OnPrefsChange, base::Unretained(this));
-  pref_change_registrar_.Add(
-      prefs::kDevToolsPortForwardingEnabled, pref_callback);
-  pref_change_registrar_.Add(
-      prefs::kDevToolsPortForwardingConfig, pref_callback);
+  (*registry_)[device_->serial()] = this;
+  web_socket_ = new AdbWebSocket(
+      device, socket, kDevToolsRemoteBrowserTarget,
+      bridge_->GetAdbMessageLoop(), this);
+  AddRef();  // Balanced in OnSocketClosed();
 }
 
-TetheringAdbFilter::~TetheringAdbFilter() {
+void PortForwardingController::Connection::Shutdown() {
+  registry_ = NULL;
+  // This will have no effect if the socket is not connected yet.
+  web_socket_->Disconnect();
 }
 
-void TetheringAdbFilter::OnPrefsChange() {
+PortForwardingController::Connection::~Connection() {
+  if (registry_) {
+    DCHECK(registry_->find(device_->serial()) != registry_->end());
+    registry_->erase(device_->serial());
+  }
+}
+
+void PortForwardingController::Connection::OnPrefsChange() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ForwardingMap new_forwarding_map;
 
   PrefService* pref_service = pref_change_registrar_.prefs();
   bool enabled =
       pref_service->GetBoolean(prefs::kDevToolsPortForwardingEnabled);
   if (enabled) {
     const DictionaryValue* dict =
         pref_service->GetDictionary(prefs::kDevToolsPortForwardingConfig);
     for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
       int port_num;
       std::string location;
       if (base::StringToInt(it.key(), &port_num) &&
           dict->GetString(it.key(), &location))
         new_forwarding_map[port_num] = location;
     }
   }
 
-  adb_message_loop_->PostTask(
+  bridge_->GetAdbMessageLoop()->PostTask(
       FROM_HERE,
-      base::Bind(&TetheringAdbFilter::ChangeForwardingMap,
+      base::Bind(&Connection::ChangeForwardingMap,
                  this, new_forwarding_map));
 }
 
-void TetheringAdbFilter::ChangeForwardingMap(ForwardingMap new_forwarding_map) {
-  DCHECK_EQ(base::MessageLoop::current(), adb_message_loop_);
+void PortForwardingController::Connection::ChangeForwardingMap(
+    ForwardingMap new_forwarding_map) {
+  DCHECK_EQ(base::MessageLoop::current(), bridge_->GetAdbMessageLoop());
 
   SerializeChanges(kTetheringUnbind, new_forwarding_map, forwarding_map_);
   SerializeChanges(kTetheringBind, forwarding_map_, new_forwarding_map);
   forwarding_map_ = new_forwarding_map;
 }
 
-void TetheringAdbFilter::SerializeChanges(const std::string& method,
-                                          const ForwardingMap& old_map,
-                                          const ForwardingMap& new_map) {
+void PortForwardingController::Connection::SerializeChanges(
+    const std::string& method,
+    const ForwardingMap& old_map,
+    const ForwardingMap& new_map) {
   for (ForwardingMap::const_iterator new_it(new_map.begin());
       new_it != new_map.end(); ++new_it) {
     int port = new_it->first;
     const std::string& location = new_it->second;
     ForwardingMap::const_iterator old_it = old_map.find(port);
     if (old_it != old_map.end() && old_it->second == location)
       continue;  // The port points to the same location in both configs, skip.
 
     SendCommand(method, port);
   }
 }
 
-void TetheringAdbFilter::SendCommand(const std::string& method, int port) {
+void PortForwardingController::Connection::SendCommand(
+    const std::string& method, int port) {
   base::DictionaryValue params;
   params.SetInteger(kPortAttribute, port);
   DevToolsProtocol::Command command(++command_id_, method, &params);
 
   if (method == kTetheringBind) {
     pending_responses_[command.id()] =
-        base::Bind(&TetheringAdbFilter::ProcessBindResponse,
+        base::Bind(&Connection::ProcessBindResponse,
                    base::Unretained(this), port);
 #if defined(DEBUG_DEVTOOLS)
     port_status_[port] = kStatusConnecting;
     UpdatePortStatusMap();
 #endif  // defined(DEBUG_DEVTOOLS)
   } else {
     DCHECK_EQ(kTetheringUnbind, method);
 
     PortStatusMap::iterator it = port_status_.find(port);
     if (it != port_status_.end() && it->second == kStatusError) {
       // The bind command failed on this port, do not attempt unbind.
       port_status_.erase(it);
       UpdatePortStatusMap();
       return;
     }
 
     pending_responses_[command.id()] =
-        base::Bind(&TetheringAdbFilter::ProcessUnbindResponse,
+        base::Bind(&Connection::ProcessUnbindResponse,
                    base::Unretained(this), port);
 #if defined(DEBUG_DEVTOOLS)
     port_status_[port] = kStatusDisconnecting;
     UpdatePortStatusMap();
 #endif  // defined(DEBUG_DEVTOOLS)
   }
 
   web_socket_->SendFrameOnHandlerThread(command.Serialize());
 }
 
-bool TetheringAdbFilter::ProcessResponse(const std::string& message) {
+bool PortForwardingController::Connection::ProcessResponse(
+    const std::string& message) {
   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;
 
   it->second.Run(response->error_code() ? kStatusError : kStatusOK);
   pending_responses_.erase(it);
   return true;
 }
 
-void TetheringAdbFilter::ProcessBindResponse(int port, PortStatus status) {
+void PortForwardingController::Connection::ProcessBindResponse(
+    int port, PortStatus status) {
   port_status_[port] = status;
   UpdatePortStatusMap();
 }
 
-void TetheringAdbFilter::ProcessUnbindResponse(int port, PortStatus status) {
+void PortForwardingController::Connection::ProcessUnbindResponse(
+    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);
   UpdatePortStatusMap();
 }
 
-void TetheringAdbFilter::UpdateSocketCount(int port, int increment) {
+void PortForwardingController::Connection::UpdateSocketCount(
+    int port, int increment) {
 #if defined(DEBUG_DEVTOOLS)
   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;
   UpdatePortStatusMap();
 #endif  // defined(DEBUG_DEVTOOLS)
 }
 
-void TetheringAdbFilter::UpdatePortStatusMap() {
+void PortForwardingController::Connection::UpdatePortStatusMap() {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-     base::Bind(&TetheringAdbFilter::UpdatePortStatusMapOnUIThread,
+     base::Bind(&Connection::UpdatePortStatusMapOnUIThread,
         this, port_status_));
 }
 
-void TetheringAdbFilter::UpdatePortStatusMapOnUIThread(
+void PortForwardingController::Connection::UpdatePortStatusMapOnUIThread(
     const PortStatusMap& status_map) {
   port_status_on_ui_thread_ = status_map;
 }
 
-const TetheringAdbFilter::PortStatusMap&
-TetheringAdbFilter::GetPortStatusMap() {
+const PortForwardingController::Connection::PortStatusMap&
+PortForwardingController::Connection::GetPortStatusMap() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return port_status_on_ui_thread_;
 }
 
-bool TetheringAdbFilter::ProcessIncomingMessage(const std::string& message) {
-  DCHECK_EQ(base::MessageLoop::current(), adb_message_loop_);
+void PortForwardingController::Connection::OnSocketOpened() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!registry_) {
+    // Socket was created after Shutdown was called. Disconnect immediately.
+    web_socket_->Disconnect();
+    return;
+  }
+  OnPrefsChange();
+  base::Closure pref_callback = base::Bind(
+      &Connection::OnPrefsChange, base::Unretained(this));
+  pref_change_registrar_.Add(
+      prefs::kDevToolsPortForwardingEnabled, pref_callback);
+  pref_change_registrar_.Add(
+      prefs::kDevToolsPortForwardingConfig, pref_callback);
+}
 
+void PortForwardingController::Connection::OnFrameRead(
+    const std::string& message) {
+}
+
+void PortForwardingController::Connection::OnSocketClosed(
+    bool closed_by_device) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  Release();  // Balanced in the constructor.
+}
+
+bool PortForwardingController::Connection::ProcessIncomingMessage(
+    const std::string& message) {
+  DCHECK_EQ(base::MessageLoop::current(), bridge_->GetAdbMessageLoop());
   if (ProcessResponse(message))
     return true;
 
   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,
-      base::Bind(&TetheringAdbFilter::UpdateSocketCount, this, port));
+      base::Bind(&Connection::UpdateSocketCount, this, port));
 
   device_->OpenSocket(connection_id.c_str(),
       base::Bind(&SocketTunnel::Start, base::Unretained(tunnel)));
   return true;
 }
 
-class PortForwardingController::Connection : public AdbWebSocket::Delegate {
- public:
-  Connection(
-      Registry* registry,
-      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
-      const std::string& socket,
-      scoped_refptr<DevToolsAdbBridge> bridge,
-      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_;
-  scoped_refptr<DevToolsAdbBridge::AndroidDevice> device_;
-  scoped_refptr<DevToolsAdbBridge> bridge_;
-  PrefService* pref_service_;
-
-  scoped_refptr<TetheringAdbFilter> tethering_adb_filter_;
-  scoped_refptr<AdbWebSocket> web_socket_;
-};
-
-PortForwardingController::Connection::Connection(
-    Registry* registry,
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
-    const std::string& socket,
-    scoped_refptr<DevToolsAdbBridge> bridge,
-    PrefService* pref_service)
-    : registry_(registry),
-      device_(device),
-      bridge_(bridge),
-      pref_service_(pref_service) {
-   (*registry_)[device_->serial()] = this;
-   web_socket_ = new AdbWebSocket(
-        device, socket, kDevToolsRemoteBrowserTarget,
-        bridge->GetAdbMessageLoop(), 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_->GetPortStatusMap();
-  else
-    return TetheringAdbFilter::PortStatusMap();
-}
-
-PortForwardingController::Connection::~Connection() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (registry_) {
-    DCHECK(registry_->find(device_->serial()) != registry_->end());
-    registry_->erase(device_->serial());
-  }
-}
-
-void PortForwardingController::Connection::OnSocketOpened() {
-  if (!registry_) {
-    // Socket was created after Shutdown was called. Disconnect immediately.
-    web_socket_->Disconnect();
-    return;
-  }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  tethering_adb_filter_ = new TetheringAdbFilter(
-      device_, bridge_->GetAdbMessageLoop(), pref_service_, web_socket_);
-}
-
-void PortForwardingController::Connection::OnFrameRead(
-    const std::string& message) {
-}
-
-void PortForwardingController::Connection::OnSocketClosed(
-    bool closed_by_device) {
-  delete this;
-}
-
-bool PortForwardingController::Connection::ProcessIncomingMessage(
-    const std::string& message) {
-  return tethering_adb_filter_->ProcessIncomingMessage(message);
-}
-
-
 PortForwardingController::PortForwardingController(
     scoped_refptr<DevToolsAdbBridge> bridge,
     PrefService* pref_service)
     : bridge_(bridge),
       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();
        it != devices.end(); ++it) {
     Registry::iterator rit = registry_.find((*it)->serial());
     if (rit == registry_.end()) {
       std::string socket = FindBestSocketForTethering((*it)->browsers());
       if (!socket.empty() || (*it)->serial().empty()) {
         // Will delete itself when disconnected.
         new Connection(
           &registry_, (*it)->device(), socket, bridge_, pref_service_);
       }
     } else {
-      (*it)->set_port_status((*rit).second->port_status());
+      (*it)->set_port_status((*rit).second->GetPortStatusMap());
     }
   }
 }