Stop linking in the old Mojo EDK.

chrome/browser/media/router/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 <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 310 matching lines @@
   route->media_source = kSource;
   route->media_sink_id = kSinkId;
   route->media_route_id = kRouteId;
   route->description = kDescription;
   route->is_local = true;
   route->for_display = true;
 
   // 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.
+  base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_,
               ConnectRouteByRouteId(mojo::String(kSource),
                                     mojo::String(kRouteId), _,
                                     mojo::String(kOrigin), kInvalidTabId, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& route_id,
           const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), mojo::String());
       }));
   EXPECT_CALL(mock_media_route_provider_,
-      StartObservingMediaRoutes(mojo::String("")));
+      StartObservingMediaRoutes(mojo::String("")))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() {
+        run_loop.Quit();
+      }));
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), Not(""), ""));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(kSource, kRouteId, GURL(kOrigin), nullptr,
                                   route_response_callbacks);
-  ProcessEventLoop();
+  run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) {
+  base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_,
               ConnectRouteByRouteId(mojo::String(kSource),
                                     mojo::String(kRouteId), _,
                                     mojo::String(kOrigin), kInvalidTabId, _))
       .WillOnce(Invoke(
           [](const mojo::String& source,
              const mojo::String& route_id,
              const mojo::String& presentation_id,
              const mojo::String& origin, int tab_id,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError));
           }));
 
   RouteResponseCallbackHandler handler;
-  EXPECT_CALL(handler, Invoke(nullptr, "", kError));
+  EXPECT_CALL(handler, Invoke(nullptr, "", kError))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() {
+        run_loop.Quit();
+      }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(kSource, kRouteId, GURL(kOrigin), nullptr,
                                   route_response_callbacks);
-  ProcessEventLoop();
+  run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, DetachRoute) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() {
         run_loop.Quit();
       }));
   router()->DetachRoute(kRouteId);
   run_loop.Run();
@@ skipping 137 matching lines @@
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE);
   MediaSource media_source(kSource);
   scoped_ptr<MockMediaSinksObserver> sinks_observer(
       new MockMediaSinksObserver(router(), media_source));
   EXPECT_CALL(*sinks_observer, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer->Init());
   MediaSource media_source2(kSource2);
   scoped_ptr<MockMediaSinksObserver> sinks_observer2(
       new MockMediaSinksObserver(router(), media_source2));
-  EXPECT_CALL(*sinks_observer2, OnSinksReceived(IsEmpty()));
+  base::RunLoop run_loop;
+  EXPECT_CALL(*sinks_observer2, OnSinksReceived(IsEmpty()))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() {
+        run_loop.Quit();
+      }));
   EXPECT_TRUE(sinks_observer2->Init());
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource)))
       .Times(0);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource2)))
       .Times(0);
-  ProcessEventLoop();
+  run_loop.Run();
+  base::RunLoop run_loop2;
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SINK_AVAILABILITY_AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource)))
       .Times(1);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource2)))
-      .Times(1);
-  ProcessEventLoop();
+      .Times(1)
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
+        run_loop2.Quit();
+      }));
+  run_loop2.Run();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SINK_AVAILABILITY_AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource)))
       .Times(0);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource2)))
       .Times(0);
   ProcessEventLoop();
@@ skipping 27 matching lines @@
       new MockMediaSinksObserver(router(), media_source2));
   EXPECT_CALL(*sinks_observer2, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer2->Init());
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource)))
       .Times(0);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource2)))
       .Times(0);
   ProcessEventLoop();
-  router()->OnSinkAvailabilityUpdated(
-      interfaces::MediaRouter::SINK_AVAILABILITY_AVAILABLE);
+  base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource)))
       .Times(1);
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaSinks(mojo::String(kSource2)))
-      .Times(1);
+      .Times(1)
+      .WillOnce(InvokeWithoutArgs([&run_loop]() {
+        run_loop.Quit();
+      }));
+  router()->OnSinkAvailabilityUpdated(
+      interfaces::MediaRouter::SINK_AVAILABILITY_AVAILABLE);
+  run_loop.Run();
+  base::RunLoop run_loop2;
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource)))
       .Times(1);
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource2)))
-      .Times(1);
+      .Times(1)
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
+        run_loop2.Quit();
+      }));
   sinks_observer.reset();   // Unregisters kSource from router().
   sinks_observer2.reset();  // Unregisters kSource2 from router().
-  ProcessEventLoop();
+  run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaRoutesObserver) {
   MockMediaRouter mock_router;
   MediaSource media_source(kSource);
   MediaSource different_media_source(kSource2);
   EXPECT_CALL(mock_media_route_provider_,
       StartObservingMediaRoutes(mojo::String(media_source.id()))).Times(2);
   EXPECT_CALL(mock_media_route_provider_,
       StartObservingMediaRoutes(
@@ skipping 35 matching lines @@
   mojo_routes[0]->media_sink_id = kSinkId;
   mojo_routes[0]->description = kDescription;
   mojo_routes[0]->is_local = false;
   mojo_routes[1] = interfaces::MediaRoute::New();
   mojo_routes[1]->media_route_id = kRouteId2;
   mojo_routes[1]->media_source = kSource;
   mojo_routes[1]->media_sink_id = kSinkId;
   mojo_routes[1]->description = kDescription;
   mojo_routes[1]->is_local = false;
 
+  base::RunLoop run_loop;
   EXPECT_CALL(routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
                               expected_joinable_route_ids));
   EXPECT_CALL(extra_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
-                              expected_joinable_route_ids));
+                              expected_joinable_route_ids))
+      .WillOnce(InvokeWithoutArgs([&run_loop]() {
+        run_loop.Quit();
+      }));
   EXPECT_CALL(different_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
                               expected_joinable_route_ids)).Times(0);
   media_router_proxy_->OnRoutesUpdated(std::move(mojo_routes),
                                        media_source.id(),
                                        std::move(mojo_joinable_routes));
-  ProcessEventLoop();
+  run_loop.Run();
 
+  base::RunLoop run_loop2;
   EXPECT_CALL(mock_router, UnregisterMediaRoutesObserver(&routes_observer));
   EXPECT_CALL(mock_router,
               UnregisterMediaRoutesObserver(&extra_routes_observer));
   EXPECT_CALL(mock_router,
               UnregisterMediaRoutesObserver(&different_routes_observer));
   router()->UnregisterMediaRoutesObserver(&routes_observer);
   router()->UnregisterMediaRoutesObserver(&extra_routes_observer);
   router()->UnregisterMediaRoutesObserver(&different_routes_observer);
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaRoutes(
                   mojo::String(media_source.id()))).Times(1);
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaRoutes(
-                  mojo::String(different_media_source.id())));
-  ProcessEventLoop();
+                  mojo::String(different_media_source.id())))
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
+        run_loop2.Quit();
+      }));
+  run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteMessage) {
   EXPECT_CALL(
       mock_media_route_provider_,
       SendRouteMessage(mojo::String(kRouteId), mojo::String(kMessage), _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::string& message,
           const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
         cb.Run(true);
@@ skipping 323 matching lines @@
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _))
       .Times(2)
       .WillOnce(Return(true))
       .WillOnce(DoAll(InvokeWithoutArgs([&run_loop]() {
                         run_loop.Quit();
                       }), Return(true)));
   router()->DetachRoute(kRouteId);
   router()->DetachRoute(kRouteId2);
   run_loop.Run();
+
+  base::RunLoop run_loop2, run_loop3;
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(1)
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)))
+      .WillOnce(InvokeWithoutArgs([&run_loop2]() {
+                  run_loop2.Quit();
+                }));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
+      .WillOnce(InvokeWithoutArgs([&run_loop3]() {
+                  run_loop3.Quit();
+                }));
   ConnectProviderManagerService();
-  ProcessEventLoop();
+  run_loop2.Run();
+  run_loop3.Run();
 }
 
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest()
     : process_manager_(nullptr),
       message_loop_(mojo::common::MessagePumpMojo::Create())
   {}
 
   ~MediaRouterMojoExtensionTest() override {}
@@ skipping 227 matching lines @@
       .WillRepeatedly(InvokeWithoutArgs([&run_loop2, &count]() {
                         if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
                           run_loop2.Quit();
                       }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
 }
 
 }  // namespace media_router