1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/webui/inspect_ui.h" 6 7 #include "base/prefs/pref_service.h" 8 #include "base/stl_util.h" 9 #include "chrome/browser/devtools/devtools_target_impl.h" 10 #include "chrome/browser/devtools/devtools_targets_ui.h" 11 #include "chrome/browser/devtools/devtools_ui_bindings.h" 12 #include "chrome/browser/profiles/profile.h" 13 #include "chrome/browser/ui/browser_navigator.h" 14 #include "chrome/browser/ui/singleton_tabs.h" 15 #include "chrome/browser/ui/webui/theme_source.h" 16 #include "chrome/common/pref_names.h" 17 #include "chrome/common/url_constants.h" 18 #include "content/public/browser/devtools_agent_host.h" 19 #include "content/public/browser/devtools_manager.h" 20 #include "content/public/browser/notification_service.h" 21 #include "content/public/browser/notification_source.h" 22 #include "content/public/browser/notification_types.h" 23 #include "content/public/browser/user_metrics.h" 24 #include "content/public/browser/web_contents.h" 25 #include "content/public/browser/web_contents_delegate.h" 26 #include "content/public/browser/web_ui.h" 27 #include "content/public/browser/web_ui_data_source.h" 28 #include "content/public/browser/web_ui_message_handler.h" 29 #include "grit/browser_resources.h" 30 31 using content::WebContents; 32 using content::WebUIMessageHandler; 33 34 namespace { 35 36 const char kInitUICommand[] = "init-ui"; 37 const char kInspectCommand[] = "inspect"; 38 const char kActivateCommand[] = "activate"; 39 const char kCloseCommand[] = "close"; 40 const char kReloadCommand[] = "reload"; 41 const char kOpenCommand[] = "open"; 42 const char kInspectBrowser[] = "inspect-browser"; 43 const char kLocalHost[] = "localhost"; 44 45 const char kDiscoverUsbDevicesEnabledCommand[] = 46 "set-discover-usb-devices-enabled"; 47 const char kPortForwardingEnabledCommand[] = 48 "set-port-forwarding-enabled"; 49 const char kPortForwardingConfigCommand[] = "set-port-forwarding-config"; 50 51 const char kPortForwardingDefaultPort[] = "8080"; 52 const char kPortForwardingDefaultLocation[] = "localhost:8080"; 53 54 class InspectMessageHandler : public WebUIMessageHandler { 55 public: 56 explicit InspectMessageHandler(InspectUI* inspect_ui) 57 : inspect_ui_(inspect_ui) {} 58 virtual ~InspectMessageHandler() {} 59 60 private: 61 // WebUIMessageHandler implementation. 62 virtual void RegisterMessages() OVERRIDE; 63 64 void HandleInitUICommand(const base::ListValue* args); 65 void HandleInspectCommand(const base::ListValue* args); 66 void HandleActivateCommand(const base::ListValue* args); 67 void HandleCloseCommand(const base::ListValue* args); 68 void HandleReloadCommand(const base::ListValue* args); 69 void HandleOpenCommand(const base::ListValue* args); 70 void HandleInspectBrowserCommand(const base::ListValue* args); 71 void HandleBooleanPrefChanged(const char* pref_name, 72 const base::ListValue* args); 73 void HandlePortForwardingConfigCommand(const base::ListValue* args); 74 75 InspectUI* inspect_ui_; 76 77 DISALLOW_COPY_AND_ASSIGN(InspectMessageHandler); 78 }; 79 80 void InspectMessageHandler::RegisterMessages() { 81 web_ui()->RegisterMessageCallback(kInitUICommand, 82 base::Bind(&InspectMessageHandler::HandleInitUICommand, 83 base::Unretained(this))); 84 web_ui()->RegisterMessageCallback(kInspectCommand, 85 base::Bind(&InspectMessageHandler::HandleInspectCommand, 86 base::Unretained(this))); 87 web_ui()->RegisterMessageCallback(kActivateCommand, 88 base::Bind(&InspectMessageHandler::HandleActivateCommand, 89 base::Unretained(this))); 90 web_ui()->RegisterMessageCallback(kCloseCommand, 91 base::Bind(&InspectMessageHandler::HandleCloseCommand, 92 base::Unretained(this))); 93 web_ui()->RegisterMessageCallback(kDiscoverUsbDevicesEnabledCommand, 94 base::Bind(&InspectMessageHandler::HandleBooleanPrefChanged, 95 base::Unretained(this), 96 &prefs::kDevToolsDiscoverUsbDevicesEnabled[0])); 97 web_ui()->RegisterMessageCallback(kPortForwardingEnabledCommand, 98 base::Bind(&InspectMessageHandler::HandleBooleanPrefChanged, 99 base::Unretained(this), 100 &prefs::kDevToolsPortForwardingEnabled[0])); 101 web_ui()->RegisterMessageCallback(kPortForwardingConfigCommand, 102 base::Bind(&InspectMessageHandler::HandlePortForwardingConfigCommand, 103 base::Unretained(this))); 104 web_ui()->RegisterMessageCallback(kReloadCommand, 105 base::Bind(&InspectMessageHandler::HandleReloadCommand, 106 base::Unretained(this))); 107 web_ui()->RegisterMessageCallback(kOpenCommand, 108 base::Bind(&InspectMessageHandler::HandleOpenCommand, 109 base::Unretained(this))); 110 web_ui()->RegisterMessageCallback(kInspectBrowser, 111 base::Bind(&InspectMessageHandler::HandleInspectBrowserCommand, 112 base::Unretained(this))); 113 } 114 115 void InspectMessageHandler::HandleInitUICommand(const base::ListValue*) { 116 inspect_ui_->InitUI(); 117 } 118 119 static bool ParseStringArgs(const base::ListValue* args, 120 std::string* arg0, 121 std::string* arg1, 122 std::string* arg2 = 0) { 123 int arg_size = args->GetSize(); 124 return (!arg0 || (arg_size > 0 && args->GetString(0, arg0))) && 125 (!arg1 || (arg_size > 1 && args->GetString(1, arg1))) && 126 (!arg2 || (arg_size > 2 && args->GetString(2, arg2))); 127 } 128 129 void InspectMessageHandler::HandleInspectCommand(const base::ListValue* args) { 130 std::string source; 131 std::string id; 132 if (ParseStringArgs(args, &source, &id)) 133 inspect_ui_->Inspect(source, id); 134 } 135 136 void InspectMessageHandler::HandleActivateCommand(const base::ListValue* args) { 137 std::string source; 138 std::string id; 139 if (ParseStringArgs(args, &source, &id)) 140 inspect_ui_->Activate(source, id); 141 } 142 143 void InspectMessageHandler::HandleCloseCommand(const base::ListValue* args) { 144 std::string source; 145 std::string id; 146 if (ParseStringArgs(args, &source, &id)) 147 inspect_ui_->Close(source, id); 148 } 149 150 void InspectMessageHandler::HandleReloadCommand(const base::ListValue* args) { 151 std::string source; 152 std::string id; 153 if (ParseStringArgs(args, &source, &id)) 154 inspect_ui_->Reload(source, id); 155 } 156 157 void InspectMessageHandler::HandleOpenCommand(const base::ListValue* args) { 158 std::string source_id; 159 std::string browser_id; 160 std::string url; 161 if (ParseStringArgs(args, &source_id, &browser_id, &url)) 162 inspect_ui_->Open(source_id, browser_id, url); 163 } 164 165 void InspectMessageHandler::HandleInspectBrowserCommand( 166 const base::ListValue* args) { 167 std::string source_id; 168 std::string browser_id; 169 std::string front_end; 170 if (ParseStringArgs(args, &source_id, &browser_id, &front_end)) { 171 inspect_ui_->InspectBrowserWithCustomFrontend( 172 source_id, browser_id, GURL(front_end)); 173 } 174 } 175 176 void InspectMessageHandler::HandleBooleanPrefChanged( 177 const char* pref_name, 178 const base::ListValue* args) { 179 Profile* profile = Profile::FromWebUI(web_ui()); 180 if (!profile) 181 return; 182 183 bool enabled; 184 if (args->GetSize() == 1 && args->GetBoolean(0, &enabled)) 185 profile->GetPrefs()->SetBoolean(pref_name, enabled); 186 } 187 188 void InspectMessageHandler::HandlePortForwardingConfigCommand( 189 const base::ListValue* args) { 190 Profile* profile = Profile::FromWebUI(web_ui()); 191 if (!profile) 192 return; 193 194 const base::DictionaryValue* dict_src; 195 if (args->GetSize() == 1 && args->GetDictionary(0, &dict_src)) 196 profile->GetPrefs()->Set(prefs::kDevToolsPortForwardingConfig, *dict_src); 197 } 198 199 } // namespace 200 201 InspectUI::InspectUI(content::WebUI* web_ui) 202 : WebUIController(web_ui) { 203 web_ui->AddMessageHandler(new InspectMessageHandler(this)); 204 Profile* profile = Profile::FromWebUI(web_ui); 205 content::WebUIDataSource::Add(profile, CreateInspectUIHTMLSource()); 206 207 // Set up the chrome://theme/ source. 208 ThemeSource* theme = new ThemeSource(profile); 209 content::URLDataSource::Add(profile, theme); 210 } 211 212 InspectUI::~InspectUI() { 213 StopListeningNotifications(); 214 } 215 216 void InspectUI::InitUI() { 217 SetPortForwardingDefaults(); 218 StartListeningNotifications(); 219 UpdateDiscoverUsbDevicesEnabled(); 220 UpdatePortForwardingEnabled(); 221 UpdatePortForwardingConfig(); 222 } 223 224 void InspectUI::Inspect(const std::string& source_id, 225 const std::string& target_id) { 226 DevToolsTargetImpl* target = FindTarget(source_id, target_id); 227 if (target) 228 target->Inspect(Profile::FromWebUI(web_ui())); 229 } 230 231 void InspectUI::Activate(const std::string& source_id, 232 const std::string& target_id) { 233 DevToolsTargetImpl* target = FindTarget(source_id, target_id); 234 if (target) 235 target->Activate(); 236 } 237 238 void InspectUI::Close(const std::string& source_id, 239 const std::string& target_id) { 240 DevToolsTargetImpl* target = FindTarget(source_id, target_id); 241 if (target) 242 target->Close(); 243 } 244 245 void InspectUI::Reload(const std::string& source_id, 246 const std::string& target_id) { 247 DevToolsTargetImpl* target = FindTarget(source_id, target_id); 248 if (target) 249 target->Reload(); 250 } 251 252 static void NoOp(DevToolsTargetImpl*) {} 253 254 void InspectUI::Open(const std::string& source_id, 255 const std::string& browser_id, 256 const std::string& url) { 257 DevToolsTargetsUIHandler* handler = FindTargetHandler(source_id); 258 if (handler) 259 handler->Open(browser_id, url, base::Bind(&NoOp)); 260 } 261 262 void InspectUI::InspectBrowserWithCustomFrontend( 263 const std::string& source_id, 264 const std::string& browser_id, 265 const GURL& frontend_url) { 266 if (!frontend_url.SchemeIs(content::kChromeUIScheme) && 267 !frontend_url.SchemeIs(content::kChromeDevToolsScheme) && 268 frontend_url.host() != kLocalHost) { 269 return; 270 } 271 272 DevToolsTargetsUIHandler* handler = FindTargetHandler(source_id); 273 if (!handler) 274 return; 275 276 // Fetch agent host from remote browser. 277 scoped_refptr<content::DevToolsAgentHost> agent_host = 278 handler->GetBrowserAgentHost(browser_id); 279 if (agent_host->IsAttached()) 280 return; 281 282 // Create web contents for the front-end. 283 WebContents* inspect_ui = web_ui()->GetWebContents(); 284 WebContents* front_end = inspect_ui->GetDelegate()->OpenURLFromTab( 285 inspect_ui, 286 content::OpenURLParams(GURL(url::kAboutBlankURL), 287 content::Referrer(), 288 NEW_FOREGROUND_TAB, 289 content::PAGE_TRANSITION_AUTO_TOPLEVEL, 290 false)); 291 292 // Install devtools bindings. 293 DevToolsUIBindings* bindings = new DevToolsUIBindings(front_end, 294 frontend_url); 295 296 // Engage remote debugging between front-end and agent host. 297 content::DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor( 298 agent_host, bindings->frontend_host()); 299 } 300 301 void InspectUI::InspectDevices(Browser* browser) { 302 content::RecordAction(base::UserMetricsAction("InspectDevices")); 303 chrome::NavigateParams params(chrome::GetSingletonTabNavigateParams( 304 browser, GURL(chrome::kChromeUIInspectURL))); 305 params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE; 306 ShowSingletonTabOverwritingNTP(browser, params); 307 } 308 309 void InspectUI::Observe(int type, 310 const content::NotificationSource& source, 311 const content::NotificationDetails& details) { 312 if (source == content::Source<WebContents>(web_ui()->GetWebContents())) 313 StopListeningNotifications(); 314 } 315 316 void InspectUI::StartListeningNotifications() { 317 if (!target_handlers_.empty()) // Possible when reloading the page. 318 StopListeningNotifications(); 319 320 Profile* profile = Profile::FromWebUI(web_ui()); 321 322 DevToolsTargetsUIHandler::Callback callback = 323 base::Bind(&InspectUI::PopulateTargets, base::Unretained(this)); 324 325 AddTargetUIHandler( 326 DevToolsTargetsUIHandler::CreateForRenderers(callback)); 327 AddTargetUIHandler( 328 DevToolsTargetsUIHandler::CreateForWorkers(callback)); 329 if (profile->IsOffTheRecord()) { 330 ShowIncognitoWarning(); 331 } else { 332 AddTargetUIHandler( 333 DevToolsTargetsUIHandler::CreateForAdb(callback, profile)); 334 } 335 336 port_status_serializer_.reset( 337 new PortForwardingStatusSerializer( 338 base::Bind(&InspectUI::PopulatePortStatus, base::Unretained(this)), 339 profile)); 340 341 notification_registrar_.Add(this, 342 content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED, 343 content::NotificationService::AllSources()); 344 345 pref_change_registrar_.Init(profile->GetPrefs()); 346 pref_change_registrar_.Add(prefs::kDevToolsDiscoverUsbDevicesEnabled, 347 base::Bind(&InspectUI::UpdateDiscoverUsbDevicesEnabled, 348 base::Unretained(this))); 349 pref_change_registrar_.Add(prefs::kDevToolsPortForwardingEnabled, 350 base::Bind(&InspectUI::UpdatePortForwardingEnabled, 351 base::Unretained(this))); 352 pref_change_registrar_.Add(prefs::kDevToolsPortForwardingConfig, 353 base::Bind(&InspectUI::UpdatePortForwardingConfig, 354 base::Unretained(this))); 355 } 356 357 void InspectUI::StopListeningNotifications() { 358 if (target_handlers_.empty()) 359 return; 360 361 STLDeleteValues(&target_handlers_); 362 363 port_status_serializer_.reset(); 364 365 notification_registrar_.RemoveAll(); 366 pref_change_registrar_.RemoveAll(); 367 } 368 369 content::WebUIDataSource* InspectUI::CreateInspectUIHTMLSource() { 370 content::WebUIDataSource* source = 371 content::WebUIDataSource::Create(chrome::kChromeUIInspectHost); 372 source->AddResourcePath("inspect.css", IDR_INSPECT_CSS); 373 source->AddResourcePath("inspect.js", IDR_INSPECT_JS); 374 source->SetDefaultResource(IDR_INSPECT_HTML); 375 source->OverrideContentSecurityPolicyFrameSrc( 376 "frame-src chrome://serviceworker-internals;"); 377 serviceworker_webui_.reset(web_ui()->GetWebContents()->CreateWebUI( 378 GURL(content::kChromeUIServiceWorkerInternalsURL))); 379 serviceworker_webui_->OverrideJavaScriptFrame( 380 content::kChromeUIServiceWorkerInternalsHost); 381 return source; 382 } 383 384 void InspectUI::RenderViewCreated(content::RenderViewHost* render_view_host) { 385 serviceworker_webui_->GetController()->RenderViewCreated(render_view_host); 386 } 387 388 void InspectUI::RenderViewReused(content::RenderViewHost* render_view_host) { 389 serviceworker_webui_->GetController()->RenderViewReused(render_view_host); 390 } 391 392 bool InspectUI::OverrideHandleWebUIMessage(const GURL& source_url, 393 const std::string& message, 394 const base::ListValue& args) { 395 if (source_url.SchemeIs(content::kChromeUIScheme) && 396 source_url.host() == content::kChromeUIServiceWorkerInternalsHost) { 397 serviceworker_webui_->ProcessWebUIMessage(source_url, message, args); 398 return true; 399 } 400 return false; 401 } 402 403 void InspectUI::UpdateDiscoverUsbDevicesEnabled() { 404 web_ui()->CallJavascriptFunction( 405 "updateDiscoverUsbDevicesEnabled", 406 *GetPrefValue(prefs::kDevToolsDiscoverUsbDevicesEnabled)); 407 } 408 409 void InspectUI::UpdatePortForwardingEnabled() { 410 web_ui()->CallJavascriptFunction( 411 "updatePortForwardingEnabled", 412 *GetPrefValue(prefs::kDevToolsPortForwardingEnabled)); 413 } 414 415 void InspectUI::UpdatePortForwardingConfig() { 416 web_ui()->CallJavascriptFunction( 417 "updatePortForwardingConfig", 418 *GetPrefValue(prefs::kDevToolsPortForwardingConfig)); 419 } 420 421 void InspectUI::SetPortForwardingDefaults() { 422 Profile* profile = Profile::FromWebUI(web_ui()); 423 PrefService* prefs = profile->GetPrefs(); 424 425 bool default_set; 426 if (!GetPrefValue(prefs::kDevToolsPortForwardingDefaultSet)-> 427 GetAsBoolean(&default_set) || default_set) { 428 return; 429 } 430 431 // This is the first chrome://inspect invocation on a fresh profile or after 432 // upgrade from a version that did not have kDevToolsPortForwardingDefaultSet. 433 prefs->SetBoolean(prefs::kDevToolsPortForwardingDefaultSet, true); 434 435 bool enabled; 436 const base::DictionaryValue* config; 437 if (!GetPrefValue(prefs::kDevToolsPortForwardingEnabled)-> 438 GetAsBoolean(&enabled) || 439 !GetPrefValue(prefs::kDevToolsPortForwardingConfig)-> 440 GetAsDictionary(&config)) { 441 return; 442 } 443 444 // Do nothing if user already took explicit action. 445 if (enabled || config->size() != 0) 446 return; 447 448 base::DictionaryValue default_config; 449 default_config.SetString( 450 kPortForwardingDefaultPort, kPortForwardingDefaultLocation); 451 prefs->Set(prefs::kDevToolsPortForwardingConfig, default_config); 452 } 453 454 const base::Value* InspectUI::GetPrefValue(const char* name) { 455 Profile* profile = Profile::FromWebUI(web_ui()); 456 return profile->GetPrefs()->FindPreference(name)->GetValue(); 457 } 458 459 void InspectUI::AddTargetUIHandler( 460 scoped_ptr<DevToolsTargetsUIHandler> handler) { 461 DevToolsTargetsUIHandler* handler_ptr = handler.release(); 462 target_handlers_[handler_ptr->source_id()] = handler_ptr; 463 } 464 465 DevToolsTargetsUIHandler* InspectUI::FindTargetHandler( 466 const std::string& source_id) { 467 TargetHandlerMap::iterator it = target_handlers_.find(source_id); 468 return it != target_handlers_.end() ? it->second : NULL; 469 } 470 471 DevToolsTargetImpl* InspectUI::FindTarget( 472 const std::string& source_id, const std::string& target_id) { 473 TargetHandlerMap::iterator it = target_handlers_.find(source_id); 474 return it != target_handlers_.end() ? 475 it->second->GetTarget(target_id) : NULL; 476 } 477 478 void InspectUI::PopulateTargets(const std::string& source, 479 scoped_ptr<base::ListValue> targets) { 480 scoped_ptr<base::Value> source_value(base::Value::CreateStringValue(source)); 481 web_ui()->CallJavascriptFunction( 482 "populateTargets", 483 *source_value.get(), 484 *targets.get()); 485 } 486 487 void InspectUI::PopulatePortStatus(const base::Value& status) { 488 web_ui()->CallJavascriptFunction("populatePortStatus", status); 489 } 490 491 void InspectUI::ShowIncognitoWarning() { 492 web_ui()->CallJavascriptFunction("showIncognitoWarning"); 493 } 494