Add UI DevTools under chrome://inspect/#other

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/memory/ptr_util.h"
 #include "chrome/browser/devtools/devtools_targets_ui.h"
 #include "chrome/browser/devtools/devtools_ui_bindings.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/webui/theme_source.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/browser_resources.h"
 #include "components/prefs/pref_service.h"
+#include "components/ui_devtools/devtools_server.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "content/public/common/frame_navigate_params.h"
 
 using content::DevToolsAgentHost;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
 const char kInitUICommand[]  = "init-ui";
 const char kInspectCommand[]  = "inspect";
+const char kInspectAdditionalCommand[] = "inspect-additional";
 const char kActivateCommand[]  = "activate";
-const char kCloseCommand[]  = "close";
+const char kCloseCommand[] = "close";
 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";
 
+const char kNameField[] = "name";
+const char kUrlField[] = "url";
+const char kIsAdditionalField[] = "isAdditional";
+
+void GetUiDevToolsTargets(base::ListValue& targets) {
+  for (const auto& client_pair :
+       ui::devtools::UiDevToolsServer::GetClientNamesAndUrls()) {
+    auto target_data = base::MakeUnique<base::DictionaryValue>();
+    target_data->SetString(kNameField, client_pair.first);
+    target_data->SetString(kUrlField, client_pair.second);
+    target_data->SetBoolean(kIsAdditionalField, true);
+    targets.Append(std::move(target_data));
+  }
+}
+
 // 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 HandleInspectAdditionalCommand(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)));
   web_ui()->RegisterMessageCallback(kInspectCommand,
       base::Bind(&InspectMessageHandler::HandleInspectCommand,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kInspectAdditionalCommand,
+      base::Bind(&InspectMessageHandler::HandleInspectAdditionalCommand,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kActivateCommand,
       base::Bind(&InspectMessageHandler::HandleActivateCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kCloseCommand,
       base::Bind(&InspectMessageHandler::HandleCloseCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kDiscoverUsbDevicesEnabledCommand,
       base::Bind(&InspectMessageHandler::HandleBooleanPrefChanged,
                   base::Unretained(this),
                   &prefs::kDevToolsDiscoverUsbDevicesEnabled[0]));
@@ skipping 36 matching lines @@
          (!arg2 || (arg_size > 2 && args->GetString(2, arg2)));
 }
 
 void InspectMessageHandler::HandleInspectCommand(const base::ListValue* args) {
   std::string source;
   std::string id;
   if (ParseStringArgs(args, &source, &id))
     inspect_ui_->Inspect(source, id);
 }
 
+void InspectMessageHandler::HandleInspectAdditionalCommand(
+    const base::ListValue* args) {
+  std::string url;
+  if (ParseStringArgs(args, &url, nullptr)) {
+    WebContents* inspect_ui = web_ui()->GetWebContents();
+    web_ui()->GetWebContents()->GetDelegate()->OpenURLFromTab(
+        inspect_ui,
+        content::OpenURLParams(GURL(url), content::Referrer(),
+                               WindowOpenDisposition::NEW_FOREGROUND_TAB,
+                               ui::PAGE_TRANSITION_AUTO_TOPLEVEL, false));
+  }
+}
+
 void InspectMessageHandler::HandleActivateCommand(const base::ListValue* args) {
   std::string source;
   std::string id;
   if (ParseStringArgs(args, &source, &id))
     inspect_ui_->Activate(source, id);
 }
 
 void InspectMessageHandler::HandleCloseCommand(const base::ListValue* args) {
   std::string source;
   std::string id;
@@ skipping 237 matching lines @@
 
 void InspectUI::StartListeningNotifications() {
   if (!target_handlers_.empty())  // Possible when reloading the page.
     StopListeningNotifications();
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
   DevToolsTargetsUIHandler::Callback callback =
       base::Bind(&InspectUI::PopulateTargets, base::Unretained(this));
 
+  base::ListValue additional_targets;
+  GetUiDevToolsTargets(additional_targets);
+  PopulateAdditionalTargets(additional_targets);
+
   AddTargetUIHandler(
       DevToolsTargetsUIHandler::CreateForLocal(callback));
   if (profile->IsOffTheRecord()) {
     ShowIncognitoWarning();
   } else {
     AddTargetUIHandler(
         DevToolsTargetsUIHandler::CreateForAdb(callback, profile));
   }
 
   port_status_serializer_.reset(
@@ skipping 130 matching lines @@
   return it != target_handlers_.end() ?
       it->second->GetTarget(target_id) : nullptr;
 }
 
 void InspectUI::PopulateTargets(const std::string& source,
                                 const base::ListValue& targets) {
   web_ui()->CallJavascriptFunctionUnsafe("populateTargets",
                                          base::StringValue(source), targets);
 }
 
+void InspectUI::PopulateAdditionalTargets(const base::ListValue& targets) {
+  web_ui()->CallJavascriptFunctionUnsafe("populateAdditionalTargets", targets);
+}
+
 void InspectUI::ForceUpdateIfNeeded(const std::string& source_id,
                                     const std::string& target_type) {
   // TODO(dgozman): remove this after moving discovery to protocol.
   // See crbug.com/398049.
   if (target_type != content::DevToolsAgentHost::kTypeServiceWorker)
     return;
   DevToolsTargetsUIHandler* handler = FindTargetHandler(source_id);
   if (handler)
     handler->ForceUpdate();
 }
 
 void InspectUI::PopulatePortStatus(const base::Value& status) {
   web_ui()->CallJavascriptFunctionUnsafe("populatePortStatus", status);
 }
 
 void InspectUI::ShowIncognitoWarning() {
   web_ui()->CallJavascriptFunctionUnsafe("showIncognitoWarning");
 }