chrome/test/media_router/media_router_e2e_browsertest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/test/media_router/media_router_e2e_browsertest.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/stl_util.h"
   9 #include "chrome/browser/media/router/media_router.h"
  10 #include "chrome/browser/media/router/media_router_mojo_impl.h"
  11 #include "chrome/browser/media/router/media_router_mojo_impl_factory.h"
  12 #include "chrome/browser/media/router/media_source.h"
  13 #include "chrome/browser/media/router/media_source_helper.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/sessions/session_tab_helper.h"
  16 #include "chrome/browser/ui/browser_finder.h"
  17 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  18 #include "chrome/test/base/ui_test_utils.h"
  19 #include "content/public/test/test_utils.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "url/gurl.h"
  22
  23 // Use the following command to run e2e browser tests:
  24 // ./out/Debug/browser_tests --user-data-dir=<empty user data dir>
  25 //   --extension-unpacked=<mr extension dir>
  26 //   --receiver=<chromecast device name>
  27 //   --enable-pixel-output-in-tests --run-manual
  28 //   --gtest_filter=MediaRouterE2EBrowserTest.<test case name>
  29 //   --enable-logging=stderr
  30 //   --whitelisted-extension-id=enhhojjnijigcajfphajepfemndkmdlo
  31 //   --ui-test-action-timeout=200000
  32 //   --enable-media-router
  33
  34 namespace {
  35 // Command line argument to specify receiver,
  36 const char kReceiver[] = "receiver";
  37 // URL to launch Castv2Player_Staging app on Chromecast
  38 const char kCastAppPresentationUrl[] =
  39     "https://google.com/cast#__castAppId__=BE6E4473";
  40 }  // namespace
  41
  42 namespace media_router {
  43
  44 MediaRouterE2EBrowserTest::MediaRouterE2EBrowserTest()
  45     : media_router_(nullptr) {
  46 }
  47
  48 MediaRouterE2EBrowserTest::~MediaRouterE2EBrowserTest() {
  49 }
  50
  51 void MediaRouterE2EBrowserTest::SetUpOnMainThread() {
  52   MediaRouterBaseBrowserTest::SetUpOnMainThread();
  53   media_router_ =
  54       MediaRouterMojoImplFactory::GetApiForBrowserContext(browser()->profile());
  55   DCHECK(media_router_);
  56 }
  57
  58 void MediaRouterE2EBrowserTest::TearDownOnMainThread() {
  59   MediaRouterBaseBrowserTest::TearDownOnMainThread();
  60   media_router_ = nullptr;
  61 }
  62
  63 void MediaRouterE2EBrowserTest::OnRouteResponseReceived(
  64     scoped_ptr<MediaRoute> route,
  65     const std::string& error) {
  66   ASSERT_TRUE(route.get());
  67   route_id_ = route->media_route_id();
  68 }
  69
  70 void MediaRouterE2EBrowserTest::CreateMediaRoute(const MediaSource& source,
  71                                                  const GURL& origin,
  72                                                  int tab_id) {
  73   DCHECK(media_router_);
  74   observer_.reset(new TestMediaSinksObserver(media_router_, source));
  75
  76   DVLOG(1) << "Receiver name: " << receiver_;
  77   // Wait for MediaSinks compatible with |source| to be discovered.
  78   ConditionalWait(base::TimeDelta::FromSeconds(30),
  79                   base::TimeDelta::FromSeconds(1),
  80                   base::Bind(&MediaRouterE2EBrowserTest::IsSinkDiscovered,
  81                              base::Unretained(this)));
  82
  83   const auto& sink_map = observer_->sink_map;
  84   const auto it = sink_map.find(receiver_);
  85   const MediaSink& sink = it->second;
  86
  87   // The callback will set route_id_ when invoked.
  88   media_router_->CreateRoute(
  89       source.id(), sink.id(), origin, tab_id,
  90       base::Bind(&MediaRouterE2EBrowserTest::OnRouteResponseReceived,
  91                  base::Unretained(this)));
  92
  93   // Wait for the route request to be fulfilled (and route to be started).
  94   ConditionalWait(base::TimeDelta::FromSeconds(30),
  95                   base::TimeDelta::FromSeconds(1),
  96                   base::Bind(&MediaRouterE2EBrowserTest::IsRouteCreated,
  97                              base::Unretained(this)));
  98 }
  99
 100 void MediaRouterE2EBrowserTest::StopMediaRoute() {
 101   ASSERT_FALSE(route_id_.empty());
 102
 103   media_router_->CloseRoute(route_id_);
 104
 105   observer_.reset();
 106   route_id_.clear();
 107 }
 108
 109 void MediaRouterE2EBrowserTest::ParseCommandLine() {
 110   MediaRouterBaseBrowserTest::ParseCommandLine();
 111   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 112
 113   receiver_ = command_line->GetSwitchValueASCII(kReceiver);
 114   ASSERT_FALSE(receiver_.empty());
 115 }
 116
 117 bool MediaRouterE2EBrowserTest::IsSinkDiscovered() const {
 118   return ContainsKey(observer_->sink_map, receiver_);
 119 }
 120
 121 bool MediaRouterE2EBrowserTest::IsRouteCreated() const {
 122   return !route_id_.empty();
 123 }
 124
 125 // Test cases
 126
 127 IN_PROC_BROWSER_TEST_F(MediaRouterE2EBrowserTest, MANUAL_TabMirroring) {
 128   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 129   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 130
 131   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
 132       browser(), GURL("about:blank"), 1);
 133   int tab_id = SessionTabHelper::IdForTab(
 134       browser()->tab_strip_model()->GetActiveWebContents());
 135
 136   // Wait for 30 seconds to make sure the route is stable.
 137   CreateMediaRoute(MediaSourceForTab(tab_id), GURL("http://origin/"), tab_id);
 138   Wait(base::TimeDelta::FromSeconds(30));
 139
 140   // Wait for 10 seconds to make sure route has been stopped.
 141   StopMediaRoute();
 142   Wait(base::TimeDelta::FromSeconds(10));
 143 }
 144
 145 IN_PROC_BROWSER_TEST_F(MediaRouterE2EBrowserTest, MANUAL_CastApp) {
 146   // Wait for 30 seconds to make sure the route is stable.
 147   CreateMediaRoute(MediaSourceForPresentationUrl(kCastAppPresentationUrl),
 148                    GURL("http://origin/"), kInvalidTabId);
 149   Wait(base::TimeDelta::FromSeconds(30));
 150
 151   // Wait for 10 seconds to make sure route has been stopped.
 152   StopMediaRoute();
 153   Wait(base::TimeDelta::FromSeconds(10));
 154 }
 155
 156 }  // namespace media_router