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