[DevTools] Explicitly add Tethering domain to browser protocol.

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"
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/devtools/devtools_protocol.h"
+#include "chrome/browser/devtools/devtools_protocol_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/dns/host_resolver.h"
 #include "net/socket/tcp_client_socket.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const int kBufferSize = 16 * 1024;
 
 enum {
   kStatusError = -3,
   kStatusDisconnecting = -2,
   kStatusConnecting = -1,
   kStatusOK = 0,
   // Positive values are used to count open connections.
 };
 
-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";
+namespace tethering = ::chrome::devtools::Tethering;
 
 static const char kDevToolsRemoteBrowserTarget[] = "/devtools/browser";
 const int kMinVersionPortForwarding = 28;
 
 class SocketTunnel : public base::NonThreadSafe {
  public:
   typedef base::Callback<void(int)> CounterCallback;
 
   static void StartTunnel(const std::string& host,
                           int port,
@@ skipping 283 matching lines @@
   if (registry_) {
     DCHECK(registry_->find(device_->serial()) != registry_->end());
     registry_->erase(device_->serial());
   }
 }
 
 void PortForwardingController::Connection::UpdateForwardingMap(
     const ForwardingMap& new_forwarding_map) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (connected_) {
-    SerializeChanges(kTetheringUnbind, new_forwarding_map, forwarding_map_);
-    SerializeChanges(kTetheringBind, forwarding_map_, new_forwarding_map);
+    SerializeChanges(tethering::unbind::kName,
+        new_forwarding_map, forwarding_map_);
+    SerializeChanges(tethering::bind::kName,
+        forwarding_map_, new_forwarding_map);
   }
   forwarding_map_ = new_forwarding_map;
 }
 
 void PortForwardingController::Connection::SerializeChanges(
     const std::string& method,
     const ForwardingMap& old_map,
     const ForwardingMap& new_map) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   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 PortForwardingController::Connection::SendCommand(
     const std::string& method, int port) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::DictionaryValue params;
-  params.SetInteger(kPortAttribute, port);
+  if (method == tethering::bind::kName) {
+    params.SetInteger(tethering::bind::kParamPort, port);
+  } else {
+    DCHECK_EQ(tethering::unbind::kName, method);
+    params.SetInteger(tethering::unbind::kParamPort, port);
+  }
   DevToolsProtocol::Command command(++command_id_, method, &params);
 
-  if (method == kTetheringBind) {
+  if (method == tethering::bind::kName) {
     pending_responses_[command.id()] =
         base::Bind(&Connection::ProcessBindResponse,
                    base::Unretained(this), port);
 #if defined(DEBUG_DEVTOOLS)
     port_status_[port] = kStatusConnecting;
 #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);
       return;
     }
 
     pending_responses_[command.id()] =
         base::Bind(&Connection::ProcessUnbindResponse,
                    base::Unretained(this), port);
@@ skipping 63 matching lines @@
 }
 
 void PortForwardingController::Connection::OnSocketOpened() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!registry_) {
     // Socket was created after Shutdown was called. Disconnect immediately.
     web_socket_->Disconnect();
     return;
   }
   connected_ = true;
-  SerializeChanges(kTetheringBind, ForwardingMap(), forwarding_map_);
+  SerializeChanges(tethering::bind::kName, ForwardingMap(), forwarding_map_);
 }
 
 void PortForwardingController::Connection::OnSocketClosed(
     bool closed_by_device) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Release();  // Balanced in the constructor.
 }
 
 void PortForwardingController::Connection::OnFrameRead(
     const std::string& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (ProcessResponse(message))
     return;
 
   scoped_ptr<DevToolsProtocol::Notification> notification(
       DevToolsProtocol::ParseNotification(message));
   if (!notification)
     return;
 
-  if (notification->method() != kTetheringAccepted)
+  if (notification->method() != tethering::accepted::kName)
     return;
 
   base::DictionaryValue* params = notification->params();
   if (!params)
     return;
 
   int port;
   std::string connection_id;
-  if (!params->GetInteger(kPortAttribute, &port) ||
-      !params->GetString(kConnectionIdAttribute, &connection_id))
+  if (!params->GetInteger(tethering::accepted::kParamPort, &port) ||
+      !params->GetString(tethering::accepted::kParamConnectionId,
+                         &connection_id))
     return;
 
   std::map<int, std::string>::iterator it = forwarding_map_.find(port);
   if (it == forwarding_map_.end())
     return;
 
   std::string location = it->second;
   std::vector<std::string> tokens;
   Tokenize(location, ":", &tokens);
   int destination_port = 0;
@@ skipping 78 matching lines @@
 void PortForwardingController::UpdateConnections() {
   for (Registry::iterator it = registry_.begin(); it != registry_.end(); ++it)
     it->second->UpdateForwardingMap(forwarding_map_);
 }
 
 void PortForwardingController::ShutdownConnections() {
   for (Registry::iterator it = registry_.begin(); it != registry_.end(); ++it)
     it->second->Shutdown();
   registry_.clear();
 }