#include "base/test/test_timeouts.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/devtools/browser_list_tabcontents_provider.h"
-#include "chrome/browser/devtools/devtools_window.h"
+#include "chrome/browser/devtools/devtools_window_testing.h"
#include "chrome/browser/extensions/extension_apitest.h"
#include "chrome/browser/extensions/extension_browsertest.h"
#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/extension_system.h"
#include "chrome/browser/extensions/unpacked_installer.h"
#include "chrome/browser/lifetime/application_lifetime.h"
#include "chrome/browser/profiles/profile.h"
#include "content/public/browser/child_process_data.h"
#include "content/public/browser/content_browser_client.h"
#include "content/public/browser/devtools_agent_host.h"
-#include "content/public/browser/devtools_client_host.h"
#include "content/public/browser/devtools_http_handler.h"
-#include "content/public/browser/devtools_manager.h"
#include "content/public/browser/notification_registrar.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/worker_service_observer.h"
#include "content/public/common/content_switches.h"
#include "content/public/test/browser_test_utils.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/notification_types.h"
#include "extensions/common/switches.h"
#include "net/socket/tcp_listen_socket.h"
#include "net/test/spawned_test_server/spawned_test_server.h"
using content::BrowserThread;
-using content::DevToolsManager;
using content::DevToolsAgentHost;
using content::NavigationController;
using content::RenderViewHost;
void RunTestFunction(DevToolsWindow* window, const char* test_name) {
std::string result;
+ RenderViewHost* rvh = DevToolsWindowTesting::Get(window)->
+ main_web_contents()->GetRenderViewHost();
// At first check that JavaScript part of the front-end is loaded by
// checking that global variable uiTests exists(it's created after all js
// files have been loaded) and has runTest method.
ASSERT_TRUE(
content::ExecuteScriptAndExtractString(
- window->GetRenderViewHost(),
+ rvh,
"window.domAutomationController.send("
" '' + (window.uiTests && (typeof uiTests.runTest)));",
&result));
- if (result == "function") {
- ASSERT_TRUE(
- content::ExecuteScriptAndExtractString(
- window->GetRenderViewHost(),
- base::StringPrintf("uiTests.runTest('%s')", test_name),
- &result));
- EXPECT_EQ("[OK]", result);
- } else {
- FAIL() << "DevTools front-end is broken.";
- }
+ ASSERT_EQ("function", result) << "DevTools front-end is broken.";
+ ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+ rvh,
+ base::StringPrintf("uiTests.runTest('%s')", test_name),
+ &result));
+ EXPECT_EQ("[OK]", result);
}
} // namespace
class DevToolsSanityTest : public InProcessBrowserTest {
public:
- DevToolsSanityTest()
- : window_(NULL),
- inspected_rvh_(NULL) {}
+ DevToolsSanityTest() : window_(NULL) {}
protected:
void RunTest(const std::string& test_name, const std::string& test_page) {
}
void LoadTestPage(const std::string& test_page) {
- content::WindowedNotificationObserver load_observer(
- content::NOTIFICATION_LOAD_STOP,
- content::NotificationService::AllSources());
GURL url = test_server()->GetURL(test_page);
ui_test_utils::NavigateToURL(browser(), url);
- load_observer.Wait();
}
void OpenDevToolsWindow(const std::string& test_page, bool is_docked) {
ASSERT_TRUE(test_server()->Start());
LoadTestPage(test_page);
- content::WindowedNotificationObserver observer(
- content::NOTIFICATION_LOAD_STOP,
- content::NotificationService::AllSources());
- inspected_rvh_ = GetInspectedTab()->GetRenderViewHost();
- window_ =
- DevToolsWindow::OpenDevToolsWindowForTest(inspected_rvh_, is_docked);
- observer.Wait();
+ window_ = DevToolsWindowTesting::OpenDevToolsWindowSync(GetInspectedTab(),
+ is_docked);
}
WebContents* GetInspectedTab() {
return browser()->tab_strip_model()->GetWebContentsAt(0);
}
- void ToggleDevToolsWindow() {
- content::WindowedNotificationObserver close_observer(
- content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(window_->web_contents()));
- DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
- DevToolsToggleAction::Toggle());
- close_observer.Wait();
+ void CloseDevToolsWindow() {
+ DevToolsWindowTesting::CloseDevToolsWindowSync(window_);
}
- void ToggleDevToolsWindowDontWait() {
- DevToolsWindow::ToggleDevToolsWindow(inspected_rvh_, false,
- DevToolsToggleAction::Toggle());
+ WebContents* main_web_contents() {
+ return DevToolsWindowTesting::Get(window_)->main_web_contents();
}
- void CloseDevToolsWindow() {
- DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
- content::WindowedNotificationObserver close_observer(
- content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(window_->web_contents()));
- devtools_manager->CloseAllClientHosts();
- close_observer.Wait();
+ WebContents* toolbox_web_contents() {
+ return DevToolsWindowTesting::Get(window_)->toolbox_web_contents();
}
DevToolsWindow* window_;
- RenderViewHost* inspected_rvh_;
};
// Used to block until a dev tools window gets beforeunload event.
DevToolsWindowBeforeUnloadObserver::DevToolsWindowBeforeUnloadObserver(
DevToolsWindow* devtools_window)
- : WebContentsObserver(devtools_window->web_contents()),
+ : WebContentsObserver(
+ DevToolsWindowTesting::Get(devtools_window)->main_web_contents()),
m_fired(false) {
}
TabStripModel::CLOSE_NONE);
}
- void CloseDockedDevTools() {
- ToggleDevToolsWindowDontWait();
- }
-
- void CloseUndockedDevTools() {
- chrome::CloseWindow(window_->browser());
+ void CloseDevToolsWindowAsync() {
+ DevToolsWindowTesting::CloseDevToolsWindow(window_);
}
void CloseInspectedBrowser() {
chrome::CloseWindow(browser());
}
+
protected:
void InjectBeforeUnloadListener(content::WebContents* web_contents) {
ASSERT_TRUE(content::ExecuteScript(web_contents->GetRenderViewHost(),
base::Callback<void(void)> close_method,
bool wait_for_browser_close = true) {
OpenDevToolsWindow(kDebuggerTestPage, is_docked);
- content::WindowedNotificationObserver devtools_close_observer(
- content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(window_->web_contents()));
- InjectBeforeUnloadListener(window_->web_contents());
+ scoped_refptr<content::MessageLoopRunner> runner =
+ new content::MessageLoopRunner;
+ DevToolsWindowTesting::Get(window_)->
+ SetCloseCallback(runner->QuitClosure());
+ InjectBeforeUnloadListener(main_web_contents());
{
DevToolsWindowBeforeUnloadObserver before_unload_observer(window_);
close_method.Run();
if (wait_for_browser_close)
close_observer.Wait();
}
- devtools_close_observer.Wait();
+ runner->Run();
}
DevToolsWindow* OpenDevToolWindowOnWebContents(
content::WebContents* contents, bool is_docked) {
- content::WindowedNotificationObserver observer(
- content::NOTIFICATION_LOAD_STOP,
- content::NotificationService::AllSources());
- DevToolsWindow* window = DevToolsWindow::OpenDevToolsWindowForTest(
- contents->GetRenderViewHost(), is_docked);
- observer.Wait();
+ DevToolsWindow* window =
+ DevToolsWindowTesting::OpenDevToolsWindowSync(contents, is_docked);
return window;
}
content::NOTIFICATION_LOAD_STOP,
content::NotificationService::AllSources());
ASSERT_TRUE(content::ExecuteScript(
- devtools_window->web_contents()->GetRenderViewHost(),
+ DevToolsWindowTesting::Get(devtools_window)->
+ main_web_contents()->GetRenderViewHost(),
"window.open(\"\", \"\", \"location=0\");"));
observer.Wait();
}
void CloseDevToolsPopupWindow(DevToolsWindow* devtools_window) {
- Browser* popup_browser = NULL;
- for (chrome::BrowserIterator it; !it.done(); it.Next()) {
- if (it->is_devtools()) {
- content::WebContents* contents =
- it->tab_strip_model()->GetWebContentsAt(0);
- if (devtools_window->web_contents() != contents) {
- popup_browser = *it;
- break;
- }
- }
- }
- ASSERT_FALSE(popup_browser == NULL);
- content::WindowedNotificationObserver close_observer(
- chrome::NOTIFICATION_BROWSER_CLOSED,
- content::Source<Browser>(popup_browser));
- chrome::CloseWindow(popup_browser);
- close_observer.Wait();
+ DevToolsWindowTesting::CloseDevToolsWindowSync(devtools_window);
}
void AcceptModalDialog() {
};
void TimeoutCallback(const std::string& timeout_message) {
- FAIL() << timeout_message;
+ ADD_FAILURE() << timeout_message;
base::MessageLoop::current()->Quit();
}
size_t num_before = service->extensions()->size();
{
content::NotificationRegistrar registrar;
- registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
+ registrar.Add(this,
+ extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
content::NotificationService::AllSources());
base::CancelableClosure timeout(
base::Bind(&TimeoutCallback, "Extension load timed out."));
// this method is running.
content::NotificationRegistrar registrar;
- registrar.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+ registrar.Add(this,
+ extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
content::NotificationService::AllSources());
base::CancelableClosure timeout(
base::Bind(&TimeoutCallback, "Extension host load timed out."));
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE {
switch (type) {
- case chrome::NOTIFICATION_EXTENSION_LOADED:
- case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
+ case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
+ case extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
base::MessageLoopForUI::current()->Quit();
break;
default:
}
static void TerminateWorkerOnIOThread(scoped_refptr<WorkerData> worker_data) {
- if (WorkerService::GetInstance()->TerminateWorker(
- worker_data->worker_process_id, worker_data->worker_route_id)) {
- WorkerService::GetInstance()->AddObserver(
- new WorkerTerminationObserver(worker_data.get()));
- return;
- }
- FAIL() << "Failed to terminate worker.\n";
+ if (!WorkerService::GetInstance()->TerminateWorker(
+ worker_data->worker_process_id, worker_data->worker_route_id))
+ FAIL() << "Failed to terminate worker.\n";
+ WorkerService::GetInstance()->AddObserver(
+ new WorkerTerminationObserver(worker_data.get()));
}
static void TerminateWorker(scoped_refptr<WorkerData> worker_data) {
DevToolsAgentHost::GetForWorker(
worker_data->worker_process_id,
worker_data->worker_route_id));
- window_ = DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host);
- RenderViewHost* client_rvh = window_->GetRenderViewHost();
- WebContents* client_contents = WebContents::FromRenderViewHost(client_rvh);
- if (client_contents->IsLoading()) {
- content::WindowedNotificationObserver observer(
- content::NOTIFICATION_LOAD_STOP,
- content::Source<NavigationController>(
- &client_contents->GetController()));
- observer.Wait();
- }
+ window_ = DevToolsWindowTesting::OpenDevToolsWindowForWorkerSync(
+ profile, agent_host.get());
}
void CloseDevToolsWindow() {
- Browser* browser = window_->browser();
- content::WindowedNotificationObserver close_observer(
- content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(window_->web_contents()));
- browser->tab_strip_model()->CloseAllTabs();
- close_observer.Wait();
+ DevToolsWindowTesting::CloseDevToolsWindowSync(window_);
}
DevToolsWindow* window_;
// we try to close them.
IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest, TestDockedDevToolsClose) {
RunBeforeUnloadSanityTest(true, base::Bind(
- &DevToolsBeforeUnloadTest::CloseDockedDevTools, this), false);
+ &DevToolsBeforeUnloadTest::CloseDevToolsWindowAsync, this), false);
}
// Tests that BeforeUnload event gets called on docked devtools if
// we try to close them.
IN_PROC_BROWSER_TEST_F(DevToolsBeforeUnloadTest, TestUndockedDevToolsClose) {
RunBeforeUnloadSanityTest(false, base::Bind(
- &DevToolsBeforeUnloadTest::CloseUndockedDevTools, this), false);
+ &DevToolsBeforeUnloadTest::CloseDevToolsWindowAsync, this), false);
}
// Tests that BeforeUnload event gets called on undocked devtools if
&chrome::CloseAllBrowsers));
}
+// Times out on Win and Linux
+// @see http://crbug.com/410327
+#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
+#define MAYBE_TestUndockedDevToolsUnresponsive DISABLED_TestUndockedDevToolsUnresponsive
+#else
+#define MAYBE_TestUndockedDevToolsUnresponsive TestUndockedDevToolsUnresponsive
+#endif
+
// Tests that inspected tab gets closed if devtools renderer
// becomes unresponsive during beforeunload event interception.
// @see http://crbug.com/322380
IN_PROC_BROWSER_TEST_F(DevToolsUnresponsiveBeforeUnloadTest,
- TestUndockedDevToolsUnresponsive) {
+ MAYBE_TestUndockedDevToolsUnresponsive) {
ASSERT_TRUE(test_server()->Start());
LoadTestPage(kDebuggerTestPage);
DevToolsWindow* devtools_window = OpenDevToolWindowOnWebContents(
GetInspectedTab(), false);
- content::WindowedNotificationObserver devtools_close_observer(
- content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(
- devtools_window->web_contents()));
+
+ scoped_refptr<content::MessageLoopRunner> runner =
+ new content::MessageLoopRunner;
+ DevToolsWindowTesting::Get(devtools_window)->SetCloseCallback(
+ runner->QuitClosure());
ASSERT_TRUE(content::ExecuteScript(
- devtools_window->web_contents()->GetRenderViewHost(),
+ DevToolsWindowTesting::Get(devtools_window)->main_web_contents()->
+ GetRenderViewHost(),
"window.addEventListener('beforeunload',"
"function(event) { while (true); });"));
CloseInspectedTab();
- devtools_close_observer.Wait();
+ runner->Run();
}
// Tests that closing worker inspector window does not cause browser crash
LoadTestPage(kDebuggerTestPage);
DevToolsWindow* devtools_window = OpenDevToolWindowOnWebContents(
GetInspectedTab(), false);
- content::WindowedNotificationObserver devtools_close_observer(
- content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
- content::Source<content::WebContents>(
- devtools_window->web_contents()));
OpenDevToolsPopupWindow(devtools_window);
CloseDevToolsPopupWindow(devtools_window);
new content::WindowedNotificationObserver(
content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
content::Source<content::WebContents>(
- devtools_window->web_contents()));
+ DevToolsWindowTesting::Get(devtools_window)->
+ main_web_contents()));
close_observers.push_back(close_observer);
- inspected_web_contents = devtools_window->web_contents();
+ inspected_web_contents =
+ DevToolsWindowTesting::Get(devtools_window)->main_web_contents();
}
- InjectBeforeUnloadListener(windows[0]->web_contents());
- InjectBeforeUnloadListener(windows[2]->web_contents());
+ InjectBeforeUnloadListener(
+ DevToolsWindowTesting::Get(windows[0])->main_web_contents());
+ InjectBeforeUnloadListener(
+ DevToolsWindowTesting::Get(windows[2])->main_web_contents());
// Try to close second devtools.
{
content::WindowedNotificationObserver cancel_browser(
chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
content::NotificationService::AllSources());
- chrome::CloseWindow(windows[1]->browser());
+ chrome::CloseWindow(DevToolsWindowTesting::Get(windows[1])->browser());
CancelModalDialog();
cancel_browser.Wait();
}
content::WindowedNotificationObserver close_observer(
chrome::NOTIFICATION_BROWSER_CLOSED,
content::Source<Browser>(browser()));
- chrome::StartKeepAlive();
+ chrome::IncrementKeepAliveCount();
chrome::CloseAllBrowsers();
AcceptModalDialog();
AcceptModalDialog();
}
// Tests scripts panel showing.
-// TODO(pfeldman): figure out flake.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, DISABLED_TestShowScriptsTab) {
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestShowScriptsTab) {
RunTest("testShowScriptsTab", kDebuggerTestPage);
}
IN_PROC_BROWSER_TEST_F(
DevToolsSanityTest,
TestScriptsTabIsPopulatedOnInspectedPageRefresh) {
- // Clear inspector settings to ensure that Elements will be
- // current panel when DevTools window is open.
- content::BrowserContext* browser_context =
- GetInspectedTab()->GetBrowserContext();
- Profile::FromBrowserContext(browser_context)->GetPrefs()->
- ClearPref(prefs::kWebKitInspectorSettings);
-
RunTest("testScriptsTabIsPopulatedOnInspectedPageRefresh",
kDebuggerTestPage);
}
}
// Tests that a content script is in the scripts list.
-// History of flakiness: http://crbug.com/114104, http://crbug.com/315288.
IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
- DISABLED_TestContentScriptIsPresent) {
+ TestContentScriptIsPresent) {
LoadExtension("simple_content_script");
RunTest("testContentScriptIsPresent", kPageWithContentScript);
}
-// Fails quite consistently on Win XP: crbug.com/317725.
-#if defined(OS_WIN) || defined(OS_MACOSX)
-#define MAYBE_TestNoScriptDuplicatesOnPanelSwitch \
- DISABLED_TestNoScriptDuplicatesOnPanelSwitch
-#else
-#define MAYBE_TestNoScriptDuplicatesOnPanelSwitch \
- TestNoScriptDuplicatesOnPanelSwitch
-#endif
-
// Tests that scripts are not duplicated after Scripts Panel switch.
IN_PROC_BROWSER_TEST_F(DevToolsSanityTest,
- MAYBE_TestNoScriptDuplicatesOnPanelSwitch) {
+ TestNoScriptDuplicatesOnPanelSwitch) {
RunTest("testNoScriptDuplicatesOnPanelSwitch", kDebuggerTestPage);
}
// Tests that debugger works correctly if pause event occurs when DevTools
// frontend is being loaded.
-// Disabled because of flakiness on all platforms: crbug.com/329036
IN_PROC_BROWSER_TEST_F(DevToolsSanityTest,
- DISABLED_TestPauseWhenLoadingDevTools) {
+ TestPauseWhenLoadingDevTools) {
RunTest("testPauseWhenLoadingDevTools", kPauseWhenLoadingDevTools);
}
// Tests that pressing 'Pause' will pause script execution if the script
// is already running.
-#if defined(OS_WIN)
-// Timing out on windows tryservers: http://crbug.com/219515
-#define MAYBE_TestPauseWhenScriptIsRunning DISABLED_TestPauseWhenScriptIsRunning
-#elif defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
// Timing out on linux ARM bot: https://crbug/238453
#define MAYBE_TestPauseWhenScriptIsRunning DISABLED_TestPauseWhenScriptIsRunning
#else
}
// Tests that console messages are not duplicated on navigation back.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestConsoleOnNavigateBack) {
+#if defined(OS_WIN)
+// Flaking on windows swarm try runs: crbug.com/409285.
+#define MAYBE_TestConsoleOnNavigateBack DISABLED_TestConsoleOnNavigateBack
+#else
+#define MAYBE_TestConsoleOnNavigateBack TestConsoleOnNavigateBack
+#endif
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestConsoleOnNavigateBack) {
RunTest("testConsoleOnNavigateBack", kNavigateBackTestPage);
}
+// https://crbug.com/397889
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, DISABLED_TestDeviceEmulation) {
+ RunTest("testDeviceMetricsOverrides", "about:blank");
+}
+
// Tests that external navigation from inspector page is always handled by
// DevToolsWindow and results in inspected page navigation.
IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDevToolsExternalNavigation) {
OpenDevToolsWindow(kDebuggerTestPage, true);
GURL url = test_server()->GetURL(kNavigateBackTestPage);
- content::WindowedNotificationObserver observer(
- content::NOTIFICATION_LOAD_STOP,
+ ui_test_utils::UrlLoadObserver observer(url,
content::NotificationService::AllSources());
ASSERT_TRUE(content::ExecuteScript(
- window_->web_contents(),
+ main_web_contents(),
std::string("window.location = \"") + url.spec() + "\""));
observer.Wait();
- ASSERT_TRUE(window_->web_contents()->GetURL().
- SchemeIs(chrome::kChromeDevToolsScheme));
- ASSERT_EQ(GetInspectedTab()->GetURL(), url);
+ ASSERT_TRUE(main_web_contents()->GetURL().
+ SchemeIs(content::kChromeDevToolsScheme));
+ ASSERT_EQ(url, GetInspectedTab()->GetURL());
CloseDevToolsWindow();
}
-#if defined(OS_WIN) || defined(OS_MACOSX)
-// Flakily times out: http://crbug.com/163411
-#define MAYBE_TestReattachAfterCrash DISABLED_TestReattachAfterCrash
-#else
-#define MAYBE_TestReattachAfterCrash TestReattachAfterCrash
-#endif
-// Tests that inspector will reattach to inspected page when it is reloaded
-// after a crash. See http://crbug.com/101952
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestReattachAfterCrash) {
+// Tests that toolbox window is loaded when DevTools window is undocked.
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestToolboxLoadedUndocked) {
OpenDevToolsWindow(kDebuggerTestPage, false);
+ ASSERT_TRUE(toolbox_web_contents());
+ DevToolsWindow* on_self =
+ DevToolsWindowTesting::OpenDevToolsWindowSync(main_web_contents(), false);
+ ASSERT_FALSE(DevToolsWindowTesting::Get(on_self)->toolbox_web_contents());
+ DevToolsWindowTesting::CloseDevToolsWindowSync(on_self);
+ CloseDevToolsWindow();
+}
- content::CrashTab(GetInspectedTab());
- content::WindowedNotificationObserver observer(
- content::NOTIFICATION_LOAD_STOP,
- content::Source<NavigationController>(
- &browser()->tab_strip_model()->GetActiveWebContents()->
- GetController()));
- chrome::Reload(browser(), CURRENT_TAB);
- observer.Wait();
-
- RunTestFunction(window_, "testReattachAfterCrash");
+// Tests that toolbox window is not loaded when DevTools window is docked.
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestToolboxNotLoadedDocked) {
+ OpenDevToolsWindow(kDebuggerTestPage, true);
+ ASSERT_FALSE(toolbox_web_contents());
+ DevToolsWindow* on_self =
+ DevToolsWindowTesting::OpenDevToolsWindowSync(main_web_contents(), false);
+ ASSERT_FALSE(DevToolsWindowTesting::Get(on_self)->toolbox_web_contents());
+ DevToolsWindowTesting::CloseDevToolsWindowSync(on_self);
CloseDevToolsWindow();
}
+// Tests that inspector will reattach to inspected page when it is reloaded
+// after a crash. See http://crbug.com/101952
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestReattachAfterCrash) {
+ RunTest("testReattachAfterCrash", std::string());
+}
+
IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPageWithNoJavaScript) {
OpenDevToolsWindow("about:blank", false);
std::string result;
ASSERT_TRUE(
content::ExecuteScriptAndExtractString(
- window_->GetRenderViewHost(),
+ main_web_contents()->GetRenderViewHost(),
"window.domAutomationController.send("
" '' + (window.uiTests && (typeof uiTests.runTest)));",
&result));
CloseDevToolsWindow();
}
-#if defined(OS_MACOSX)
-#define MAYBE_InspectSharedWorker DISABLED_InspectSharedWorker
-#else
-#define MAYBE_InspectSharedWorker InspectSharedWorker
-#endif
-// Flakily fails with 25s timeout: http://crbug.com/89845
-IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, MAYBE_InspectSharedWorker) {
+// Flakily fails: http://crbug.com/403007 http://crbug.com/89845
+IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest, DISABLED_InspectSharedWorker) {
#if defined(OS_WIN) && defined(USE_ASH)
// Disable this test in Metro+Ash for now (http://crbug.com/262796).
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
}
// http://crbug.com/100538
-#if defined(OS_MACOSX) || defined(OS_WIN)
-#define MAYBE_PauseInSharedWorkerInitialization DISABLED_PauseInSharedWorkerInitialization
-#else
-#define MAYBE_PauseInSharedWorkerInitialization PauseInSharedWorkerInitialization
-#endif
-
-// http://crbug.com/106114 is masking
-// MAYBE_PauseInSharedWorkerInitialization into
-// DISABLED_PauseInSharedWorkerInitialization
IN_PROC_BROWSER_TEST_F(WorkerDevToolsSanityTest,
- MAYBE_PauseInSharedWorkerInitialization) {
+ DISABLED_PauseInSharedWorkerInitialization) {
ASSERT_TRUE(test_server()->Start());
GURL url = test_server()->GetURL(kReloadSharedWorkerTestPage);
ui_test_utils::NavigateToURL(browser(), url);
// Tests DevToolsAgentHost retention by its target.
IN_PROC_BROWSER_TEST_F(DevToolsAgentHostTest, TestAgentHostReleased) {
ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
- RenderViewHost* rvh = browser()->tab_strip_model()->GetWebContentsAt(0)->
- GetRenderViewHost();
- DevToolsAgentHost* agent_raw = DevToolsAgentHost::GetOrCreateFor(rvh).get();
+ WebContents* web_contents = browser()->tab_strip_model()->GetWebContentsAt(0);
+ DevToolsAgentHost* agent_raw =
+ DevToolsAgentHost::GetOrCreateFor(web_contents).get();
const std::string agent_id = agent_raw->GetId();
- ASSERT_EQ(agent_raw, DevToolsAgentHost::GetForId(agent_id)) <<
- "DevToolsAgentHost cannot be found by id";
+ ASSERT_EQ(agent_raw, DevToolsAgentHost::GetForId(agent_id).get())
+ << "DevToolsAgentHost cannot be found by id";
browser()->tab_strip_model()->
CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
ASSERT_FALSE(DevToolsAgentHost::GetForId(agent_id).get())
projects / platform / framework / web / crosswalk.git / blobdiff