Show Cast sessions in Global Media Controls

Add CastMediaNotificationProvider, which is responsible for providing
MediaToolbarButtonController with notification items for Cast, which are
represented by the CastMediaNotificationItem class.

MediaToolbarButtonController::MediaRoutesObserver has been merged into
CastMediaNotificationProvider.

Bug: 987479

Change-Id: I258674c6d5541a581e79f4d91d2568c239931be8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1888533Reviewed-by: Tommy Steimel <steimel@chromium.org>
Commit-Queue: Takumi Fujimoto <takumif@chromium.org>
Cr-Commit-Position: refs/heads/master@{#712630}

chrome/browser/ui/BUILD.gn

@@ -932,6 +932,10 @@ jumbo_static_library("ui") {
       "global_error/global_error_service.h",
       "global_error/global_error_service_factory.cc",
       "global_error/global_error_service_factory.h",
+      "global_media_controls/cast_media_notification_item.cc",
+      "global_media_controls/cast_media_notification_item.h",
+      "global_media_controls/cast_media_notification_provider.cc",
+      "global_media_controls/cast_media_notification_provider.h",
       "global_media_controls/media_dialog_delegate.cc",
       "global_media_controls/media_dialog_delegate.h",
       "global_media_controls/media_notification_container_impl.h",

chrome/browser/ui/global_media_controls/cast_media_notification_item.cc

+// Copyright 2019 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/browser/ui/global_media_controls/cast_media_notification_item.h"
+
+#include "services/media_session/public/mojom/media_session.mojom.h"
+
+namespace {
+
+media_session::mojom::MediaSessionInfoPtr CreateSessionInfo() {
+  auto session_info = media_session::mojom::MediaSessionInfo::New();
+  session_info->state =
+      media_session::mojom::MediaSessionInfo::SessionState::kSuspended;
+  session_info->force_duck = false;
+  session_info->playback_state =
+      media_session::mojom::MediaPlaybackState::kPaused;
+  session_info->is_controllable = true;
+  session_info->prefer_stop_for_gain_focus_loss = false;
+  return session_info;
+}
+
+}  // namespace
+
+CastMediaNotificationItem::CastMediaNotificationItem(
+    media_message_center::MediaNotificationController* notification_controller)
+    : session_info_(CreateSessionInfo()) {}
+
+CastMediaNotificationItem::~CastMediaNotificationItem() = default;
+
+void CastMediaNotificationItem::SetView(
+    media_message_center::MediaNotificationView* view) {
+  view_ = view;
+}
+
+void CastMediaNotificationItem::OnMediaSessionActionButtonPressed(
+    media_session::mojom::MediaSessionAction action) {
+  // TODO(crbug.com/987479): Forward the action to the Cast receiver.
+}
+
+void CastMediaNotificationItem::Dismiss() {
+  // TODO(crbug.com/987479): Hide the notification.
+}
+
+void CastMediaNotificationItem::OnMediaStatusUpdated(
+    media_router::mojom::MediaStatusPtr status) {
+  // TODO(crbug.com/987479): Update |session_info_| with the data from |status|,
+  // and notify |view_|.
+}

chrome/browser/ui/global_media_controls/cast_media_notification_item.h

+// Copyright 2019 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.
+
+#ifndef CHROME_BROWSER_UI_GLOBAL_MEDIA_CONTROLS_CAST_MEDIA_NOTIFICATION_ITEM_H_
+#define CHROME_BROWSER_UI_GLOBAL_MEDIA_CONTROLS_CAST_MEDIA_NOTIFICATION_ITEM_H_
+
+#include "base/memory/weak_ptr.h"
+#include "chrome/common/media_router/media_route.h"
+#include "chrome/common/media_router/mojom/media_status.mojom.h"
+#include "components/media_message_center/media_notification_item.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "services/media_session/public/cpp/media_metadata.h"
+
+namespace media_message_center {
+class MediaNotificationController;
+}  // namespace media_message_center
+
+// Represents the media notification shown in the Global Media Controls dialog
+// for a Cast session. It is responsible for showing/hiding a
+// MediaNotificationView.
+class CastMediaNotificationItem
+    : public media_message_center::MediaNotificationItem,
+      public media_router::mojom::MediaStatusObserver {
+ public:
+  CastMediaNotificationItem(media_message_center::MediaNotificationController*
+                                notification_controller);
+  CastMediaNotificationItem(const CastMediaNotificationItem&) = delete;
+  CastMediaNotificationItem& operator=(const CastMediaNotificationItem&) =
+      delete;
+  ~CastMediaNotificationItem() override;
+
+  // media_message_center::MediaNotificationItem:
+  void SetView(media_message_center::MediaNotificationView* view) override;
+  void OnMediaSessionActionButtonPressed(
+      media_session::mojom::MediaSessionAction action) override;
+  void Dismiss() override;
+
+  // media_router::mojom::MediaStatusObserver:
+  void OnMediaStatusUpdated(
+      media_router::mojom::MediaStatusPtr status) override;
+
+  base::WeakPtr<media_message_center::MediaNotificationItem> GetWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
+ private:
+  media_message_center::MediaNotificationView* view_ = nullptr;
+  media_session::mojom::MediaSessionInfoPtr session_info_;
+  base::WeakPtrFactory<CastMediaNotificationItem> weak_ptr_factory_{this};
+};
+
+#endif  // CHROME_BROWSER_UI_GLOBAL_MEDIA_CONTROLS_CAST_MEDIA_NOTIFICATION_ITEM_H_

chrome/browser/ui/global_media_controls/cast_media_notification_provider.cc

+// Copyright 2019 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/browser/ui/global_media_controls/cast_media_notification_provider.h"
+
+#include "chrome/browser/media/router/media_router.h"
+#include "chrome/browser/media/router/media_router_factory.h"
+#include "chrome/browser/profiles/profile.h"
+
+CastMediaNotificationProvider::CastMediaNotificationProvider(
+    Profile* profile,
+    media_message_center::MediaNotificationController* notification_controller,
+    base::RepeatingClosure items_changed_callback)
+    : CastMediaNotificationProvider(
+          media_router::MediaRouterFactory::GetApiForBrowserContext(profile),
+          notification_controller,
+          std::move(items_changed_callback)) {}
+
+CastMediaNotificationProvider::CastMediaNotificationProvider(
+    media_router::MediaRouter* router,
+    media_message_center::MediaNotificationController* notification_controller,
+    base::RepeatingClosure items_changed_callback)
+    : media_router::MediaRoutesObserver(router),
+      notification_controller_(notification_controller),
+      items_changed_callback_(std::move(items_changed_callback)) {}
+
+CastMediaNotificationProvider::~CastMediaNotificationProvider() = default;
+
+void CastMediaNotificationProvider::OnRoutesUpdated(
+    const std::vector<media_router::MediaRoute>& routes,
+    const std::vector<media_router::MediaRoute::Id>& joinable_route_ids) {
+  const bool had_items = HasItems();
+
+  base::EraseIf(items_, [&routes](const auto& item) {
+    return std::find_if(routes.begin(), routes.end(),
+                        [&item](const media_router::MediaRoute& route) {
+                          return item.first == route.media_route_id();
+                        }) == routes.end();
+  });
+
+  for (const auto& route : routes) {
+    if (!route.for_display() ||
+        route.controller_type() !=
+            media_router::RouteControllerType::kGeneric) {
+      continue;
+    }
+    if (std::find_if(items_.begin(), items_.end(), [&route](const auto& item) {
+          return item.first == route.media_route_id();
+        }) == items_.end()) {
+      items_.emplace(std::piecewise_construct,
+                     std::forward_as_tuple(route.media_route_id()),
+                     std::forward_as_tuple(notification_controller_));
+      // TODO(crbug.com/987479): Connect the CastMediaNotificationItem to a
+      // controller through MediaRouter::GetMediaController().
+    }
+  }
+  if (HasItems() != had_items)
+    items_changed_callback_.Run();
+}
+
+base::WeakPtr<media_message_center::MediaNotificationItem>
+CastMediaNotificationProvider::GetNotificationItem(const std::string& id) {
+  const auto item_it = items_.find(id);
+  if (item_it == items_.end())
+    return nullptr;
+  return item_it->second.GetWeakPtr();
+}
+
+bool CastMediaNotificationProvider::HasItems() const {
+  return !items_.empty();
+}

chrome/browser/ui/global_media_controls/cast_media_notification_provider.h

+// Copyright 2019 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.
+
+#ifndef CHROME_BROWSER_UI_GLOBAL_MEDIA_CONTROLS_CAST_MEDIA_NOTIFICATION_PROVIDER_H_
+#define CHROME_BROWSER_UI_GLOBAL_MEDIA_CONTROLS_CAST_MEDIA_NOTIFICATION_PROVIDER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/media/router/media_routes_observer.h"
+#include "chrome/browser/ui/global_media_controls/cast_media_notification_item.h"
+
+class Profile;
+
+namespace media_message_center {
+class MediaNotificationController;
+}  // namespace media_message_center
+
+namespace media_router {
+class MediaRouter;
+}  // namespace media_router
+
+// Manages media notifications shown in the Global Media Controls dialog for
+// active Cast sessions.
+class CastMediaNotificationProvider : public media_router::MediaRoutesObserver {
+ public:
+  CastMediaNotificationProvider(
+      Profile* profile,
+      media_message_center::MediaNotificationController*
+          notification_controller,
+      base::RepeatingClosure items_changed_callback);
+  CastMediaNotificationProvider(
+      media_router::MediaRouter* router,
+      media_message_center::MediaNotificationController*
+          notification_controller,
+      base::RepeatingClosure items_changed_callback_);
+  CastMediaNotificationProvider(const CastMediaNotificationProvider&) = delete;
+  CastMediaNotificationProvider& operator=(
+      const CastMediaNotificationProvider&) = delete;
+  ~CastMediaNotificationProvider() override;
+
+  // media_router::MediaRoutesObserver:
+  void OnRoutesUpdated(const std::vector<media_router::MediaRoute>& routes,
+                       const std::vector<media_router::MediaRoute::Id>&
+                           joinable_route_ids) override;
+
+  base::WeakPtr<media_message_center::MediaNotificationItem>
+  GetNotificationItem(const std::string& id);
+
+  virtual bool HasItems() const;
+
+ private:
+  media_message_center::MediaNotificationController* const
+      notification_controller_;
+
+  // Maps from notification item IDs to items.
+  std::map<std::string, CastMediaNotificationItem> items_;
+
+  // Called when the number of items changes from zero to positive or vice
+  // versa.
+  base::RepeatingClosure items_changed_callback_;
+};
+
+#endif  // CHROME_BROWSER_UI_GLOBAL_MEDIA_CONTROLS_CAST_MEDIA_NOTIFICATION_PROVIDER_H_

chrome/browser/ui/global_media_controls/cast_media_notification_provider_unittest.cc

+// Copyright 2019 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/browser/ui/global_media_controls/cast_media_notification_provider.h"
+
+#include "chrome/browser/media/router/test/mock_media_router.h"
+#include "components/media_message_center/media_notification_controller.h"
+#include "content/public/test/browser_task_environment.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class MockMediaNotificationController
+    : public media_message_center::MediaNotificationController {
+ public:
+  MockMediaNotificationController() = default;
+  ~MockMediaNotificationController() = default;
+
+  MOCK_METHOD1(ShowNotification, void(const std::string& id));
+  MOCK_METHOD1(HideNotification, void(const std::string& id));
+  MOCK_METHOD1(RemoveItem, void(const std::string& id));
+  scoped_refptr<base::SequencedTaskRunner> GetTaskRunner() const override {
+    return nullptr;
+  }
+  MOCK_METHOD1(LogMediaSessionActionButtonPressed, void(const std::string& id));
+};
+
+class MockClosure {
+ public:
+  MOCK_METHOD0(Run, void());
+};
+
+}  // namespace
+
+class CastMediaNotificationProviderTest : public testing::Test {
+ public:
+  void SetUp() override {
+    notification_provider_ = std::make_unique<CastMediaNotificationProvider>(
+        &router_, &notification_controller_,
+        base::BindRepeating(&MockClosure::Run,
+                            base::Unretained(&items_changed_callback_)));
+  }
+
+  void TearDown() override { notification_provider_.reset(); }
+
+ protected:
+  content::BrowserTaskEnvironment task_environment_;
+  std::unique_ptr<CastMediaNotificationProvider> notification_provider_;
+  MockMediaNotificationController notification_controller_;
+  media_router::MockMediaRouter router_;
+  MockClosure items_changed_callback_;
+};
+
+TEST_F(CastMediaNotificationProviderTest, AddAndRemoveRoute) {
+  const std::string route_id = "route-id-1";
+  media_router::MediaRoute route(route_id,
+                                 media_router::MediaSource("source_id"),
+                                 "sink_id", "description", true, true);
+  route.set_controller_type(media_router::RouteControllerType::kGeneric);
+
+  EXPECT_CALL(items_changed_callback_, Run());
+  notification_provider_->OnRoutesUpdated({route}, {});
+  testing::Mock::VerifyAndClearExpectations(&items_changed_callback_);
+  EXPECT_TRUE(notification_provider_->HasItems());
+  EXPECT_NE(nullptr, notification_provider_->GetNotificationItem(route_id));
+
+  EXPECT_CALL(items_changed_callback_, Run());
+  notification_provider_->OnRoutesUpdated({}, {});
+  testing::Mock::VerifyAndClearExpectations(&items_changed_callback_);
+  EXPECT_FALSE(notification_provider_->HasItems());
+}

chrome/browser/ui/global_media_controls/media_toolbar_button_controller.cc

@@ -5,6 +5,8 @@
 #include "chrome/browser/ui/global_media_controls/media_toolbar_button_controller.h"
 
 #include "base/metrics/histogram_functions.h"
+#include "chrome/browser/media/router/media_router_feature.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
@@ -16,6 +18,7 @@
 #include "components/media_message_center/media_notification_util.h"
 #include "components/media_message_center/media_session_notification_item.h"
 #include "content/public/browser/media_session.h"
+#include "media/base/media_switches.h"
 #include "services/media_session/public/mojom/constants.mojom.h"
 #include "services/media_session/public/mojom/media_session.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -65,45 +68,22 @@ void MediaToolbarButtonController::Session::WebContentsDestroyed() {
   owner_->RemoveItem(id_);
 }
 
-MediaToolbarButtonController::MediaRoutesObserver::MediaRoutesObserver(
-    media_router::MediaRouter* router,
-    base::RepeatingClosure routes_changed_callback)
-    : media_router::MediaRoutesObserver(router),
-      routes_changed_callback_(std::move(routes_changed_callback)) {}
-
-MediaToolbarButtonController::MediaRoutesObserver::~MediaRoutesObserver() =
-    default;
-
-void MediaToolbarButtonController::MediaRoutesObserver::OnRoutesUpdated(
-    const std::vector<media_router::MediaRoute>& routes,
-    const std::vector<media_router::MediaRoute::Id>& joinable_route_ids) {
-  bool has_routes_now =
-      std::find_if(routes.begin(), routes.end(),
-                   [](const media_router::MediaRoute& route) {
-                     return route.for_display() &&
-                            route.controller_type() ==
-                                media_router::RouteControllerType::kGeneric;
-                   }) != routes.end();
-  if (has_routes_ != has_routes_now) {
-    has_routes_ = has_routes_now;
-    routes_changed_callback_.Run();
-  }
-}
-
 MediaToolbarButtonController::MediaToolbarButtonController(
     const base::UnguessableToken& source_id,
     service_manager::Connector* connector,
     MediaToolbarButtonControllerDelegate* delegate,
-    media_router::MediaRouter* media_router)
+    Profile* profile)
     : connector_(connector), delegate_(delegate) {
   DCHECK(delegate_);
 
-  if (media_router) {
-    media_routes_observer_ = std::make_unique<MediaRoutesObserver>(
-        media_router,
-        base::BindRepeating(
-            &MediaToolbarButtonController::UpdateToolbarButtonState,
-            base::Unretained(this)));
+  if (base::FeatureList::IsEnabled(media::kGlobalMediaControlsForCast) &&
+      media_router::MediaRouterEnabled(profile)) {
+    cast_notification_provider_ =
+        std::make_unique<CastMediaNotificationProvider>(
+            profile, this,
+            base::BindRepeating(
+                &MediaToolbarButtonController::UpdateToolbarButtonState,
+                base::Unretained(this)));
   }
 
   // |connector| can be null in tests.
@@ -195,12 +175,8 @@ void MediaToolbarButtonController::ShowNotification(const std::string& id) {
   if (!dialog_delegate_)
     return;
 
-  base::WeakPtr<media_message_center::MediaNotificationItem> item;
-
-  auto it = sessions_.find(id);
-  if (it != sessions_.end())
-    item = it->second.item()->GetWeakPtr();
-
+  base::WeakPtr<media_message_center::MediaNotificationItem> item =
+      GetNotificationItem(id);
   MediaNotificationContainerImpl* container =
       dialog_delegate_->ShowMediaSession(id, item);
 
@@ -290,12 +266,8 @@ void MediaToolbarButtonController::SetDialogDelegate(
     return;
 
   for (const std::string& id : active_controllable_session_ids_) {
-    base::WeakPtr<media_message_center::MediaNotificationItem> item;
-
-    auto it = sessions_.find(id);
-    if (it != sessions_.end())
-      item = it->second.item()->GetWeakPtr();
-
+    base::WeakPtr<media_message_center::MediaNotificationItem> item =
+        GetNotificationItem(id);
     MediaNotificationContainerImpl* container =
         dialog_delegate_->ShowMediaSession(id, item);
 
@@ -318,7 +290,8 @@ void MediaToolbarButtonController::OnReceivedAudioFocusRequests(
 
 void MediaToolbarButtonController::UpdateToolbarButtonState() {
   if (!active_controllable_session_ids_.empty() ||
-      (media_routes_observer_ && media_routes_observer_->has_routes())) {
+      (cast_notification_provider_ &&
+       cast_notification_provider_->HasItems())) {
     if (delegate_display_state_ != DisplayState::kShown) {
       delegate_->Enable();
       delegate_->Show();
@@ -340,3 +313,14 @@ void MediaToolbarButtonController::UpdateToolbarButtonState() {
     delegate_display_state_ = DisplayState::kDisabled;
   }
 }
+
+base::WeakPtr<media_message_center::MediaNotificationItem>
+MediaToolbarButtonController::GetNotificationItem(const std::string& id) {
+  auto it = sessions_.find(id);
+  if (it != sessions_.end()) {
+    return it->second.item()->GetWeakPtr();
+  } else if (cast_notification_provider_) {
+    return cast_notification_provider_->GetNotificationItem(id);
+  }
+  return nullptr;
+}

chrome/browser/ui/global_media_controls/media_toolbar_button_controller.h

@@ -12,6 +12,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
+#include "chrome/browser/ui/global_media_controls/cast_media_notification_provider.h"
 #include "chrome/browser/ui/global_media_controls/media_notification_container_observer.h"
 #include "components/media_message_center/media_notification_controller.h"
 #include "content/public/browser/web_contents_observer.h"
@@ -28,10 +29,6 @@ namespace media_message_center {
 class MediaSessionNotificationItem;
 }  // namespace media_message_center
 
-namespace media_router {
-class MediaRouter;
-}  // namespace media_router
-
 namespace service_manager {
 class Connector;
 }  // namespace service_manager
@@ -51,7 +48,7 @@ class MediaToolbarButtonController
   MediaToolbarButtonController(const base::UnguessableToken& source_id,
                                service_manager::Connector* connector,
                                MediaToolbarButtonControllerDelegate* delegate,
-                               media_router::MediaRouter* media_router);
+                               Profile* profile);
   ~MediaToolbarButtonController() override;
 
   // media_session::mojom::AudioFocusObserver implementation.
@@ -110,34 +107,14 @@ class MediaToolbarButtonController
     std::unique_ptr<media_message_center::MediaSessionNotificationItem> item_;
   };
 
-  class MediaRoutesObserver : public media_router::MediaRoutesObserver {
-   public:
-    MediaRoutesObserver(media_router::MediaRouter* router,
-                        base::RepeatingClosure routes_changed_callback);
-    MediaRoutesObserver(const MediaRoutesObserver&) = delete;
-    MediaRoutesObserver& operator=(const MediaRoutesObserver&) = delete;
-
-    ~MediaRoutesObserver() override;
-
-    // media_router::MediaRoutesObserver implementation.
-    void OnRoutesUpdated(const std::vector<media_router::MediaRoute>& routes,
-                         const std::vector<media_router::MediaRoute::Id>&
-                             joinable_route_ids) override;
-
-    bool has_routes() const { return has_routes_; }
-
-   private:
-    bool has_routes_ = false;
-
-    // Called when the presence of media routes has changed.
-    base::RepeatingClosure routes_changed_callback_;
-  };
-
   void OnReceivedAudioFocusRequests(
       std::vector<media_session::mojom::AudioFocusRequestStatePtr> sessions);
 
   void UpdateToolbarButtonState();
 
+  base::WeakPtr<media_message_center::MediaNotificationItem>
+  GetNotificationItem(const std::string& id);
+
   service_manager::Connector* const connector_;
   MediaToolbarButtonControllerDelegate* const delegate_;
   MediaDialogDelegate* dialog_delegate_ = nullptr;
@@ -169,8 +146,7 @@ class MediaToolbarButtonController
   mojo::Receiver<media_session::mojom::AudioFocusObserver>
       audio_focus_observer_receiver_{this};
 
-  // Observes for active Cast sessions that can be controlled.
-  std::unique_ptr<MediaRoutesObserver> media_routes_observer_;
+  std::unique_ptr<CastMediaNotificationProvider> cast_notification_provider_;
 
   base::WeakPtrFactory<MediaToolbarButtonController> weak_ptr_factory_{this};
 

chrome/browser/ui/global_media_controls/media_toolbar_button_controller_unittest.cc

@@ -8,14 +8,19 @@
 
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/metrics/histogram_tester.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/unguessable_token.h"
+#include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/test/mock_media_router.h"
+#include "chrome/browser/ui/global_media_controls/cast_media_notification_provider.h"
 #include "chrome/browser/ui/global_media_controls/media_dialog_delegate.h"
 #include "chrome/browser/ui/global_media_controls/media_toolbar_button_controller_delegate.h"
+#include "chrome/test/base/testing_profile.h"
 #include "components/media_message_center/media_notification_item.h"
 #include "components/media_message_center/media_notification_util.h"
 #include "components/media_message_center/media_session_notification_item.h"
 #include "content/public/test/browser_task_environment.h"
+#include "media/base/media_switches.h"
 #include "services/media_session/public/mojom/audio_focus.mojom.h"
 #include "services/media_session/public/mojom/media_session.mojom.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -85,10 +90,14 @@ class MediaToolbarButtonControllerTest : public testing::Test {
   ~MediaToolbarButtonControllerTest() override = default;
 
   void SetUp() override {
+    media_router::MediaRouterFactory::GetInstance()->SetTestingFactory(
+        &profile_, base::BindRepeating(&media_router::MockMediaRouter::Create));
     controller_ = std::make_unique<MediaToolbarButtonController>(
-        base::UnguessableToken::Create(), nullptr, &delegate_, &media_router_);
+        base::UnguessableToken::Create(), nullptr, &delegate_, &profile_);
   }
 
+  void TearDown() override { controller_.reset(); }
+
  protected:
   void AdvanceClockMilliseconds(int milliseconds) {
     task_environment_.FastForwardBy(
@@ -198,7 +207,7 @@ class MediaToolbarButtonControllerTest : public testing::Test {
 
   void SimulateMediaRoutesUpdate(
       const std::vector<media_router::MediaRoute>& routes) {
-    controller_->media_routes_observer_->OnRoutesUpdated(routes, {});
+    controller_->cast_notification_provider_->OnRoutesUpdated(routes, {});
   }
 
   MockMediaToolbarButtonControllerDelegate& delegate() { return delegate_; }
@@ -206,13 +215,27 @@ class MediaToolbarButtonControllerTest : public testing::Test {
  private:
   content::BrowserTaskEnvironment task_environment_;
   MockMediaToolbarButtonControllerDelegate delegate_;
-  media_router::MockMediaRouter media_router_;
   std::unique_ptr<MediaToolbarButtonController> controller_;
   base::HistogramTester histogram_tester_;
+  TestingProfile profile_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaToolbarButtonControllerTest);
 };
 
+// TODO(takumif): Remove this class once |kGlobalMediaControlsForCast| is
+// enabled by default.
+class MediaToolbarButtonControllerCastTest
+    : public MediaToolbarButtonControllerTest {
+ public:
+  void SetUp() override {
+    feature_list_.InitAndEnableFeature(media::kGlobalMediaControlsForCast);
+    MediaToolbarButtonControllerTest::SetUp();
+  }
+
+ private:
+  base::test::ScopedFeatureList feature_list_;
+};
+
 TEST_F(MediaToolbarButtonControllerTest, ShowControllableOnGainAndHideOnLoss) {
   // Simulate a new active, controllable media session.
   EXPECT_CALL(delegate(), Show());
@@ -428,7 +451,7 @@ TEST_F(MediaToolbarButtonControllerTest, DismissesMediaSession) {
   testing::Mock::VerifyAndClearExpectations(&delegate());
 }
 
-TEST_F(MediaToolbarButtonControllerTest, ShowButtonForCastSession) {
+TEST_F(MediaToolbarButtonControllerCastTest, ShowButtonForCastSession) {
   media_router::MediaRoute media_route("id",
                                        media_router::MediaSource("source_id"),
                                        "sink_id", "description", true, true);

chrome/browser/ui/views/global_media_controls/media_toolbar_button_view.cc

@@ -6,9 +6,6 @@
 
 #include "build/build_config.h"
 #include "chrome/app/vector_icons/vector_icons.h"
-#include "chrome/browser/media/router/media_router_factory.h"
-#include "chrome/browser/media/router/media_router_feature.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/global_media_controls/media_toolbar_button_controller.h"
@@ -28,30 +25,17 @@
 #include "ui/views/animation/ink_drop.h"
 #include "ui/views/controls/button/button_controller.h"
 
-namespace {
-
-media_router::MediaRouter* GetMediaRouter(Profile* profile) {
-  bool supports_cast =
-      base::FeatureList::IsEnabled(media::kGlobalMediaControlsForCast) &&
-      media_router::MediaRouterEnabled(profile);
-  if (!supports_cast)
-    return nullptr;
-  return media_router::MediaRouterFactory::GetApiForBrowserContext(profile);
-}
-
-}  // namespace
-
 MediaToolbarButtonView::MediaToolbarButtonView(
     const base::UnguessableToken& source_id,
     service_manager::Connector* connector,
     const Browser* browser)
     : ToolbarButton(this),
       connector_(connector),
-      controller_(std::make_unique<MediaToolbarButtonController>(
-          source_id,
-          connector_,
-          this,
-          GetMediaRouter(browser->profile()))),
+      controller_(
+          std::make_unique<MediaToolbarButtonController>(source_id,
+                                                         connector_,
+                                                         this,
+                                                         browser->profile())),
       browser_(browser) {
   GlobalMediaControlsInProductHelp* in_product_help =
       GlobalMediaControlsInProductHelpFactory::GetForProfile(

chrome/test/BUILD.gn

@@ -3848,6 +3848,7 @@ test("unit_tests") {
       "../browser/ui/extensions/extension_action_view_controller_unittest.cc",
       "../browser/ui/extensions/extension_message_bubble_bridge_unittest.cc",
       "../browser/ui/global_error/global_error_service_unittest.cc",
+      "../browser/ui/global_media_controls/cast_media_notification_provider_unittest.cc",
       "../browser/ui/global_media_controls/media_toolbar_button_controller_unittest.cc",
       "../browser/ui/hid/hid_chooser_controller_unittest.cc",
       "../browser/ui/in_product_help/active_tab_tracker_unittest.cc",