[Media Router] Use DialMediaSinkService in MediaRouterMojoImpl

chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 166 matching lines @@
   MOCK_METHOD1(IsEventPageSuspended, bool(const std::string& ext_id));
 
   MOCK_METHOD2(WakeEventPage,
                bool(const std::string& extension_id,
                     const base::Callback<void(bool)>& callback));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
 };
 
-// Mockable class for awaiting RegisterMediaRouteProvider callbacks.
-class RegisterMediaRouteProviderHandler {
- public:
-  MOCK_METHOD1(Invoke, void(const std::string& instance_id));
-};
-
 TEST_F(MediaRouterMojoImplTest, CreateRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
@@ skipping 1210 matching lines @@
 
     profile_.reset(new TestingProfile);
     // Set up a mock ProcessManager instance.
     extensions::ProcessManagerFactory::GetInstance()->SetTestingFactory(
         profile_.get(), &TestProcessManager::Create);
     process_manager_ = static_cast<TestProcessManager*>(
         extensions::ProcessManager::Get(profile_.get()));
     DCHECK(process_manager_);
 
     // Create MR and its proxy, so that it can be accessed through Mojo.
-    media_router_.reset(new MediaRouterMojoImpl(process_manager_));
+    media_router_.reset(
+        new MediaRouterMojoImpl(process_manager_, profile_.get()));
     ProcessEventLoop();
   }
 
   void TearDown() override {
     media_router_.reset();
     profile_.reset();
   }
 
   // Constructs bindings so that |media_router_| delegates calls to
   // |mojo_media_router_|, which are then handled by
@@ skipping 66 matching lines @@
   // It should be queued.
   media_router_->DetachRoute(kRouteId);
 
   BindMediaRouteProvider();
 
   base::RunLoop run_loop, run_loop2;
   // |mojo_media_router| signals its readiness to the MR by registering
   // itself via RegisterMediaRouteProvider().
   // Now that the |media_router| and |mojo_media_router| are fully initialized,
   // the queued DetachRoute() call should be executed.
-  EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
+  EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .Times(AtMost(1));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
 
   base::RunLoop run_loop3;
   // Extension is suspended and re-awoken.
   ResetMediaRouteProvider();
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
   EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .WillOnce(testing::DoAll(
           media::RunCallback<1>(true),
           InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }),
           Return(true)));
   media_router_->DetachRoute(kRouteId2);
   run_loop3.Run();
 
   base::RunLoop run_loop4, run_loop5;
   // RegisterMediaRouteProvider() is called.
   // The queued DetachRoute(kRouteId2) call should be executed.
-  EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
+  EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _))
       .WillOnce(InvokeWithoutArgs([&run_loop4]() { run_loop4.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .Times(AtMost(1));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2))
       .WillOnce(InvokeWithoutArgs([&run_loop5]() { run_loop5.Quit(); }));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   run_loop4.Run();
@@ skipping 89 matching lines @@
     media_router_->DetachRoute(kRouteId2);
 
   // The request queue size should not exceed |kMaxPendingRequests|.
   EXPECT_EQ(kMaxPendingRequests, media_router_->pending_requests_.size());
 
   base::RunLoop run_loop, run_loop2;
   size_t count = 0;
   // The oldest request should have been dropped, so we don't expect to see
   // DetachRoute(kRouteId) here.
   BindMediaRouteProvider();
-  EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
+  EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()));
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .Times(AtMost(1));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2))
       .Times(kMaxPendingRequests)
       .WillRepeatedly(InvokeWithoutArgs([&run_loop2, &count]() {
         if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
           run_loop2.Quit();
       }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
   ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
                            1);
 }
 
 #if defined(OS_WIN)
 TEST_F(MediaRouterMojoExtensionTest, EnableMdnsAfterEachRegister) {
   // This should be queued since no MRPM is registered yet.
   media_router_->OnUserGesture();
 
   BindMediaRouteProvider();
 
   base::RunLoop run_loop;
   base::RunLoop run_loop2;
-  EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-                  run_loop.Quit();
-                }));
+  EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false)).WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .Times(2);
   // EnableMdnsDiscovery() is never called except on Windows.
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
                   run_loop2.Quit();
                 }));
@@ skipping 16 matching lines @@
           InvokeWithoutArgs([&run_loop4]() { run_loop4.Quit(); }),
           Return(true)));
   // Use DetachRoute because it unconditionally calls RunOrDefer().
   media_router_->DetachRoute(kRouteId);
   run_loop4.Run();
 
   base::RunLoop run_loop5;
   base::RunLoop run_loop6;
   // RegisterMediaRouteProvider() is called.
   // The queued DetachRoute(kRouteId) call should be executed.
-  EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
-      .WillOnce(InvokeWithoutArgs([&run_loop5]() {
-                  run_loop5.Quit();
-                }));
+  EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _))
+      .WillOnce(InvokeWithoutArgs([&run_loop5]() { run_loop5.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false)).WillOnce(Return(false));
   // Expected because it was used to wake up the page.
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId));
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()));
   // EnableMdnsDiscovery() is never called except on Windows.
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .WillOnce(InvokeWithoutArgs([&run_loop6]() {
                   run_loop6.Quit();
                 }));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   run_loop5.Run();
   run_loop6.Run();
   // Should not call EnableMdnsDiscovery, but will call UpdateMediaSinks
   media_router_->OnUserGesture();
   base::RunLoop run_loop7;
   run_loop7.RunUntilIdle();
 }
 #endif
 
 TEST_F(MediaRouterMojoExtensionTest, UpdateMediaSinksOnUserGesture) {
   BindMediaRouteProvider();
 
   base::RunLoop run_loop;
-  EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() {
-                  run_loop.Quit();
-                }));
+  EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
 #if defined(OS_WIN)
       // Windows calls once for EnableMdnsDiscovery
       .Times(3)
 #else
       // All others call once for registration, and once for the user gesture.
       .Times(2)
 #endif
       .WillRepeatedly(Return(false));
 
@@ skipping 19 matching lines @@
 
 TEST_F(MediaRouterMojoExtensionTest, SyncStateToMediaRouteProvider) {
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillRepeatedly(Return(false));
   MediaSource media_source = MediaSource(kSource);
   std::unique_ptr<MockMediaSinksObserver> sinks_observer;
   std::unique_ptr<MockMediaRoutesObserver> routes_observer;
   std::unique_ptr<NullMessageObserver> messages_observer;
 
   {
-    EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
+    EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _));
     BindMediaRouteProvider();
     RegisterMediaRouteProvider();
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&provide_handler_));
   }
 
   {
     media_router_->OnSinkAvailabilityUpdated(
         mojom::MediaRouter::SinkAvailability::PER_SOURCE);
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaSinks(media_source.id()));
     sinks_observer.reset(new MockMediaSinksObserver(
         router(), media_source, url::Origin(GURL(kOrigin))));
     EXPECT_TRUE(sinks_observer->Init());
 
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaRoutes(media_source.id()));
     routes_observer.reset(
         new MockMediaRoutesObserver(router(), media_source.id()));
 
     EXPECT_CALL(mock_media_route_provider_,
                 StartListeningForRouteMessages(media_source.id()));
     messages_observer.reset(
         new NullMessageObserver(router(), media_source.id()));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
   }
 
   {
-    EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
+    EXPECT_CALL(provide_handler_, InvokeRaw(testing::Not(""), _));
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaSinks(media_source.id()));
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaRoutes(media_source.id()));
     EXPECT_CALL(mock_media_route_provider_,
                 StartListeningForRouteMessages(media_source.id()));
     media_router_->OnConnectionError();
     BindMediaRouteProvider();
     RegisterMediaRouteProvider();
     base::RunLoop().RunUntilIdle();
   }
 }
 
 }  // namespace media_router