| OLD | NEW |
|---|
| (Empty) |
| 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 "base/bind.h" | |
| 6 #include "base/cancelable_callback.h" | |
| 7 #include "base/command_line.h" | |
| 8 #include "base/compiler_specific.h" | |
| 9 #include "base/memory/ref_counted.h" | |
| 10 #include "base/path_service.h" | |
| 11 #include "base/stringprintf.h" | |
| 12 #include "base/test/test_timeouts.h" | |
| 13 #include "base/utf_string_conversions.h" | |
| 14 #include "chrome/browser/debugger/devtools_window.h" | |
| 15 #include "chrome/browser/extensions/extension_service.h" | |
| 16 #include "chrome/browser/extensions/extension_system.h" | |
| 17 #include "chrome/browser/extensions/unpacked_installer.h" | |
| 18 #include "chrome/browser/profiles/profile.h" | |
| 19 #include "chrome/browser/ui/browser.h" | |
| 20 #include "chrome/browser/ui/browser_commands.h" | |
| 21 #include "chrome/browser/ui/browser_tabstrip.h" | |
| 22 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 23 #include "chrome/common/chrome_notification_types.h" | |
| 24 #include "chrome/common/chrome_paths.h" | |
| 25 #include "chrome/common/chrome_switches.h" | |
| 26 #include "chrome/test/base/in_process_browser_test.h" | |
| 27 #include "chrome/test/base/ui_test_utils.h" | |
| 28 #include "content/public/browser/child_process_data.h" | |
| 29 #include "content/public/browser/content_browser_client.h" | |
| 30 #include "content/public/browser/devtools_agent_host_registry.h" | |
| 31 #include "content/public/browser/devtools_client_host.h" | |
| 32 #include "content/public/browser/devtools_manager.h" | |
| 33 #include "content/public/browser/notification_registrar.h" | |
| 34 #include "content/public/browser/notification_service.h" | |
| 35 #include "content/public/browser/render_view_host.h" | |
| 36 #include "content/public/browser/web_contents.h" | |
| 37 #include "content/public/browser/worker_service.h" | |
| 38 #include "content/public/browser/worker_service_observer.h" | |
| 39 #include "content/public/test/browser_test_utils.h" | |
| 40 #include "net/test/test_server.h" | |
| 41 | |
| 42 using content::BrowserThread; | |
| 43 using content::DevToolsManager; | |
| 44 using content::DevToolsAgentHost; | |
| 45 using content::DevToolsAgentHostRegistry; | |
| 46 using content::NavigationController; | |
| 47 using content::RenderViewHost; | |
| 48 using content::WebContents; | |
| 49 using content::WorkerService; | |
| 50 using content::WorkerServiceObserver; | |
| 51 | |
| 52 namespace { | |
| 53 | |
| 54 // Used to block until a dev tools client window's browser is closed. | |
| 55 class BrowserClosedObserver : public content::NotificationObserver { | |
| 56 public: | |
| 57 explicit BrowserClosedObserver(Browser* browser) { | |
| 58 registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED, | |
| 59 content::Source<Browser>(browser)); | |
| 60 content::RunMessageLoop(); | |
| 61 } | |
| 62 | |
| 63 virtual void Observe(int type, | |
| 64 const content::NotificationSource& source, | |
| 65 const content::NotificationDetails& details) { | |
| 66 MessageLoopForUI::current()->Quit(); | |
| 67 } | |
| 68 | |
| 69 private: | |
| 70 content::NotificationRegistrar registrar_; | |
| 71 DISALLOW_COPY_AND_ASSIGN(BrowserClosedObserver); | |
| 72 }; | |
| 73 | |
| 74 // The delay waited in some cases where we don't have a notifications for an | |
| 75 // action we take. | |
| 76 const int kActionDelayMs = 500; | |
| 77 | |
| 78 const char kDebuggerTestPage[] = "files/devtools/debugger_test_page.html"; | |
| 79 const char kPauseWhenLoadingDevTools[] = | |
| 80 "files/devtools/pause_when_loading_devtools.html"; | |
| 81 const char kPauseWhenScriptIsRunning[] = | |
| 82 "files/devtools/pause_when_script_is_running.html"; | |
| 83 const char kPageWithContentScript[] = | |
| 84 "files/devtools/page_with_content_script.html"; | |
| 85 const char kNavigateBackTestPage[] = | |
| 86 "files/devtools/navigate_back.html"; | |
| 87 const char kChunkedTestPage[] = "chunked"; | |
| 88 const char kSlowTestPage[] = | |
| 89 "chunked?waitBeforeHeaders=100&waitBetweenChunks=100&chunksNumber=2"; | |
| 90 const char kSharedWorkerTestPage[] = | |
| 91 "files/workers/workers_ui_shared_worker.html"; | |
| 92 const char kReloadSharedWorkerTestPage[] = | |
| 93 "files/workers/debug_shared_worker_initialization.html"; | |
| 94 | |
| 95 void RunTestFunction(DevToolsWindow* window, const char* test_name) { | |
| 96 std::string result; | |
| 97 | |
| 98 // At first check that JavaScript part of the front-end is loaded by | |
| 99 // checking that global variable uiTests exists(it's created after all js | |
| 100 // files have been loaded) and has runTest method. | |
| 101 ASSERT_TRUE( | |
| 102 content::ExecuteJavaScriptAndExtractString( | |
| 103 window->GetRenderViewHost(), | |
| 104 L"", | |
| 105 L"window.domAutomationController.send(" | |
| 106 L"'' + (window.uiTests && (typeof uiTests.runTest)));", | |
| 107 &result)); | |
| 108 | |
| 109 if (result == "function") { | |
| 110 ASSERT_TRUE( | |
| 111 content::ExecuteJavaScriptAndExtractString( | |
| 112 window->GetRenderViewHost(), | |
| 113 L"", | |
| 114 UTF8ToWide(base::StringPrintf("uiTests.runTest('%s')", | |
| 115 test_name)), | |
| 116 &result)); | |
| 117 EXPECT_EQ("[OK]", result); | |
| 118 } else { | |
| 119 FAIL() << "DevTools front-end is broken."; | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 class DevToolsSanityTest : public InProcessBrowserTest { | |
| 124 public: | |
| 125 DevToolsSanityTest() | |
| 126 : window_(NULL), | |
| 127 inspected_rvh_(NULL) {} | |
| 128 | |
| 129 protected: | |
| 130 void RunTest(const std::string& test_name, const std::string& test_page) { | |
| 131 OpenDevToolsWindow(test_page); | |
| 132 RunTestFunction(window_, test_name.c_str()); | |
| 133 CloseDevToolsWindow(); | |
| 134 } | |
| 135 | |
| 136 void OpenDevToolsWindow(const std::string& test_page) { | |
| 137 ASSERT_TRUE(test_server()->Start()); | |
| 138 GURL url = test_server()->GetURL(test_page); | |
| 139 ui_test_utils::NavigateToURL(browser(), url); | |
| 140 | |
| 141 content::WindowedNotificationObserver observer( | |
| 142 content::NOTIFICATION_LOAD_STOP, | |
| 143 content::NotificationService::AllSources()); | |
| 144 inspected_rvh_ = GetInspectedTab()->GetRenderViewHost(); | |
| 145 window_ = DevToolsWindow::OpenDevToolsWindow(inspected_rvh_); | |
| 146 observer.Wait(); | |
| 147 } | |
| 148 | |
| 149 WebContents* GetInspectedTab() { | |
| 150 return chrome::GetWebContentsAt(browser(), 0); | |
| 151 } | |
| 152 | |
| 153 void CloseDevToolsWindow() { | |
| 154 DevToolsManager* devtools_manager = DevToolsManager::GetInstance(); | |
| 155 // UnregisterDevToolsClientHostFor may destroy window_ so store the browser | |
| 156 // first. | |
| 157 Browser* browser = window_->browser(); | |
| 158 DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost( | |
| 159 inspected_rvh_); | |
| 160 devtools_manager->UnregisterDevToolsClientHostFor(agent); | |
| 161 | |
| 162 // Wait only when DevToolsWindow has a browser. For docked DevTools, this | |
| 163 // is NULL and we skip the wait. | |
| 164 if (browser) | |
| 165 BrowserClosedObserver close_observer(browser); | |
| 166 } | |
| 167 | |
| 168 DevToolsWindow* window_; | |
| 169 RenderViewHost* inspected_rvh_; | |
| 170 }; | |
| 171 | |
| 172 void TimeoutCallback(const std::string& timeout_message) { | |
| 173 FAIL() << timeout_message; | |
| 174 MessageLoop::current()->Quit(); | |
| 175 } | |
| 176 | |
| 177 // Base class for DevTools tests that test devtools functionality for | |
| 178 // extensions and content scripts. | |
| 179 class DevToolsExtensionTest : public DevToolsSanityTest, | |
| 180 public content::NotificationObserver { | |
| 181 public: | |
| 182 DevToolsExtensionTest() : DevToolsSanityTest() { | |
| 183 PathService::Get(chrome::DIR_TEST_DATA, &test_extensions_dir_); | |
| 184 test_extensions_dir_ = test_extensions_dir_.AppendASCII("devtools"); | |
| 185 test_extensions_dir_ = test_extensions_dir_.AppendASCII("extensions"); | |
| 186 } | |
| 187 | |
| 188 protected: | |
| 189 // Load an extension from test\data\devtools\extensions\<extension_name> | |
| 190 void LoadExtension(const char* extension_name) { | |
| 191 FilePath path = test_extensions_dir_.AppendASCII(extension_name); | |
| 192 ASSERT_TRUE(LoadExtensionFromPath(path)) << "Failed to load extension."; | |
| 193 } | |
| 194 | |
| 195 private: | |
| 196 bool LoadExtensionFromPath(const FilePath& path) { | |
| 197 ExtensionService* service = extensions::ExtensionSystem::Get( | |
| 198 browser()->profile())->extension_service(); | |
| 199 size_t num_before = service->extensions()->size(); | |
| 200 { | |
| 201 content::NotificationRegistrar registrar; | |
| 202 registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED, | |
| 203 content::NotificationService::AllSources()); | |
| 204 base::CancelableClosure timeout( | |
| 205 base::Bind(&TimeoutCallback, "Extension load timed out.")); | |
| 206 MessageLoop::current()->PostDelayedTask( | |
| 207 FROM_HERE, timeout.callback(), base::TimeDelta::FromSeconds(4)); | |
| 208 extensions::UnpackedInstaller::Create(service)->Load(path); | |
| 209 content::RunMessageLoop(); | |
| 210 timeout.Cancel(); | |
| 211 } | |
| 212 size_t num_after = service->extensions()->size(); | |
| 213 if (num_after != (num_before + 1)) | |
| 214 return false; | |
| 215 | |
| 216 return WaitForExtensionViewsToLoad(); | |
| 217 } | |
| 218 | |
| 219 bool WaitForExtensionViewsToLoad() { | |
| 220 // Wait for all the extension render views that exist to finish loading. | |
| 221 // NOTE: This assumes that the extension views list is not changing while | |
| 222 // this method is running. | |
| 223 | |
| 224 content::NotificationRegistrar registrar; | |
| 225 registrar.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING, | |
| 226 content::NotificationService::AllSources()); | |
| 227 base::CancelableClosure timeout( | |
| 228 base::Bind(&TimeoutCallback, "Extension host load timed out.")); | |
| 229 MessageLoop::current()->PostDelayedTask( | |
| 230 FROM_HERE, timeout.callback(), base::TimeDelta::FromSeconds(4)); | |
| 231 | |
| 232 ExtensionProcessManager* manager = | |
| 233 extensions::ExtensionSystem::Get(browser()->profile())-> | |
| 234 process_manager(); | |
| 235 ExtensionProcessManager::ViewSet all_views = manager->GetAllViews(); | |
| 236 for (ExtensionProcessManager::ViewSet::const_iterator iter = | |
| 237 all_views.begin(); | |
| 238 iter != all_views.end();) { | |
| 239 if (!(*iter)->IsLoading()) | |
| 240 ++iter; | |
| 241 else | |
| 242 content::RunMessageLoop(); | |
| 243 } | |
| 244 | |
| 245 timeout.Cancel(); | |
| 246 return true; | |
| 247 } | |
| 248 | |
| 249 void Observe(int type, | |
| 250 const content::NotificationSource& source, | |
| 251 const content::NotificationDetails& details) { | |
| 252 switch (type) { | |
| 253 case chrome::NOTIFICATION_EXTENSION_LOADED: | |
| 254 case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING: | |
| 255 MessageLoopForUI::current()->Quit(); | |
| 256 break; | |
| 257 default: | |
| 258 NOTREACHED(); | |
| 259 break; | |
| 260 } | |
| 261 } | |
| 262 | |
| 263 FilePath test_extensions_dir_; | |
| 264 }; | |
| 265 | |
| 266 class DevToolsExperimentalExtensionTest : public DevToolsExtensionTest { | |
| 267 public: | |
| 268 void SetUpCommandLine(CommandLine* command_line) OVERRIDE { | |
| 269 command_line->AppendSwitch(switches::kEnableExperimentalExtensionApis); | |
| 270 } | |
| 271 }; | |
| 272 | |
| 273 class WorkerDevToolsSanityTest : public InProcessBrowserTest { | |
| 274 public: | |
| 275 WorkerDevToolsSanityTest() : window_(NULL) {} | |
| 276 | |
| 277 protected: | |
| 278 class WorkerData : public base::RefCountedThreadSafe<WorkerData> { | |
| 279 public: | |
| 280 WorkerData() : worker_process_id(0), worker_route_id(0) {} | |
| 281 int worker_process_id; | |
| 282 int worker_route_id; | |
| 283 | |
| 284 private: | |
| 285 friend class base::RefCountedThreadSafe<WorkerData>; | |
| 286 ~WorkerData() {} | |
| 287 }; | |
| 288 | |
| 289 class WorkerCreationObserver : public WorkerServiceObserver { | |
| 290 public: | |
| 291 explicit WorkerCreationObserver(WorkerData* worker_data) | |
| 292 : worker_data_(worker_data) { | |
| 293 } | |
| 294 | |
| 295 private: | |
| 296 virtual ~WorkerCreationObserver() {} | |
| 297 | |
| 298 virtual void WorkerCreated ( | |
| 299 const GURL& url, | |
| 300 const string16& name, | |
| 301 int process_id, | |
| 302 int route_id) OVERRIDE { | |
| 303 worker_data_->worker_process_id = process_id; | |
| 304 worker_data_->worker_route_id = route_id; | |
| 305 WorkerService::GetInstance()->RemoveObserver(this); | |
| 306 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 307 MessageLoop::QuitClosure()); | |
| 308 delete this; | |
| 309 } | |
| 310 scoped_refptr<WorkerData> worker_data_; | |
| 311 }; | |
| 312 | |
| 313 class WorkerTerminationObserver : public WorkerServiceObserver { | |
| 314 public: | |
| 315 explicit WorkerTerminationObserver(WorkerData* worker_data) | |
| 316 : worker_data_(worker_data) { | |
| 317 } | |
| 318 | |
| 319 private: | |
| 320 virtual ~WorkerTerminationObserver() {} | |
| 321 | |
| 322 virtual void WorkerDestroyed(int process_id, int route_id) OVERRIDE { | |
| 323 ASSERT_EQ(worker_data_->worker_process_id, process_id); | |
| 324 ASSERT_EQ(worker_data_->worker_route_id, route_id); | |
| 325 WorkerService::GetInstance()->RemoveObserver(this); | |
| 326 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 327 MessageLoop::QuitClosure()); | |
| 328 delete this; | |
| 329 } | |
| 330 scoped_refptr<WorkerData> worker_data_; | |
| 331 }; | |
| 332 | |
| 333 void RunTest(const char* test_name, const char* test_page) { | |
| 334 ASSERT_TRUE(test_server()->Start()); | |
| 335 GURL url = test_server()->GetURL(test_page); | |
| 336 ui_test_utils::NavigateToURL(browser(), url); | |
| 337 | |
| 338 scoped_refptr<WorkerData> worker_data = WaitForFirstSharedWorker(); | |
| 339 OpenDevToolsWindowForSharedWorker(worker_data.get()); | |
| 340 RunTestFunction(window_, test_name); | |
| 341 CloseDevToolsWindow(); | |
| 342 } | |
| 343 | |
| 344 static void TerminateWorkerOnIOThread(scoped_refptr<WorkerData> worker_data) { | |
| 345 if (WorkerService::GetInstance()->TerminateWorker( | |
| 346 worker_data->worker_process_id, worker_data->worker_route_id)) { | |
| 347 WorkerService::GetInstance()->AddObserver( | |
| 348 new WorkerTerminationObserver(worker_data)); | |
| 349 return; | |
| 350 } | |
| 351 FAIL() << "Failed to terminate worker.\n"; | |
| 352 } | |
| 353 | |
| 354 static void TerminateWorker(scoped_refptr<WorkerData> worker_data) { | |
| 355 BrowserThread::PostTask( | |
| 356 BrowserThread::IO, FROM_HERE, | |
| 357 base::Bind(&TerminateWorkerOnIOThread, worker_data)); | |
| 358 content::RunMessageLoop(); | |
| 359 } | |
| 360 | |
| 361 static void WaitForFirstSharedWorkerOnIOThread( | |
| 362 scoped_refptr<WorkerData> worker_data) { | |
| 363 std::vector<WorkerService::WorkerInfo> worker_info = | |
| 364 WorkerService::GetInstance()->GetWorkers(); | |
| 365 if (!worker_info.empty()) { | |
| 366 worker_data->worker_process_id = worker_info[0].process_id; | |
| 367 worker_data->worker_route_id = worker_info[0].route_id; | |
| 368 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 369 MessageLoop::QuitClosure()); | |
| 370 return; | |
| 371 } | |
| 372 | |
| 373 WorkerService::GetInstance()->AddObserver( | |
| 374 new WorkerCreationObserver(worker_data.get())); | |
| 375 } | |
| 376 | |
| 377 static scoped_refptr<WorkerData> WaitForFirstSharedWorker() { | |
| 378 scoped_refptr<WorkerData> worker_data(new WorkerData()); | |
| 379 BrowserThread::PostTask( | |
| 380 BrowserThread::IO, FROM_HERE, | |
| 381 base::Bind(&WaitForFirstSharedWorkerOnIOThread, worker_data)); | |
| 382 content::RunMessageLoop(); | |
| 383 return worker_data; | |
| 384 } | |
| 385 | |
| 386 void OpenDevToolsWindowForSharedWorker(WorkerData* worker_data) { | |
| 387 Profile* profile = browser()->profile(); | |
| 388 window_ = DevToolsWindow::CreateDevToolsWindowForWorker(profile); | |
| 389 window_->Show(DEVTOOLS_TOGGLE_ACTION_SHOW); | |
| 390 DevToolsAgentHost* agent_host = | |
| 391 DevToolsAgentHostRegistry::GetDevToolsAgentHostForWorker( | |
| 392 worker_data->worker_process_id, | |
| 393 worker_data->worker_route_id); | |
| 394 DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor( | |
| 395 agent_host, | |
| 396 window_->devtools_client_host()); | |
| 397 RenderViewHost* client_rvh = window_->GetRenderViewHost(); | |
| 398 WebContents* client_contents = WebContents::FromRenderViewHost(client_rvh); | |
| 399 if (client_contents->IsLoading()) { | |
| 400 content::WindowedNotificationObserver observer( | |
| 401 content::NOTIFICATION_LOAD_STOP, | |
| 402 content::Source<NavigationController>( | |
| 403 &client_contents->GetController())); | |
| 404 observer.Wait(); | |
| 405 } | |
| 406 } | |
| 407 | |
| 408 void CloseDevToolsWindow() { | |
| 409 Browser* browser = window_->browser(); | |
| 410 browser->tab_strip_model()->CloseAllTabs(); | |
| 411 BrowserClosedObserver close_observer(browser); | |
| 412 } | |
| 413 | |
| 414 DevToolsWindow* window_; | |
| 415 }; | |
| 416 | |
| 417 | |
| 418 // Tests scripts panel showing. | |
| 419 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestShowScriptsTab) { | |
| 420 RunTest("testShowScriptsTab", kDebuggerTestPage); | |
| 421 } | |
| 422 | |
| 423 // Tests that scripts tab is populated with inspected scripts even if it | |
| 424 // hadn't been shown by the moment inspected paged refreshed. | |
| 425 // @see http://crbug.com/26312 | |
| 426 IN_PROC_BROWSER_TEST_F( | |
| 427 DevToolsSanityTest, | |
| 428 TestScriptsTabIsPopulatedOnInspectedPageRefresh) { | |
| 429 // Clear inspector settings to ensure that Elements will be | |
| 430 // current panel when DevTools window is open. | |
| 431 content::GetContentClient()->browser()->ClearInspectorSettings( | |
| 432 GetInspectedTab()->GetRenderViewHost()); | |
| 433 RunTest("testScriptsTabIsPopulatedOnInspectedPageRefresh", | |
| 434 kDebuggerTestPage); | |
| 435 } | |
| 436 | |
| 437 // Tests that chrome.devtools extension is correctly exposed. | |
| 438 IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, | |
| 439 TestDevToolsExtensionAPI) { | |
| 440 LoadExtension("devtools_extension"); | |
| 441 RunTest("waitForTestResultsInConsole", ""); | |
| 442 } | |
| 443 | |
| 444 // Tests that chrome.devtools extension can communicate with background page | |
| 445 // using extension messaging. | |
| 446 IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, | |
| 447 TestDevToolsExtensionMessaging) { | |
| 448 LoadExtension("devtools_messaging"); | |
| 449 RunTest("waitForTestResultsInConsole", ""); | |
| 450 } | |
| 451 | |
| 452 // Tests that chrome.experimental.devtools extension is correctly exposed | |
| 453 // when the extension has experimental permission. | |
| 454 IN_PROC_BROWSER_TEST_F(DevToolsExperimentalExtensionTest, | |
| 455 TestDevToolsExperimentalExtensionAPI) { | |
| 456 LoadExtension("devtools_experimental"); | |
| 457 RunTest("waitForTestResultsInConsole", ""); | |
| 458 } | |
| 459 | |
| 460 // Tests that a content script is in the scripts list. | |
| 461 // http://crbug.com/114104 | |
| 462 IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, | |
| 463 TestContentScriptIsPresent) { | |
| 464 LoadExtension("simple_content_script"); | |
| 465 RunTest("testContentScriptIsPresent", kPageWithContentScript); | |
| 466 } | |
| 467 | |
| 468 // Tests that scripts are not duplicated after Scripts Panel switch. | |
| 469 // Disabled - see http://crbug.com/124300 | |
| 470 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, | |
| 471 TestNoScriptDuplicatesOnPanelSwitch) { | |
| 472 RunTest("testNoScriptDuplicatesOnPanelSwitch", kDebuggerTestPage); | |
| 473 } | |
| 474 | |
| 475 // Tests that debugger works correctly if pause event occurs when DevTools | |
| 476 // frontend is being loaded. | |
| 477 // http://crbug.com/106114 | |
| 478 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, | |
| 479 TestPauseWhenLoadingDevTools) { | |
| 480 RunTest("testPauseWhenLoadingDevTools", kPauseWhenLoadingDevTools); | |
| 481 } | |
| 482 | |
| 483 // Tests that pressing 'Pause' will pause script execution if the script | |
| 484 // is already running. | |
| 485 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPauseWhenScriptIsRunning) { | |
| 486 RunTest("testPauseWhenScriptIsRunning", kPauseWhenScriptIsRunning); | |
| 487 } | |
| 488 | |
| 489 // Tests network timing. | |
| 490 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkTiming) { | |
| 491 RunTest("testNetworkTiming", kSlowTestPage); | |
| 492 } | |
| 493 | |
| 494 // Tests network size. | |
| 495 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkSize) { | |
| 496 RunTest("testNetworkSize", kChunkedTestPage); | |
| 497 } | |
| 498 | |
| 499 // Tests raw headers text. | |
| 500 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkSyncSize) { | |
| 501 RunTest("testNetworkSyncSize", kChunkedTestPage); | |
| 502 } | |
| 503 | |
| 504 // Tests raw headers text. | |
| 505 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestNetworkRawHeadersText) { | |
| 506 RunTest("testNetworkRawHeadersText", kChunkedTestPage); | |
| 507 } | |
| 508 | |
| 509 // Tests that console messages are not duplicated on navigation back. | |
| 510 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestConsoleOnNavigateBack) { | |
| 511 RunTest("testConsoleOnNavigateBack", kNavigateBackTestPage); | |
| 512 } | |
| 513 | |
| 514 // Tests that inspector will reattach to inspected page when it is reloaded | |
| 515 // after a crash. See http://crbug.com/101952 | |
| 516 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestReattachAfterCrash) { | |
| 517 OpenDevToolsWindow(kDebuggerTestPage); | |
| 518 | |
| 519 content::CrashTab(GetInspectedTab()); | |
| 520 content::WindowedNotificationObserver observer( | |
| 521 content::NOTIFICATION_LOAD_STOP, | |
| 522 content::Source<NavigationController>( | |
| 523 &chrome::GetActiveWebContents(browser())->GetController())); | |
| 524 chrome::Reload(browser(), CURRENT_TAB); | |
| 525 observer.Wait(); | |
| 526 | |
| 527 RunTestFunction(window_, "testReattachAfterCrash"); | |
| 528 CloseDevToolsWindow(); | |
| 529 } | |
| 530 | |
| 531 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPageWithNoJavaScript) { | |
| 532 OpenDevToolsWindow("about:blank"); | |
| 533 std::string result; | |
| 534 ASSERT_TRUE( | |
| 535 content::ExecuteJavaScriptAndExtractString( | |
| 536 window_->GetRenderViewHost(), | |
| 537 L"", | |
| 538 L"window.domAutomationController.send(" | |
| 539 L"'' + (window.uiTests && (typeof uiTests.runTest)));", | |
| 540 &result)); | |
| 541 ASSERT_EQ("function", result) << "DevTools front-end is broken."; | |
| 542 CloseDevToolsWindow(); | |
| 543 } | |
| 544 | |
| 545 #if defined(OS_MACOSX) | |
| 546 #define MAYBE_InspectSharedWorker DISABLED_InspectSharedWorker | |
| 547 #else | |
| 548 #define MAYBE_InspectSharedWorker InspectSharedWorker | |
| 549 #endif | |
| 550 // Flakily fails with 25s timeout: http://crbug.com/89845 | |
| 551 IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, MAYBE_InspectSharedWorker) { | |
| 552 RunTest("testSharedWorker", kSharedWorkerTestPage); | |
| 553 } | |
| 554 | |
| 555 // http://crbug.com/100538 | |
| 556 #if defined(OS_MACOSX) || defined(OS_WIN) | |
| 557 #define MAYBE_PauseInSharedWorkerInitialization DISABLED_PauseInSharedWorkerInit
ialization | |
| 558 #else | |
| 559 #define MAYBE_PauseInSharedWorkerInitialization PauseInSharedWorkerInitializatio
n | |
| 560 #endif | |
| 561 | |
| 562 // http://crbug.com/106114 is masking | |
| 563 // MAYBE_PauseInSharedWorkerInitialization into | |
| 564 // DISABLED_PauseInSharedWorkerInitialization | |
| 565 IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, | |
| 566 MAYBE_PauseInSharedWorkerInitialization) { | |
| 567 ASSERT_TRUE(test_server()->Start()); | |
| 568 GURL url = test_server()->GetURL(kReloadSharedWorkerTestPage); | |
| 569 ui_test_utils::NavigateToURL(browser(), url); | |
| 570 | |
| 571 scoped_refptr<WorkerData> worker_data = WaitForFirstSharedWorker(); | |
| 572 OpenDevToolsWindowForSharedWorker(worker_data.get()); | |
| 573 | |
| 574 TerminateWorker(worker_data); | |
| 575 | |
| 576 // Reload page to restart the worker. | |
| 577 ui_test_utils::NavigateToURL(browser(), url); | |
| 578 | |
| 579 // Wait until worker script is paused on the debugger statement. | |
| 580 RunTestFunction(window_, "testPauseInSharedWorkerInitialization"); | |
| 581 CloseDevToolsWindow(); | |
| 582 } | |
| 583 | |
| 584 // Tests DevToolsAgentHost::AddMessageToConsole. | |
| 585 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestAddMessageToConsole) { | |
| 586 OpenDevToolsWindow("about:blank"); | |
| 587 DevToolsManager* devtools_manager = DevToolsManager::GetInstance(); | |
| 588 DevToolsAgentHost* agent_host = | |
| 589 DevToolsAgentHostRegistry::GetDevToolsAgentHost(inspected_rvh_); | |
| 590 devtools_manager->AddMessageToConsole(agent_host, | |
| 591 content::CONSOLE_MESSAGE_LEVEL_LOG, | |
| 592 "log"); | |
| 593 devtools_manager->AddMessageToConsole(agent_host, | |
| 594 content::CONSOLE_MESSAGE_LEVEL_ERROR, | |
| 595 "error"); | |
| 596 RunTestFunction(window_, "checkLogAndErrorMessages"); | |
| 597 CloseDevToolsWindow(); | |
| 598 } | |
| 599 | |
| 600 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11630004:
DevTools: rename debugger/ to devtools/, move DevTools files into content/renderer/devtools. (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master