[Media Router] Enable the in-browser DIAL discovery feature by default.

The feature has been fully rolled out to stable for more than a month.
We should now be able to start doing feature cleanups.

Bug: 718154
Change-Id: I874c5517003badc37c8fc0e29ca6e96c9a4eaae1
Reviewed-on: https://chromium-review.googlesource.com/794715
Commit-Queue: Derek Cheng <imcheng@chromium.org>
Reviewed-by: mark a. foltz <mfoltz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521891}

chrome/browser/media/router/discovery/dial/dial_media_sink_service.h

@@ -50,20 +50,23 @@ class DialMediaSinkService {
   // |dial_sink_added_cb_sequence|: The sequence |dial_sink_added_cb| is
   // invoked on, or nullptr if the callback is null.
   // Both callbacks may be invoked after |this| is destroyed.
-  void Start(const OnSinksDiscoveredCallback& sink_discovery_cb,
+  // Marked virtual for tests.
+  virtual void Start(const OnSinksDiscoveredCallback& sink_discovery_cb,
                      const OnDialSinkAddedCallback& dial_sink_added_cb,
                      const scoped_refptr<base::SequencedTaskRunner>&
                          dial_sink_added_cb_sequence);
 
   // Forces the sink discovery callback to be invoked with the current list of
   // sinks. This method can only be called after |Start()|.
-  void ForceSinkDiscoveryCallback();
+  // Marked virtual for tests.
+  virtual void ForceSinkDiscoveryCallback();
 
   // Initiates discovery immediately in response to a user gesture
   // (i.e., opening the Media Router dialog). This method can only be called
   // after |Start()|.
   // TODO(imcheng): Rename to ManuallyInitiateDiscovery() or similar.
-  void OnUserGesture();
+  // Marked virtual for tests.
+  virtual void OnUserGesture();
 
  private:
   friend class DialMediaSinkServiceTest;

chrome/browser/media/router/discovery/mdns/cast_media_sink_service.h

@@ -53,16 +53,19 @@ class CastMediaSinkService : public DnsSdRegistry::DnsSdObserver {
   // |sink_discovery_cb|: Callback to invoke when the list of discovered sinks
   // has been updated. The callback is invoked on the UI thread and may be
   // invoked after |this| is destroyed.
-  void Start(const OnSinksDiscoveredCallback& sinks_discovered_cb);
+  // Marked virtual for tests.
+  virtual void Start(const OnSinksDiscoveredCallback& sinks_discovered_cb);
 
   // Forces the sink discovery callback to be invoked with the current list of
   // sinks.
-  void ForceSinkDiscoveryCallback();
+  // Marked virtual for tests.
+  virtual void ForceSinkDiscoveryCallback();
 
   // Initiates discovery immediately in response to a user gesture
   // (i.e., opening the Media Router dialog).
   // TODO(imcheng): Rename to ManuallyInitiateDiscovery() or similar.
-  void OnUserGesture();
+  // Marked virtual for tests.
+  virtual void OnUserGesture();
 
   // Marked virtual for tests.
   virtual std::unique_ptr<CastMediaSinkServiceImpl> CreateImpl(

chrome/browser/media/router/media_router_feature.cc

@@ -20,8 +20,8 @@ namespace media_router {
 
 #if !defined(OS_ANDROID)
 // Controls if browser side DIAL device discovery is enabled.
-const base::Feature kEnableDialLocalDiscovery{
-    "EnableDialLocalDiscovery", base::FEATURE_DISABLED_BY_DEFAULT};
+const base::Feature kEnableDialLocalDiscovery{"EnableDialLocalDiscovery",
+                                              base::FEATURE_ENABLED_BY_DEFAULT};
 
 // Controls if browser side Cast device discovery is enabled.
 const base::Feature kEnableCastDiscovery{"EnableCastDiscovery",

chrome/browser/media/router/media_router_feature.h

@@ -18,6 +18,7 @@ bool MediaRouterEnabled(content::BrowserContext* context);
 
 #if !defined(OS_ANDROID)
 
+extern const base::Feature kEnableDialLocalDiscovery;
 extern const base::Feature kEnableCastDiscovery;
 extern const base::Feature kEnableCastLocalMedia;
 

chrome/browser/media/router/mojo/media_route_controller.cc

@@ -36,11 +36,12 @@ void MediaRouteController::Observer::InvalidateController() {
 void MediaRouteController::Observer::OnControllerInvalidated() {}
 
 MediaRouteController::MediaRouteController(const MediaRoute::Id& route_id,
-                                           content::BrowserContext* context)
+                                           content::BrowserContext* context,
+                                           MediaRouter* router)
     : route_id_(route_id),
       request_manager_(
           EventPageRequestManagerFactory::GetApiForBrowserContext(context)),
-      media_router_(MediaRouterFactory::GetApiForBrowserContext(context)),
+      media_router_(router),
       binding_(this) {
   DCHECK(media_router_);
   DCHECK(request_manager_);
@@ -167,8 +168,9 @@ HangoutsMediaRouteController* HangoutsMediaRouteController::From(
 
 HangoutsMediaRouteController::HangoutsMediaRouteController(
     const MediaRoute::Id& route_id,
-    content::BrowserContext* context)
-    : MediaRouteController(route_id, context) {}
+    content::BrowserContext* context,
+    MediaRouter* router)
+    : MediaRouteController(route_id, context, router) {}
 
 HangoutsMediaRouteController::~HangoutsMediaRouteController() {}
 
@@ -217,8 +219,9 @@ MirroringMediaRouteController* MirroringMediaRouteController::From(
 
 MirroringMediaRouteController::MirroringMediaRouteController(
     const MediaRoute::Id& route_id,
-    content::BrowserContext* context)
-    : MediaRouteController(route_id, context),
+    content::BrowserContext* context,
+    MediaRouter* router)
+    : MediaRouteController(route_id, context, router),
       prefs_(Profile::FromBrowserContext(context)->GetPrefs()) {
   DCHECK(prefs_);
   media_remoting_enabled_ =

chrome/browser/media/router/mojo/media_route_controller.h

@@ -97,7 +97,8 @@ class MediaRouteController
   // |mojo_media_controller_|. |media_router_| will be notified when the
   // MediaRouteController is destroyed via DetachRouteController().
   MediaRouteController(const MediaRoute::Id& route_id,
-                       content::BrowserContext* context);
+                       content::BrowserContext* context,
+                       MediaRouter* router);
 
   // Initializes the Mojo interfaces/bindings in this MediaRouteController.
   // This should only be called when the Mojo interfaces/bindings are not bound.
@@ -203,7 +204,8 @@ class HangoutsMediaRouteController : public MediaRouteController {
   static HangoutsMediaRouteController* From(MediaRouteController* controller);
 
   HangoutsMediaRouteController(const MediaRoute::Id& route_id,
-                               content::BrowserContext* context);
+                               content::BrowserContext* context,
+                               MediaRouter* router);
 
   // MediaRouteController
   RouteControllerType GetType() const override;
@@ -235,7 +237,8 @@ class MirroringMediaRouteController : public MediaRouteController {
   static MirroringMediaRouteController* From(MediaRouteController* controller);
 
   MirroringMediaRouteController(const MediaRoute::Id& route_id,
-                                content::BrowserContext* context);
+                                content::BrowserContext* context,
+                                MediaRouter* router);
 
   // MediaRouteController
   RouteControllerType GetType() const override;

chrome/browser/media/router/mojo/media_route_controller_unittest.cc

@@ -49,7 +49,8 @@ class MediaRouteControllerTest : public ::testing::Test {
   void TearDown() override { observer_.reset(); }
 
   virtual scoped_refptr<MediaRouteController> CreateMediaRouteController() {
-    return base::MakeRefCounted<MediaRouteController>(kRouteId, &profile_);
+    return base::MakeRefCounted<MediaRouteController>(kRouteId, &profile_,
+                                                      &router_);
   }
 
   scoped_refptr<MediaRouteController> GetController() const {
@@ -67,7 +68,7 @@ class MediaRouteControllerTest : public ::testing::Test {
   content::TestBrowserThreadBundle test_thread_bundle_;
   TestingProfile profile_;
 
-  MockMediaRouter* router_ = nullptr;
+  MockMediaRouter router_;
   MockEventPageRequestManager* request_manager_ = nullptr;
   MockMediaController mock_media_controller_;
   mojom::MediaStatusObserverPtr mojo_media_status_observer_;
@@ -79,10 +80,6 @@ class MediaRouteControllerTest : public ::testing::Test {
         EventPageRequestManagerFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, &MockEventPageRequestManager::Create));
     request_manager_->set_mojo_connections_ready_for_test(true);
-
-    router_ = static_cast<MockMediaRouter*>(
-        MediaRouterFactory::GetInstance()->SetTestingFactoryAndUse(
-            &profile_, &MockMediaRouter::Create));
   }
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouteControllerTest);
@@ -99,8 +96,8 @@ class HangoutsMediaRouteControllerTest : public MediaRouteControllerTest {
   }
 
   scoped_refptr<MediaRouteController> CreateMediaRouteController() override {
-    return base::MakeRefCounted<HangoutsMediaRouteController>(kRouteId,
-                                                              &profile_);
+    return base::MakeRefCounted<HangoutsMediaRouteController>(
+        kRouteId, &profile_, &router_);
   }
 };
 
@@ -109,8 +106,8 @@ class MirroringMediaRouteControllerTest : public MediaRouteControllerTest {
   ~MirroringMediaRouteControllerTest() override {}
 
   scoped_refptr<MediaRouteController> CreateMediaRouteController() override {
-    return base::MakeRefCounted<MirroringMediaRouteController>(kRouteId,
-                                                               &profile_);
+    return base::MakeRefCounted<MirroringMediaRouteController>(
+        kRouteId, &profile_, &router_);
   }
 };
 
@@ -207,14 +204,14 @@ TEST_F(MediaRouteControllerTest, DestroyControllerOnNoObservers) {
   // Get rid of |observer_| and its reference to the controller.
   observer_.reset();
 
-  EXPECT_CALL(*router_, DetachRouteController(kRouteId, controller)).Times(0);
+  EXPECT_CALL(router_, DetachRouteController(kRouteId, controller)).Times(0);
   observer1.reset();
 
   // DetachRouteController() should be called when the controller no longer
   // has any observers.
-  EXPECT_CALL(*router_, DetachRouteController(kRouteId, controller)).Times(1);
+  EXPECT_CALL(router_, DetachRouteController(kRouteId, controller)).Times(1);
   observer2.reset();
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(router_));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&router_));
 }
 
 TEST_F(HangoutsMediaRouteControllerTest, HangoutsCommands) {

chrome/browser/media/router/mojo/media_router_desktop.cc

@@ -66,20 +66,27 @@ MediaRouterDesktop::GetProviderIdForPresentation(
   return MediaRouterMojoImpl::GetProviderIdForPresentation(presentation_id);
 }
 
-MediaRouterDesktop::MediaRouterDesktop(content::BrowserContext* context,
-                                       FirewallCheck check_firewall)
-    : MediaRouterMojoImpl(context),
-      weak_factory_(this) {
+MediaRouterDesktop::MediaRouterDesktop(content::BrowserContext* context)
+    : MediaRouterMojoImpl(context), weak_factory_(this) {
   InitializeMediaRouteProviders();
 #if defined(OS_WIN)
-  if (check_firewall == FirewallCheck::RUN) {
   CanFirewallUseLocalPorts(
       base::BindOnce(&MediaRouterDesktop::OnFirewallCheckComplete,
                      weak_factory_.GetWeakPtr()));
-  }
 #endif
 }
 
+MediaRouterDesktop::MediaRouterDesktop(
+    content::BrowserContext* context,
+    std::unique_ptr<DialMediaSinkService> dial_media_sink_service,
+    std::unique_ptr<CastMediaSinkService> cast_media_sink_service)
+    : MediaRouterMojoImpl(context),
+      dial_media_sink_service_(std::move(dial_media_sink_service)),
+      cast_media_sink_service_(std::move(cast_media_sink_service)),
+      weak_factory_(this) {
+  InitializeMediaRouteProviders();
+}
+
 void MediaRouterDesktop::RegisterMediaRouteProvider(
     MediaRouteProviderId provider_id,
     mojom::MediaRouteProviderPtr media_route_provider_ptr,

chrome/browser/media/router/mojo/media_router_desktop.h

@@ -57,16 +57,16 @@ class MediaRouterDesktop : public MediaRouterMojoImpl {
   friend class MediaRouterFactory;
   FRIEND_TEST_ALL_PREFIXES(MediaRouterDesktopTest, TestProvideSinks);
 
-  enum class FirewallCheck {
-    // Skips the firewall check for the benefit of unit tests so they do not
-    // have to depend on the system's firewall configuration.
-    SKIP_FOR_TESTING,
-    // Perform the firewall check (default).
-    RUN,
-  };
-
-  MediaRouterDesktop(content::BrowserContext* context,
-                     FirewallCheck check_firewall = FirewallCheck::RUN);
+  // This constructor performs a firewall check on Windows and is not suitable
+  // for use in unit tests; instead use the constructor below.
+  explicit MediaRouterDesktop(content::BrowserContext* context);
+
+  // Used by tests only. This constructor skips the firewall check so unit tests
+  // do not have to depend on the system's firewall configuration.
+  MediaRouterDesktop(
+      content::BrowserContext* context,
+      std::unique_ptr<DialMediaSinkService> dial_media_sink_service,
+      std::unique_ptr<CastMediaSinkService> cast_media_sink_service);
 
   // mojom::MediaRouter implementation.
   void RegisterMediaRouteProvider(

chrome/browser/media/router/mojo/media_router_desktop_unittest.cc

@@ -12,10 +12,14 @@
 #include "chrome/browser/media/router/mojo/media_router_desktop.h"
 
 #include "base/run_loop.h"
+#include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
+#include "chrome/browser/media/router/discovery/dial/dial_media_sink_service.h"
+#include "chrome/browser/media/router/discovery/mdns/cast_media_sink_service.h"
 #include "chrome/browser/media/router/event_page_request_manager.h"
 #include "chrome/browser/media/router/event_page_request_manager_factory.h"
 #include "chrome/browser/media/router/media_router_factory.h"
+#include "chrome/browser/media/router/media_router_feature.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
 #include "chrome/common/media_router/media_source_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -45,6 +49,31 @@ class NullMessageObserver : public RouteMessageObserver {
       final {}
 };
 
+class MockDialMediaSinkService : public DialMediaSinkService {
+ public:
+  explicit MockDialMediaSinkService(content::BrowserContext* context)
+      : DialMediaSinkService(context) {}
+  ~MockDialMediaSinkService() override {}
+
+  MOCK_METHOD3(Start,
+               void(const OnSinksDiscoveredCallback&,
+                    const OnDialSinkAddedCallback&,
+                    const scoped_refptr<base::SequencedTaskRunner>&));
+  MOCK_METHOD0(ForceSinkDiscoveryCallback, void());
+  MOCK_METHOD0(OnUserGesture, void());
+};
+
+class MockCastMediaSinkService : public CastMediaSinkService {
+ public:
+  explicit MockCastMediaSinkService(content::BrowserContext* context)
+      : CastMediaSinkService(context) {}
+  ~MockCastMediaSinkService() override {}
+
+  MOCK_METHOD1(Start, void(const OnSinksDiscoveredCallback&));
+  MOCK_METHOD0(ForceSinkDiscoveryCallback, void());
+  MOCK_METHOD0(OnUserGesture, void());
+};
+
 }  // namespace
 
 class MediaRouterDesktopTest : public MediaRouterMojoTest {
@@ -53,46 +82,76 @@ class MediaRouterDesktopTest : public MediaRouterMojoTest {
   ~MediaRouterDesktopTest() override {}
 
  protected:
-  MediaRouterMojoImpl* SetTestingFactoryAndUse() override {
-    return static_cast<MediaRouterMojoImpl*>(
-        MediaRouterFactory::GetInstance()->SetTestingFactoryAndUse(
-            profile(), &CreateMediaRouter));
+  void SetUp() override {
+    feature_list_.InitWithFeatures(
+        {kEnableDialLocalDiscovery, kEnableCastDiscovery}, {});
+    MediaRouterMojoTest::SetUp();
+  }
+  std::unique_ptr<MediaRouterMojoImpl> CreateMediaRouter() override {
+    auto dial_media_sink_service =
+        std::make_unique<MockDialMediaSinkService>(profile());
+    dial_media_sink_service_ = dial_media_sink_service.get();
+    EXPECT_CALL(*dial_media_sink_service_, ForceSinkDiscoveryCallback());
+
+    auto cast_media_sink_service =
+        std::make_unique<MockCastMediaSinkService>(profile());
+    cast_media_sink_service_ = cast_media_sink_service.get();
+    EXPECT_CALL(*cast_media_sink_service_, ForceSinkDiscoveryCallback());
+    return std::unique_ptr<MediaRouterDesktop>(
+        new MediaRouterDesktop(profile(), std::move(dial_media_sink_service),
+                               std::move(cast_media_sink_service)));
   }
 
- private:
-  static std::unique_ptr<KeyedService> CreateMediaRouter(
-      content::BrowserContext* context) {
-    return std::unique_ptr<KeyedService>(new MediaRouterDesktop(
-        context, MediaRouterDesktop::FirewallCheck::SKIP_FOR_TESTING));
+  MockDialMediaSinkService* dial_media_sink_service() const {
+    return dial_media_sink_service_;
+  }
+
+  MockCastMediaSinkService* cast_media_sink_service() const {
+    return cast_media_sink_service_;
   }
+
+ private:
+  base::test::ScopedFeatureList feature_list_;
+  MockDialMediaSinkService* dial_media_sink_service_ = nullptr;
+  MockCastMediaSinkService* cast_media_sink_service_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaRouterDesktopTest);
 };
 
 #if defined(OS_WIN)
 TEST_F(MediaRouterDesktopTest, EnableMdnsAfterEachRegister) {
   EXPECT_CALL(mock_extension_provider_, EnableMdnsDiscovery()).Times(0);
+  EXPECT_CALL(*dial_media_sink_service(), ForceSinkDiscoveryCallback());
+  EXPECT_CALL(*cast_media_sink_service(), ForceSinkDiscoveryCallback());
   RegisterExtensionProvider();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(mock_extension_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()));
   EXPECT_CALL(mock_extension_provider_, EnableMdnsDiscovery());
+  EXPECT_CALL(*dial_media_sink_service(), OnUserGesture());
+  EXPECT_CALL(*cast_media_sink_service(), OnUserGesture());
   router()->OnUserGesture();
   base::RunLoop().RunUntilIdle();
 
   // EnableMdnsDiscovery() is called on this RegisterExtensionProvider() because
   // we've already seen an mdns-enabling event.
   EXPECT_CALL(mock_extension_provider_, EnableMdnsDiscovery());
+  EXPECT_CALL(*dial_media_sink_service(), ForceSinkDiscoveryCallback());
+  EXPECT_CALL(*cast_media_sink_service(), ForceSinkDiscoveryCallback());
   RegisterExtensionProvider();
   base::RunLoop().RunUntilIdle();
 }
 #endif
 
-TEST_F(MediaRouterDesktopTest, UpdateMediaSinksOnUserGesture) {
+TEST_F(MediaRouterDesktopTest, OnUserGesture) {
 #if defined(OS_WIN)
   EXPECT_CALL(mock_extension_provider_, EnableMdnsDiscovery());
 #endif
   EXPECT_CALL(mock_extension_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()));
+  EXPECT_CALL(*dial_media_sink_service(), OnUserGesture());
+  EXPECT_CALL(*cast_media_sink_service(), OnUserGesture());
   router()->OnUserGesture();
   base::RunLoop().RunUntilIdle();
 }

chrome/browser/media/router/mojo/media_router_mojo_impl.cc

@@ -364,17 +364,18 @@ scoped_refptr<MediaRouteController> MediaRouterMojoImpl::GetRouteController(
           << __func__ << ": route does not support controller: " << route_id;
       return nullptr;
     case RouteControllerType::kGeneric:
-      route_controller = new MediaRouteController(route_id, context_);
+      route_controller = new MediaRouteController(route_id, context_, this);
       break;
     case RouteControllerType::kHangouts:
-      route_controller = new HangoutsMediaRouteController(route_id, context_);
+      route_controller =
+          new HangoutsMediaRouteController(route_id, context_, this);
       break;
     case RouteControllerType::kMirroring:
       // TODO(imcheng): Remove this check when remoting is default enabled.
       route_controller =
           base::FeatureList::IsEnabled(features::kMediaRemoting)
-              ? new MirroringMediaRouteController(route_id, context_)
-              : new MediaRouteController(route_id, context_);
+              ? new MirroringMediaRouteController(route_id, context_, this)
+              : new MediaRouteController(route_id, context_, this);
       break;
   }
   DCHECK(route_controller);

chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc

@@ -143,18 +143,12 @@ class MediaRouterMojoImplTest : public MediaRouterMojoTest {
         expected_count);
   }
 
-  MediaRouterMojoImpl* SetTestingFactoryAndUse() override {
-    return static_cast<MediaRouterMojoImpl*>(
-        MediaRouterFactory::GetInstance()->SetTestingFactoryAndUse(
-            profile(), &CreateMediaRouter));
+  std::unique_ptr<MediaRouterMojoImpl> CreateMediaRouter() override {
+    return std::unique_ptr<MediaRouterMojoImpl>(
+        new MediaRouterMojoImpl(profile()));
   }
 
  private:
-  static std::unique_ptr<KeyedService> CreateMediaRouter(
-      content::BrowserContext* context) {
-    return std::unique_ptr<KeyedService>(new MediaRouterMojoImpl(context));
-  }
-
   base::HistogramTester histogram_tester_;
 };
 

chrome/browser/media/router/mojo/media_router_mojo_test.cc

@@ -151,8 +151,9 @@ void MockMediaController::CloseBinding() {
 
 MockMediaRouteController::MockMediaRouteController(
     const MediaRoute::Id& route_id,
-    content::BrowserContext* context)
-    : MediaRouteController(route_id, context) {}
+    content::BrowserContext* context,
+    MediaRouter* router)
+    : MediaRouteController(route_id, context, router) {}
 
 MockMediaRouteController::~MockMediaRouteController() {}
 
@@ -187,7 +188,7 @@ void MediaRouterMojoTest::RegisterWiredDisplayProvider() {
 }
 
 void MediaRouterMojoTest::SetUp() {
-  media_router_ = SetTestingFactoryAndUse();
+  media_router_ = CreateMediaRouter();
   media_router_->set_instance_id_for_test(kInstanceId);
   RegisterExtensionProvider();
   media_router_->Initialize();

chrome/browser/media/router/mojo/media_router_mojo_test.h

@@ -244,7 +244,8 @@ class MockMediaController : public mojom::MediaController,
 class MockMediaRouteController : public MediaRouteController {
  public:
   MockMediaRouteController(const MediaRoute::Id& route_id,
-                           content::BrowserContext* context);
+                           content::BrowserContext* context,
+                           MediaRouter* router);
   MOCK_METHOD0(Play, void());
   MOCK_METHOD0(Pause, void());
   MOCK_METHOD1(Seek, void(base::TimeDelta time));
@@ -277,9 +278,8 @@ class MediaRouterMojoTest : public ::testing::Test {
   void SetUp() override;
   void TearDown() override;
 
-  // Set the MediaRouter instance to be used by the MediaRouterFactory and
-  // return it.
-  virtual MediaRouterMojoImpl* SetTestingFactoryAndUse() = 0;
+  // Creates a MediaRouterMojoImpl instance to be used for this test.
+  virtual std::unique_ptr<MediaRouterMojoImpl> CreateMediaRouter() = 0;
 
   // Notify media router that the provider provides a route or a sink.
   // Need to be called after the provider is registered.
@@ -308,7 +308,7 @@ class MediaRouterMojoTest : public ::testing::Test {
 
   const std::string& extension_id() const { return extension_->id(); }
 
-  MediaRouterMojoImpl* router() const { return media_router_; }
+  MediaRouterMojoImpl* router() const { return media_router_.get(); }
 
   Profile* profile() { return &profile_; }
 
@@ -326,7 +326,7 @@ class MediaRouterMojoTest : public ::testing::Test {
   content::TestBrowserThreadBundle test_thread_bundle_;
   scoped_refptr<extensions::Extension> extension_;
   TestingProfile profile_;
-  MediaRouterMojoImpl* media_router_ = nullptr;
+  std::unique_ptr<MediaRouterMojoImpl> media_router_;
   mojo::BindingSet<mojom::MediaRouteProvider> provider_bindings_;
   std::unique_ptr<MediaRoutesObserver> routes_observer_;
   std::unique_ptr<MockMediaSinksObserver> sinks_observer_;

chrome/browser/ui/webui/media_router/media_router_webui_message_handler_unittest.cc

@@ -207,8 +207,11 @@ class MediaRouterWebUIMessageHandlerTest : public MediaRouterWebUITest {
     return dict_value;
   }
 
+  MockMediaRouter* router() { return &router_; }
+
  protected:
   std::unique_ptr<content::TestWebUI> web_ui_;
+  MockMediaRouter router_;
   std::unique_ptr<MockMediaRouterUI> mock_media_router_ui_;
   std::unique_ptr<TestMediaRouterWebUIMessageHandler> handler_;
   const std::string provider_extension_id_;
@@ -619,8 +622,8 @@ TEST_F(MediaRouterWebUIMessageHandlerTest, OnRouteDetailsOpenedAndClosed) {
 }
 
 TEST_F(MediaRouterWebUIMessageHandlerTest, OnMediaCommandsReceived) {
-  auto controller =
-      base::MakeRefCounted<MockMediaRouteController>("routeId", profile());
+  auto controller = base::MakeRefCounted<MockMediaRouteController>(
+      "routeId", profile(), router());
   EXPECT_CALL(*mock_media_router_ui_, GetMediaRouteController())
       .WillRepeatedly(Return(controller.get()));
   MediaStatus status;
@@ -657,8 +660,8 @@ TEST_F(MediaRouterWebUIMessageHandlerTest, OnMediaCommandsReceived) {
 }
 
 TEST_F(MediaRouterWebUIMessageHandlerTest, OnSetMediaRemotingEnabled) {
-  auto controller =
-      base::MakeRefCounted<MirroringMediaRouteController>("routeId", profile());
+  auto controller = base::MakeRefCounted<MirroringMediaRouteController>(
+      "routeId", profile(), router());
   EXPECT_CALL(*mock_media_router_ui_, GetMediaRouteController())
       .WillRepeatedly(Return(controller.get()));
 
@@ -669,8 +672,8 @@ TEST_F(MediaRouterWebUIMessageHandlerTest, OnSetMediaRemotingEnabled) {
 }
 
 TEST_F(MediaRouterWebUIMessageHandlerTest, OnInvalidMediaCommandsReceived) {
-  auto controller =
-      base::MakeRefCounted<MockMediaRouteController>("routeId", profile());
+  auto controller = base::MakeRefCounted<MockMediaRouteController>(
+      "routeId", profile(), router());
   EXPECT_CALL(*mock_media_router_ui_, GetMediaRouteController())
       .WillRepeatedly(Return(controller.get()));