[Media Router] Add integration browser tests

chrome/test/media_router/media_router_integration_browsertest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/test/media_router/media_router_integration_browsertest.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/ui/webui/media_router/media_router_dialog_controller_impl.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/filename_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using content::WebContents;
 
 namespace media_router {
 
 namespace {
 // Command line argument to specify receiver,
 const char kReceiver[] = "receiver";
 // The path relative to <chromium src>/out/<build config> for media router
 // browser test resources.
 const base::FilePath::StringPieceType kResourcePath = FILE_PATH_LITERAL(
     "media_router/browser_test_resources/");
 const char kTestSinkName[] = "test-sink-1";
 // The javascript snippets.
 const char kCheckSessionScript[] = "checkSession();";
 const char kCheckStartFailedScript[] = "checkStartFailed('%s', '%s');";
 const char kStartSessionScript[] = "startSession();";
 const char kTerminateSessionScript[] =
     "terminateSessionAndWaitForStateChange();";
+const char kCloseSessionScript[] = "closeSessionAndWaitForStateChange();";
+const char kReconnectSessionScript[] = "reconnectSession('%s');";
+const char kCheckSendMessageFailedScript[] = "checkSendMessageFailed('%s');";
 const char kWaitDeviceScript[] = "waitUntilDeviceAvailable();";
 const char kSendMessageAndExpectResponseScript[] =
     "sendMessageAndExpectResponse('%s');";
 const char kSendMessageAndExpectConnectionCloseOnErrorScript[] =
     "sendMessageAndExpectConnectionCloseOnError()";
 const char kChooseSinkScript[] =
     "var sinks = document.getElementById('media-router-container')."
     "  shadowRoot.getElementById('sink-list').getElementsByTagName('span');"
     "for (var i=0; i<sinks.length; i++) {"
     "  if(sinks[i].textContent.trim() == '%s') {"
@@ skipping 37 matching lines @@
     "/** Wait until media router container is not undefined and "
     "*   deviceMissingUrl is not undefined, "
     "*   once deviceMissingUrl is not undefined, which means "
     "*   the dialog is fully loaded."
     "*/"
     "if (container != undefined && container.deviceMissingUrl != undefined) {"
     "  domAutomationController.send(true);"
     "}"
     "domAutomationController.send(false);";
 
-std::string GetStartedConnectionId(content::WebContents* web_contents) {
+std::string GetStartedConnectionId(WebContents* web_contents) {
   std::string session_id;
   CHECK(content::ExecuteScriptAndExtractString(
       web_contents, "window.domAutomationController.send(startedConnection.id)",
       &session_id));
   return session_id;
 }
 
-std::string GetDefaultRequestSessionId(content::WebContents* web_contents) {
+std::string GetDefaultRequestSessionId(WebContents* web_contents) {
   std::string session_id;
   CHECK(content::ExecuteScriptAndExtractString(
       web_contents,
       "window.domAutomationController.send(defaultRequestSessionId)",
       &session_id));
   return session_id;
 }
 
 }  // namespace
 
 MediaRouterIntegrationBrowserTest::MediaRouterIntegrationBrowserTest() {
 }
 
 MediaRouterIntegrationBrowserTest::~MediaRouterIntegrationBrowserTest() {
 }
 
 void MediaRouterIntegrationBrowserTest::TearDownOnMainThread() {
   MediaRouterBaseBrowserTest::TearDownOnMainThread();
   test_navigation_observer_.reset();
 }
 
 void MediaRouterIntegrationBrowserTest::ExecuteJavaScriptAPI(
-    content::WebContents* web_contents,
+    WebContents* web_contents,
     const std::string& script) {
   std::string result(ExecuteScriptAndExtractString(web_contents, script));
 
   // Read the test result, the test result set by javascript is a
   // JSON string with the following format:
   // {"passed": "<true/false>", "errorMessage": "<error_message>"}
   std::unique_ptr<base::Value> value =
       base::JSONReader::Read(result, base::JSON_ALLOW_TRAILING_COMMAS);
 
   // Convert to dictionary.
   base::DictionaryValue* dict_value = nullptr;
   ASSERT_TRUE(value->GetAsDictionary(&dict_value));
 
   // Extract the fields.
   bool passed = false;
   ASSERT_TRUE(dict_value->GetBoolean("passed", &passed));
   std::string error_message;
   ASSERT_TRUE(dict_value->GetString("errorMessage", &error_message));
 
   ASSERT_TRUE(passed) << error_message;
 }
 
+WebContents* MediaRouterIntegrationBrowserTest::StartSessionWithTestPage(
+    bool wait_for_sink) {
+  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
+  WebContents* web_contents = GetActiveWebContents();
+  CHECK(web_contents);
+  if (wait_for_sink)
+    ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);

[mark a. foltz, 2017/02/09 23:29:59]

I feel link this should be kWaitSinkScript to be consistent with other script
names.

[takumif, 2017/02/14 19:11:48]

Done.

+  StartSession(web_contents);
+  return web_contents;
+}
+
+WebContents*
+MediaRouterIntegrationBrowserTest::StartSessionWithTestPageAndChooseSink(
+    bool should_succeed) {
+  WebContents* web_contents = StartSessionWithTestPage(true);
+  WaitUntilSinkDiscoveredOnUI();
+  ChooseSink(web_contents, kTestSinkName);
+  if (should_succeed)
+    CheckSessionValidity(web_contents);
+  return web_contents;
+}
+
 void MediaRouterIntegrationBrowserTest::OpenTestPage(
     base::FilePath::StringPieceType file_name) {
   base::FilePath full_path = GetResourceFile(file_name);
   ui_test_utils::NavigateToURL(browser(), net::FilePathToFileURL(full_path));
 }
 
 void MediaRouterIntegrationBrowserTest::OpenTestPageInNewTab(
     base::FilePath::StringPieceType file_name) {
   base::FilePath full_path = GetResourceFile(file_name);
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), net::FilePathToFileURL(full_path),
       WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 void MediaRouterIntegrationBrowserTest::StartSession(
-    content::WebContents* web_contents) {
+    WebContents* web_contents) {
   test_navigation_observer_.reset(
       new content::TestNavigationObserver(web_contents, 1));
   test_navigation_observer_->StartWatchingNewWebContents();
   ExecuteJavaScriptAPI(web_contents, kStartSessionScript);
   test_navigation_observer_->Wait();
   test_navigation_observer_->StopWatchingNewWebContents();
 }
 
 void MediaRouterIntegrationBrowserTest::ChooseSink(
-    content::WebContents* web_contents,
+    WebContents* web_contents,
     const std::string& sink_name) {
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   std::string script = base::StringPrintf(
       kChooseSinkScript, sink_name.c_str());
   // Execute javascript to choose sink, but don't wait until it finishes.
   dialog_contents->GetMainFrame()->ExecuteJavaScriptWithUserGestureForTests(
       base::UTF8ToUTF16(script));
 }
 
 void MediaRouterIntegrationBrowserTest::CheckStartFailed(
-    content::WebContents* web_contents,
+    WebContents* web_contents,
     const std::string& error_name,
     const std::string& error_message_substring) {
   std::string script(base::StringPrintf(kCheckStartFailedScript,
                                         error_name.c_str(),
                                         error_message_substring.c_str()));
   ExecuteJavaScriptAPI(web_contents, script);
 }
 
 void MediaRouterIntegrationBrowserTest::ClickDialog() {
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* web_contents = GetActiveWebContents();
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   ASSERT_TRUE(content::ExecuteScript(dialog_contents, kClickDialog));
 }
-content::WebContents* MediaRouterIntegrationBrowserTest::GetMRDialog(
-    content::WebContents* web_contents) {
+WebContents* MediaRouterIntegrationBrowserTest::GetMRDialog(
+    WebContents* web_contents) {
   MediaRouterDialogControllerImpl* controller =
       MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
-  content::WebContents* dialog_contents = controller->GetMediaRouterDialog();
+  WebContents* dialog_contents = controller->GetMediaRouterDialog();
   CHECK(dialog_contents);
   WaitUntilDialogFullyLoaded(dialog_contents);
   return dialog_contents;
 }
 
 bool MediaRouterIntegrationBrowserTest::IsDialogClosed(
-    content::WebContents* web_contents) {
+    WebContents* web_contents) {
   MediaRouterDialogControllerImpl* controller =
       MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
   return !controller->GetMediaRouterDialog();
 }
 
 void MediaRouterIntegrationBrowserTest::WaitUntilDialogClosed(
-    content::WebContents* web_contents) {
+    WebContents* web_contents) {
   ASSERT_TRUE(ConditionalWait(
       base::TimeDelta::FromSeconds(5), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsDialogClosed,
                  base::Unretained(this), web_contents)));
 }
 
 void MediaRouterIntegrationBrowserTest::CheckDialogRemainsOpen(
-    content::WebContents* web_contents) {
+    WebContents* web_contents) {
   ASSERT_FALSE(ConditionalWait(
       base::TimeDelta::FromSeconds(5), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsDialogClosed,
                  base::Unretained(this), web_contents)));
 }
 
 void MediaRouterIntegrationBrowserTest::SetTestData(
     base::FilePath::StringPieceType test_data_file) {
   base::FilePath full_path = GetResourceFile(test_data_file);
   JSONFileValueDeserializer deserializer(full_path);
   int error_code = 0;
   std::string error_message;
   std::unique_ptr<base::Value> value =
       deserializer.Deserialize(&error_code, &error_message);
   CHECK(value.get()) << "Deserialize failed: " << error_message;
   std::string test_data_str;
   ASSERT_TRUE(base::JSONWriter::Write(*value, &test_data_str));
   ExecuteScriptInBackgroundPageNoWait(
       extension_id_,
       base::StringPrintf("localStorage['testdata'] = '%s'",
                          test_data_str.c_str()));
 }
 
-content::WebContents* MediaRouterIntegrationBrowserTest::OpenMRDialog(
-    content::WebContents* web_contents) {
+WebContents* MediaRouterIntegrationBrowserTest::OpenMRDialog(
+    WebContents* web_contents) {
   MediaRouterDialogControllerImpl* controller =
       MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
   test_navigation_observer_.reset(
         new content::TestNavigationObserver(web_contents, 1));
   test_navigation_observer_->StartWatchingNewWebContents();
   CHECK(controller->ShowMediaRouterDialog());
   test_navigation_observer_->Wait();
   test_navigation_observer_->StopWatchingNewWebContents();
-  content::WebContents* dialog_contents = controller->GetMediaRouterDialog();
+  WebContents* dialog_contents = controller->GetMediaRouterDialog();
   CHECK(dialog_contents);
   WaitUntilDialogFullyLoaded(dialog_contents);
   return dialog_contents;
 }
 
 base::FilePath MediaRouterIntegrationBrowserTest::GetResourceFile(
     base::FilePath::StringPieceType relative_path) const {
   base::FilePath base_dir;
   // ASSERT_TRUE can only be used in void returning functions.
   // Use CHECK instead in non-void returning functions.
@@ skipping 29 matching lines @@
     const content::ToRenderFrameHost& adapter, const std::string& script) {
   ASSERT_TRUE(content::ExecuteScript(adapter, script));
 }
 
 bool MediaRouterIntegrationBrowserTest::IsRouteCreatedOnUI() {
   return !GetRouteId(receiver()).empty();
 }
 
 std::string MediaRouterIntegrationBrowserTest::GetRouteId(
     const std::string& sink_name) {
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* web_contents = GetActiveWebContents();
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   std::string script = base::StringPrintf(kGetSinkIdScript, sink_name.c_str());
   std::string sink_id = ExecuteScriptAndExtractString(dialog_contents, script);
   DVLOG(0) << "sink id: " << sink_id;
   script = base::StringPrintf(kGetRouteIdScript, sink_id.c_str());
   std::string route_id = ExecuteScriptAndExtractString(dialog_contents, script);
   DVLOG(0) << "route id: " << route_id;
   return route_id;
 }
 
 void MediaRouterIntegrationBrowserTest::WaitUntilRouteCreated() {
   ASSERT_TRUE(ConditionalWait(
       base::TimeDelta::FromSeconds(10), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsRouteCreatedOnUI,
                  base::Unretained(this))));
 }
 
 bool MediaRouterIntegrationBrowserTest::IsUIShowingIssue() {
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* web_contents = GetActiveWebContents();
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   std::string script = base::StringPrintf(
       "domAutomationController.send(window.document.getElementById("
       "'media-router-container').issue != undefined)");
   bool has_issue = false;
   CHECK(content::ExecuteScriptAndExtractBool(dialog_contents, script,
                                              &has_issue));
   return has_issue;
 }
 
 void MediaRouterIntegrationBrowserTest::WaitUntilIssue() {
   ASSERT_TRUE(ConditionalWait(
       base::TimeDelta::FromSeconds(30), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsUIShowingIssue,
                  base::Unretained(this))));
 }
 
 std::string MediaRouterIntegrationBrowserTest::GetIssueTitle() {
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* web_contents = GetActiveWebContents();
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   std::string script = base::StringPrintf(
       "domAutomationController.send(window.document.getElementById("
       "'media-router-container').issue.title)");
   return ExecuteScriptAndExtractString(dialog_contents, script);
 }
 
 bool MediaRouterIntegrationBrowserTest::IsRouteClosedOnUI() {
   // After execute js script to close route on UI, the dialog will dispear
   // after 3s. But sometimes it takes more than 3s to close the route, so
   // we need to re-open the dialog if it is closed.
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
+  WebContents* web_contents = GetActiveWebContents();
   MediaRouterDialogControllerImpl* controller =
       MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
-  content::WebContents* dialog_contents = controller->GetMediaRouterDialog();
+  WebContents* dialog_contents = controller->GetMediaRouterDialog();
   if (!dialog_contents) {
     VLOG(0) << "Media router dialog was closed, reopen it again.";
     OpenMRDialog(web_contents);
   }
   return GetRouteId(receiver()).empty();
 }
 
 void MediaRouterIntegrationBrowserTest::CloseRouteOnUI() {
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* web_contents = GetActiveWebContents();
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   ASSERT_TRUE(content::ExecuteScript(dialog_contents, kCloseRouteScript));
   ASSERT_TRUE(ConditionalWait(
       base::TimeDelta::FromSeconds(10), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsRouteClosedOnUI,
                  base::Unretained(this))));
 }
 
 bool MediaRouterIntegrationBrowserTest::IsSinkDiscoveredOnUI() {
-  content::WebContents* web_contents =
-        browser()->tab_strip_model()->GetActiveWebContents();
-  content::WebContents* dialog_contents = GetMRDialog(web_contents);
+  WebContents* web_contents = GetActiveWebContents();
+  WebContents* dialog_contents = GetMRDialog(web_contents);
   std::string script = base::StringPrintf(kFindSinkScript, receiver().c_str());
   return ExecuteScriptAndExtractBool(dialog_contents, script);
 }
 
 void MediaRouterIntegrationBrowserTest::WaitUntilSinkDiscoveredOnUI() {

[mark a. foltz, 2017/02/09 23:29:59]

How is this different from running kWaitDeviceScript?

[takumif, 2017/02/14 19:11:48]

This waits for a sink to appear in the dialog UI, whereas kWaitDeviceScript
waits for PresentationRequest.getAvailability() promise to be resolved.

   DVLOG(0) << "Receiver name: " << receiver_;
   // Wait for sink to show up in UI.
   ASSERT_TRUE(ConditionalWait(
       base::TimeDelta::FromSeconds(30), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsSinkDiscoveredOnUI,
                  base::Unretained(this))));
 }
 
 bool MediaRouterIntegrationBrowserTest::IsDialogLoaded(
-    content::WebContents* dialog_contents) {
+    WebContents* dialog_contents) {
   return ExecuteScriptAndExtractBool(dialog_contents, kCheckDialogLoadedScript);
 }
 
 void MediaRouterIntegrationBrowserTest::WaitUntilDialogFullyLoaded(
-    content::WebContents* dialog_contents) {
+    WebContents* dialog_contents) {
   ASSERT_TRUE(ConditionalWait(
       base::TimeDelta::FromSeconds(30), base::TimeDelta::FromSeconds(1),
       base::Bind(&MediaRouterIntegrationBrowserTest::IsDialogLoaded,
                  base::Unretained(this), dialog_contents)));
 }
 
 void MediaRouterIntegrationBrowserTest::ParseCommandLine() {
   MediaRouterBaseBrowserTest::ParseCommandLine();
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   receiver_ = command_line->GetSwitchValueASCII(kReceiver);
   if (receiver_.empty())
     receiver_ = kTestSinkName;
 }
 
-IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest, MANUAL_Basic) {
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
+void MediaRouterIntegrationBrowserTest::CheckSessionValidity(
+    WebContents* web_contents) {
   ExecuteJavaScriptAPI(web_contents, kCheckSessionScript);
   std::string session_id(GetStartedConnectionId(web_contents));
   EXPECT_FALSE(session_id.empty());
-
   std::string default_request_session_id(
       GetDefaultRequestSessionId(web_contents));
   EXPECT_EQ(session_id, default_request_session_id);
+}
 
+void MediaRouterIntegrationBrowserTest::HideMediaRouterDialog(
+    WebContents* web_contents,
+    bool wait_for_sink) {
+  MediaRouterDialogControllerImpl* controller =
+      MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
+  EXPECT_TRUE(controller->IsShowingMediaRouterDialog());
+  if (wait_for_sink)
+    WaitUntilSinkDiscoveredOnUI();
+  controller->HideMediaRouterDialog();
+}
+
+WebContents* MediaRouterIntegrationBrowserTest::GetActiveWebContents() {
+  return browser()->tab_strip_model()->GetActiveWebContents();
+}
+
+void MediaRouterIntegrationBrowserTest::RunBasicTest() {
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
   ExecuteJavaScriptAPI(web_contents, kTerminateSessionScript);
 }
 
-IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
-                       MANUAL_SendAndOnMessage) {
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
-  ExecuteJavaScriptAPI(web_contents, kCheckSessionScript);
-  std::string session_id(GetStartedConnectionId(web_contents));
-  EXPECT_FALSE(session_id.empty());
-
-  ExecuteJavaScriptAPI(
-      web_contents,
-      base::StringPrintf(kSendMessageAndExpectResponseScript, "foo"));
-}
-
-IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest, MANUAL_OnClose) {
-  SetTestData(FILE_PATH_LITERAL("close_route_with_error_on_send.json"));
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
-  ExecuteJavaScriptAPI(web_contents, kCheckSessionScript);
-  std::string session_id(GetStartedConnectionId(web_contents));
-  EXPECT_FALSE(session_id.empty());
-
-  ExecuteJavaScriptAPI(
-      web_contents,
-      base::StringPrintf("%s",
-                         kSendMessageAndExpectConnectionCloseOnErrorScript));
-}
-
-IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
-                       MANUAL_Fail_NoProvider) {
-  SetTestData(FILE_PATH_LITERAL("no_provider.json"));
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
-  CheckStartFailed(web_contents, "UnknownError",
-      "No provider supports createRoute with source");
-}
-
-IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
-                       MANUAL_Fail_CreateRoute) {
-  SetTestData(FILE_PATH_LITERAL("fail_create_route.json"));
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
-  CheckStartFailed(web_contents, "UnknownError", "Unknown sink");
-}
-
-IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
-                       MANUAL_ReconnectSession) {
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
-  ExecuteJavaScriptAPI(web_contents, kCheckSessionScript);
+void MediaRouterIntegrationBrowserTest::RunReconnectSessionTest() {
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
   std::string session_id(GetStartedConnectionId(web_contents));
 
   // Wait a few seconds for MediaRouter to receive updates containing the
   // created route.
   Wait(base::TimeDelta::FromSeconds(3));
 
   OpenTestPageInNewTab(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* new_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
+  WebContents* new_web_contents = GetActiveWebContents();
   ASSERT_TRUE(new_web_contents);
   ASSERT_NE(web_contents, new_web_contents);
   ExecuteJavaScriptAPI(
       new_web_contents,
-      base::StringPrintf("reconnectSession('%s');", session_id.c_str()));
+      base::StringPrintf(kReconnectSessionScript, session_id.c_str()));
   std::string reconnected_session_id;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       new_web_contents,
       "window.domAutomationController.send(reconnectedSession.id)",
       &reconnected_session_id));
   ASSERT_EQ(session_id, reconnected_session_id);
 }
 
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest, MANUAL_Basic) {
+  RunBasicTest();
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
+                       MANUAL_SendAndOnMessage) {
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
+  ExecuteJavaScriptAPI(
+      web_contents,
+      base::StringPrintf(kSendMessageAndExpectResponseScript, "foo"));
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
+                       MANUAL_CloseAndReconnect) {
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
+  ExecuteJavaScriptAPI(web_contents, kCloseSessionScript);
+
+  // Wait a few seconds for MediaRouter to receive status updates.
+  Wait(base::TimeDelta::FromSeconds(3));
+  std::string session_id(GetStartedConnectionId(web_contents));
+  ExecuteJavaScriptAPI(web_contents, base::StringPrintf(kReconnectSessionScript,
+                                                        session_id.c_str()));
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest, MANUAL_CloseOnError) {
+  SetTestData(FILE_PATH_LITERAL("close_route_with_error_on_send.json"));
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
+  ExecuteJavaScriptAPI(web_contents,
+                       kSendMessageAndExpectConnectionCloseOnErrorScript);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
+                       MANUAL_Fail_SendMessage) {
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
+  ExecuteJavaScriptAPI(web_contents, kCloseSessionScript);
+
+  // Wait a few seconds for MediaRouter to receive status updates.
+  Wait(base::TimeDelta::FromSeconds(3));
+  ExecuteJavaScriptAPI(
+      web_contents,
+      base::StringPrintf(kCheckSendMessageFailedScript, "closed"));
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
+                       MANUAL_Fail_NoProvider) {
+  SetTestData(FILE_PATH_LITERAL("no_provider.json"));
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(false);
+  CheckStartFailed(web_contents, "UnknownError",
+                   "No provider supports createRoute with source");
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
+                       MANUAL_Fail_CreateRoute) {
+  SetTestData(FILE_PATH_LITERAL("fail_create_route.json"));
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(false);
+  CheckStartFailed(web_contents, "UnknownError", "Unknown sink");
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
+                       MANUAL_ReconnectSession) {
+  RunReconnectSessionTest();
+}
+
 IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
                        MANUAL_Fail_ReconnectSession) {
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  content::TestNavigationObserver test_navigation_observer(web_contents, 1);
-  StartSession(web_contents);
-  WaitUntilSinkDiscoveredOnUI();
-  ChooseSink(web_contents, kTestSinkName);
-  ExecuteJavaScriptAPI(web_contents, kCheckSessionScript);
+  WebContents* web_contents = StartSessionWithTestPageAndChooseSink(true);
   std::string session_id(GetStartedConnectionId(web_contents));
 
   // Wait a few seconds for MediaRouter to receive updates containing the
   // created route.
   Wait(base::TimeDelta::FromSeconds(3));
 
   SetTestData(FILE_PATH_LITERAL("fail_reconnect_session.json"));
-  OpenTestPage(FILE_PATH_LITERAL("fail_reconnect_session.html"));
-  content::WebContents* new_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
+  OpenTestPageInNewTab(FILE_PATH_LITERAL("fail_reconnect_session.html"));
+  WebContents* new_web_contents = GetActiveWebContents();
   ASSERT_TRUE(new_web_contents);
   ExecuteJavaScriptAPI(
       new_web_contents,
       base::StringPrintf("checkReconnectSessionFails('%s');",
                          session_id.c_str()));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
                        MANUAL_Fail_StartCancelled) {
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  ExecuteJavaScriptAPI(web_contents, kWaitDeviceScript);
-  content::TestNavigationObserver test_navigation_observer(web_contents, 1);
-  StartSession(web_contents);
-
-  MediaRouterDialogControllerImpl* controller =
-      MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
-  EXPECT_TRUE(controller->IsShowingMediaRouterDialog());
-  controller->HideMediaRouterDialog();
+  WebContents* web_contents = StartSessionWithTestPage(true);
+  HideMediaRouterDialog(web_contents, false);
   CheckStartFailed(web_contents, "NotAllowedError", "Dialog closed.");
 }
 
 IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
                        MANUAL_Fail_StartCancelledNoSinks) {
   SetTestData(FILE_PATH_LITERAL("no_sinks.json"));
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  content::TestNavigationObserver test_navigation_observer(web_contents, 1);
-  StartSession(web_contents);
-
-  MediaRouterDialogControllerImpl* controller =
-      MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
-  EXPECT_TRUE(controller->IsShowingMediaRouterDialog());
-  controller->HideMediaRouterDialog();
+  WebContents* web_contents = StartSessionWithTestPage(false);
+  HideMediaRouterDialog(web_contents, false);
   CheckStartFailed(web_contents, "NotFoundError", "No screens found.");
 }
 
 IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationBrowserTest,
                        MANUAL_Fail_StartCancelledNoSupportedSinks) {
   SetTestData(FILE_PATH_LITERAL("no_supported_sinks.json"));
-  OpenTestPage(FILE_PATH_LITERAL("basic_test.html"));
-  content::WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(web_contents);
-  content::TestNavigationObserver test_navigation_observer(web_contents, 1);
-  StartSession(web_contents);
-
-  MediaRouterDialogControllerImpl* controller =
-      MediaRouterDialogControllerImpl::GetOrCreateForWebContents(web_contents);
-  EXPECT_TRUE(controller->IsShowingMediaRouterDialog());
-  WaitUntilSinkDiscoveredOnUI();
-  controller->HideMediaRouterDialog();
+  WebContents* web_contents = StartSessionWithTestPage(false);
+  HideMediaRouterDialog(web_contents, true);
   CheckStartFailed(web_contents, "NotFoundError", "No screens found.");
 }
 
+void MediaRouterIntegrationIncognitoBrowserTest::InstallAndEnableMRExtension() {
+  const extensions::Extension* extension =
+      LoadExtensionIncognito(extension_unpacked_);
+  extension_id_ = extension->id();
+}
+
+void MediaRouterIntegrationIncognitoBrowserTest::UninstallMRExtension() {
+  if (!extension_id_.empty()) {
+    UninstallExtension(extension_id_);
+  }
+}
+
+Browser* MediaRouterIntegrationIncognitoBrowserTest::browser() {
+  if (!browser_)
+    browser_ = CreateIncognitoBrowser();
+  return browser_;
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationIncognitoBrowserTest,
+                       MANUAL_Basic) {
+  RunBasicTest();
+}
+
+IN_PROC_BROWSER_TEST_F(MediaRouterIntegrationIncognitoBrowserTest,
+                       MANUAL_ReconnectSession) {
+  RunReconnectSessionTest();
+}
+
 }  // namespace media_router