[DevTools] Add UI for adding remote targets

chrome/browser/ui/webui/inspect_ui.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 "chrome/browser/ui/webui/inspect_ui.h"
 
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "chrome/browser/devtools/devtools_targets_ui.h"
 #include "chrome/browser/devtools/devtools_ui_bindings.h"
@@ skipping 32 matching lines @@
 const char kReloadCommand[]  = "reload";
 const char kOpenCommand[]  = "open";
 const char kInspectBrowser[] = "inspect-browser";
 const char kLocalHost[] = "localhost";
 
 const char kDiscoverUsbDevicesEnabledCommand[] =
     "set-discover-usb-devices-enabled";
 const char kPortForwardingEnabledCommand[] =
     "set-port-forwarding-enabled";
 const char kPortForwardingConfigCommand[] = "set-port-forwarding-config";
+const char kDiscoverTCPTargetsEnabledCommand[] =
+    "set-discover-tcp-targets-enabled";
+const char kTCPDiscoveryConfigCommand[] = "set-tcp-discovery-config";
 
 const char kPortForwardingDefaultPort[] = "8080";
 const char kPortForwardingDefaultLocation[] = "localhost:8080";
 
 // InspectMessageHandler --------------------------------------------
 
 class InspectMessageHandler : public WebUIMessageHandler {
  public:
   explicit InspectMessageHandler(InspectUI* inspect_ui)
       : inspect_ui_(inspect_ui) {}
   ~InspectMessageHandler() override {}
 
  private:
   // WebUIMessageHandler implementation.
   void RegisterMessages() override;
 
   void HandleInitUICommand(const base::ListValue* args);
   void HandleInspectCommand(const base::ListValue* args);
   void HandleActivateCommand(const base::ListValue* args);
   void HandleCloseCommand(const base::ListValue* args);
   void HandleReloadCommand(const base::ListValue* args);
   void HandleOpenCommand(const base::ListValue* args);
   void HandleInspectBrowserCommand(const base::ListValue* args);
   void HandleBooleanPrefChanged(const char* pref_name,
                                 const base::ListValue* args);
   void HandlePortForwardingConfigCommand(const base::ListValue* args);
+  void HandleTCPDiscoveryConfigCommand(const base::ListValue* args);
 
   InspectUI* inspect_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(InspectMessageHandler);
 };
 
 void InspectMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(kInitUICommand,
       base::Bind(&InspectMessageHandler::HandleInitUICommand,
                  base::Unretained(this)));
@@ skipping 10 matching lines @@
       base::Bind(&InspectMessageHandler::HandleBooleanPrefChanged,
                   base::Unretained(this),
                   &prefs::kDevToolsDiscoverUsbDevicesEnabled[0]));
   web_ui()->RegisterMessageCallback(kPortForwardingEnabledCommand,
       base::Bind(&InspectMessageHandler::HandleBooleanPrefChanged,
                  base::Unretained(this),
                  &prefs::kDevToolsPortForwardingEnabled[0]));
   web_ui()->RegisterMessageCallback(kPortForwardingConfigCommand,
       base::Bind(&InspectMessageHandler::HandlePortForwardingConfigCommand,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(kDiscoverTCPTargetsEnabledCommand,
+      base::Bind(&InspectMessageHandler::HandleBooleanPrefChanged,
+                 base::Unretained(this),
+                 &prefs::kDevToolsDiscoverTCPTargetsEnabled[0]));
+  web_ui()->RegisterMessageCallback(kTCPDiscoveryConfigCommand,
+      base::Bind(&InspectMessageHandler::HandleTCPDiscoveryConfigCommand,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kReloadCommand,
       base::Bind(&InspectMessageHandler::HandleReloadCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kOpenCommand,
       base::Bind(&InspectMessageHandler::HandleOpenCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kInspectBrowser,
       base::Bind(&InspectMessageHandler::HandleInspectBrowserCommand,
                  base::Unretained(this)));
 }
@@ skipping 75 matching lines @@
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
     return;
 
   const base::DictionaryValue* dict_src;
   if (args->GetSize() == 1 && args->GetDictionary(0, &dict_src))
     profile->GetPrefs()->Set(prefs::kDevToolsPortForwardingConfig, *dict_src);
 }
 
+void InspectMessageHandler::HandleTCPDiscoveryConfigCommand(
+    const base::ListValue* args) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  if (!profile)
+    return;
+
+  const base::ListValue* list_src;
+  if (args->GetSize() == 1 && args->GetList(0, &list_src))
+    profile->GetPrefs()->Set(prefs::kDevToolsTCPDiscoveryConfig, *list_src);
+}
+
 // DevToolsUIBindingsEnabler ----------------------------------------
 
 class DevToolsUIBindingsEnabler
     : public content::WebContentsObserver {
  public:
   DevToolsUIBindingsEnabler(WebContents* web_contents,
                             const GURL& url);
   ~DevToolsUIBindingsEnabler() override {}
 
   DevToolsUIBindings* GetBindings();
@@ skipping 51 matching lines @@
 InspectUI::~InspectUI() {
   StopListeningNotifications();
 }
 
 void InspectUI::InitUI() {
   SetPortForwardingDefaults();
   StartListeningNotifications();
   UpdateDiscoverUsbDevicesEnabled();
   UpdatePortForwardingEnabled();
   UpdatePortForwardingConfig();
+  UpdateTCPDiscoveryEnabled();
+  UpdateTCPDiscoveryConfig();
 }
 
 void InspectUI::Inspect(const std::string& source_id,
                         const std::string& target_id) {
   scoped_refptr<DevToolsAgentHost> target = FindTarget(source_id, target_id);
   if (target) {
     const std::string target_type = target->GetType();
     target->Inspect();
     ForceUpdateIfNeeded(source_id, target_type);
   }
@@ skipping 118 matching lines @@
   pref_change_registrar_.Init(profile->GetPrefs());
   pref_change_registrar_.Add(prefs::kDevToolsDiscoverUsbDevicesEnabled,
       base::Bind(&InspectUI::UpdateDiscoverUsbDevicesEnabled,
                  base::Unretained(this)));
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingEnabled,
       base::Bind(&InspectUI::UpdatePortForwardingEnabled,
                  base::Unretained(this)));
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingConfig,
       base::Bind(&InspectUI::UpdatePortForwardingConfig,
                  base::Unretained(this)));
+  pref_change_registrar_.Add(prefs::kDevToolsDiscoverTCPTargetsEnabled,
+      base::Bind(&InspectUI::UpdateTCPDiscoveryEnabled,
+                 base::Unretained(this)));
+  pref_change_registrar_.Add(prefs::kDevToolsTCPDiscoveryConfig,
+      base::Bind(&InspectUI::UpdateTCPDiscoveryConfig,
+                 base::Unretained(this)));
 }
 
 void InspectUI::StopListeningNotifications() {
   if (target_handlers_.empty())
     return;
 
   base::STLDeleteValues(&target_handlers_);
 
   port_status_serializer_.reset();
 
@@ skipping 21 matching lines @@
       "updatePortForwardingEnabled",
       *GetPrefValue(prefs::kDevToolsPortForwardingEnabled));
 }
 
 void InspectUI::UpdatePortForwardingConfig() {
   web_ui()->CallJavascriptFunctionUnsafe(
       "updatePortForwardingConfig",
       *GetPrefValue(prefs::kDevToolsPortForwardingConfig));
 }
 
+void InspectUI::UpdateTCPDiscoveryEnabled() {
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "updateTCPDiscoveryEnabled",
+      *GetPrefValue(prefs::kDevToolsDiscoverTCPTargetsEnabled));
+}
+
+void InspectUI::UpdateTCPDiscoveryConfig() {
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "updateTCPDiscoveryConfig",
+      *GetPrefValue(prefs::kDevToolsTCPDiscoveryConfig));
+}
+
 void InspectUI::SetPortForwardingDefaults() {
   Profile* profile = Profile::FromWebUI(web_ui());
   PrefService* prefs = profile->GetPrefs();
 
   bool default_set;
   if (!GetPrefValue(prefs::kDevToolsPortForwardingDefaultSet)->
       GetAsBoolean(&default_set) || default_set) {
     return;
   }
 
@@ skipping 61 matching lines @@
     handler->ForceUpdate();
 }
 
 void InspectUI::PopulatePortStatus(const base::Value& status) {
   web_ui()->CallJavascriptFunctionUnsafe("populatePortStatus", status);
 }
 
 void InspectUI::ShowIncognitoWarning() {
   web_ui()->CallJavascriptFunctionUnsafe("showIncognitoWarning");
 }