Use OnceCallback on Mojo interfaces in //chrome/common/media_router

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 87 matching lines @@
 // Creates a media route whose ID is |kRouteId2|.
 MediaRoute CreateMediaRoute2() {
   return MediaRoute(kRouteId2, MediaSource(kSource), kSinkId, kDescription,
                     true, std::string(), true);
 }
 
 void OnCreateMediaRouteController(
     Unused,
     Unused,
     Unused,
-    const mojom::MediaRouteProvider::CreateMediaRouteControllerCallback& cb) {
-  cb.Run(true);
+    mojom::MediaRouteProvider::CreateMediaRouteControllerCallback& cb) {
+  std::move(cb).Run(true);
 }
 
 }  // namespace
 
 class RouteResponseCallbackHandler {
  public:
   void Invoke(const RouteRequestResult& result) {
     DoInvoke(result.route(), result.presentation_id(), result.error(),
              result.result_code());
   }
@@ skipping 71 matching lines @@
 };
 
 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)),
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      CreateRouteInternal(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
                           kInvalidTabId, _, _, _))
-      .WillOnce(Invoke(
-          [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
-             int tab_id, base::TimeDelta timeout, bool incognito,
-             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(CreateMediaRoute(), std::string(), RouteRequestResult::OK);
-          }));
+      .WillOnce(Invoke([](const std::string& source, const std::string& sink,
+                          const std::string& presentation_id,
+                          const url::Origin& origin, int tab_id,
+                          base::TimeDelta timeout, bool incognito,
+                          mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+        std::move(cb).Run(CreateMediaRoute(), std::string(),
+                          RouteRequestResult::OK);
+      }));
 
   base::RunLoop run_loop;
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .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()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
                         route_response_callbacks,
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         false);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateIncognitoRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(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.
-  EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      CreateRouteInternal(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
                           kInvalidTabId, _, _, _))
       .WillOnce(Invoke([&expected_route](
-          const std::string& source, const std::string& sink,
-          const std::string& presentation_id, const url::Origin& origin,
-          int tab_id, base::TimeDelta timeout, bool incognito,
-          const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-        cb.Run(expected_route, std::string(), RouteRequestResult::OK);
+                           const std::string& source, const std::string& sink,
+                           const std::string& presentation_id,
+                           const url::Origin& origin, int tab_id,
+                           base::TimeDelta timeout, bool incognito,
+                           mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+        std::move(cb).Run(expected_route, std::string(),
+                          RouteRequestResult::OK);
       }));
 
   base::RunLoop run_loop;
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .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()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
                         route_response_callbacks,
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                  kInvalidTabId,
-                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
-      .WillOnce(Invoke(
-          [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
-             int tab_id, base::TimeDelta timeout, bool incognito,
-             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(base::nullopt, std::string(kError),
-                   RouteRequestResult::TIMED_OUT);
-          }));
+      CreateRouteInternal(
+          kSource, kSinkId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
+          base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
+      .WillOnce(Invoke([](const std::string& source, const std::string& sink,
+                          const std::string& presentation_id,
+                          const url::Origin& origin, int tab_id,
+                          base::TimeDelta timeout, bool incognito,
+                          mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+        std::move(cb).Run(base::nullopt, std::string(kError),
+                          RouteRequestResult::TIMED_OUT);
+      }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .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()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
                         route_response_callbacks,
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         false);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute", RouteRequestResult::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                  kInvalidTabId,
-                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
-      .WillOnce(Invoke(
-          [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
-             int tab_id, base::TimeDelta timeout, bool incognito,
-             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(CreateMediaRoute(), std::string(), RouteRequestResult::OK);
-          }));
+      CreateRouteInternal(
+          kSource, kSinkId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
+          base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+      .WillOnce(Invoke([](const std::string& source, const std::string& sink,
+                          const std::string& presentation_id,
+                          const url::Origin& origin, int tab_id,
+                          base::TimeDelta timeout, bool incognito,
+                          mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+        std::move(cb).Run(CreateMediaRoute(), std::string(),
+                          RouteRequestResult::OK);
+      }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
                                 RouteRequestResult::INCOGNITO_MISMATCH))
       .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()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
                         route_response_callbacks,
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute", RouteRequestResult::INCOGNITO_MISMATCH,
                           1);
 }
 
 TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) {
   MediaRoute route = CreateMediaRoute();
   route.set_incognito(true);
 
   EXPECT_CALL(
       mock_media_route_provider_,
-      CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                  kInvalidTabId,
-                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
-      .WillOnce(Invoke([&route](
-          const std::string& source, const std::string& sink,
-          const std::string& presentation_id, const url::Origin& origin,
-          int tab_id, base::TimeDelta timeout, bool incognito,
-          const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-        cb.Run(route, std::string(), RouteRequestResult::OK);
-      }));
+      CreateRouteInternal(
+          kSource, kSinkId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
+          base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+      .WillOnce(
+          Invoke([&route](const std::string& source, const std::string& sink,
+                          const std::string& presentation_id,
+                          const url::Origin& origin, int tab_id,
+                          base::TimeDelta timeout, bool incognito,
+                          mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+            std::move(cb).Run(route, std::string(), RouteRequestResult::OK);
+          }));
   base::RunLoop run_loop;
   router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
   std::vector<MediaRoute> routes;
   routes.push_back(route);
   router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>());
 
   // TODO(mfoltz): Where possible, convert other tests to use RunUntilIdle
   // instead of manually calling Run/Quit on the run loop.
   run_loop.RunUntilIdle();
 
-  EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _))
-      .WillOnce(Invoke(
-          [](const std::string& route_id,
-             const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
-            cb.Run(base::nullopt, RouteRequestResult::OK);
+  EXPECT_CALL(mock_media_route_provider_, TerminateRouteInternal(kRouteId, _))
+      .WillOnce(
+          Invoke([](const std::string& route_id,
+                    mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+            std::move(cb).Run(base::nullopt, RouteRequestResult::OK);
           }));
 
   base::RunLoop run_loop2;
   router()->OnIncognitoProfileShutdown();
   run_loop2.RunUntilIdle();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
 
   MediaRoute route = CreateMediaRoute();
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
   std::vector<MediaRoute> routes;
   routes.push_back(route);
   router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   // 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_,
-      JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
-                kInvalidTabId,
-                base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
-      .WillOnce(Invoke([&route](
-          const std::string& source, const std::string& presentation_id,
-          const url::Origin& origin, int tab_id, base::TimeDelta timeout,
-          bool incognito,
-          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(route, std::string(), RouteRequestResult::OK);
-      }));
+      JoinRouteInternal(
+          kSource, kPresentationId, url::Origin(GURL(kOrigin)), kInvalidTabId,
+          base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
+      .WillOnce(
+          Invoke([&route](const std::string& source,
+                          const std::string& presentation_id,
+                          const url::Origin& origin, int tab_id,
+                          base::TimeDelta timeout, bool incognito,
+                          mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            std::move(cb).Run(route, std::string(), RouteRequestResult::OK);
+          }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .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()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
@@ skipping 22 matching lines @@
 TEST_F(MediaRouterMojoImplTest, JoinRouteTimedOutFails) {
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
   std::vector<MediaRoute> routes;
   routes.push_back(CreateMediaRoute());
   router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   EXPECT_CALL(
       mock_media_route_provider_,
-      JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
-                kInvalidTabId,
-                base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
+      JoinRouteInternal(
+          kSource, kPresentationId, url::Origin(GURL(kOrigin)), kInvalidTabId,
+          base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& presentation_id,
              const url::Origin& origin, int tab_id, base::TimeDelta timeout,
-             bool incognito,
-             const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(base::nullopt, std::string(kError),
-                   RouteRequestResult::TIMED_OUT);
+             bool incognito, mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            std::move(cb).Run(base::nullopt, std::string(kError),
+                              RouteRequestResult::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .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)));
@@ skipping 12 matching lines @@
   std::vector<MediaRoute> routes;
   routes.push_back(route);
   router()->OnRoutesUpdated(routes, std::string(), std::vector<std::string>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   // 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_,
-      JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
-                kInvalidTabId,
-                base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
-      .WillOnce(Invoke([&route](
-          const std::string& source, const std::string& presentation_id,
-          const url::Origin& origin, int tab_id, base::TimeDelta timeout,
-          bool incognito,
-          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(route, std::string(), RouteRequestResult::OK);
-      }));
+      JoinRouteInternal(
+          kSource, kPresentationId, url::Origin(GURL(kOrigin)), kInvalidTabId,
+          base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+      .WillOnce(
+          Invoke([&route](const std::string& source,
+                          const std::string& presentation_id,
+                          const url::Origin& origin, int tab_id,
+                          base::TimeDelta timeout, bool incognito,
+                          mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            std::move(cb).Run(route, std::string(), RouteRequestResult::OK);
+          }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
                                 RouteRequestResult::INCOGNITO_MISMATCH))
       .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)));
@@ skipping 10 matching lines @@
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(false);
   MediaRoute route = CreateMediaRoute();
 
   // 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_,
-      ConnectRouteByRouteId(
+      ConnectRouteByRouteIdInternal(
           kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
           base::TimeDelta::FromMilliseconds(kTimeoutMillis), false, _))
-      .WillOnce(Invoke([&route](
-          const std::string& source, const std::string& route_id,
-          const std::string& presentation_id, const url::Origin& origin,
-          int tab_id, base::TimeDelta timeout, bool incognito,
-          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(route, std::string(), RouteRequestResult::OK);
-      }));
+      .WillOnce(Invoke(
+          [&route](const std::string& source, const std::string& route_id,
+                   const std::string& presentation_id,
+                   const url::Origin& origin, int tab_id,
+                   base::TimeDelta timeout, bool incognito,
+                   mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            std::move(cb).Run(route, std::string(), RouteRequestResult::OK);
+          }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .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, url::Origin(GURL(kOrigin)), nullptr,
       route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      ConnectRouteByRouteId(
+      ConnectRouteByRouteIdInternal(
           kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
           base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& route_id,
              const std::string& presentation_id, const url::Origin& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
-             const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(base::nullopt, std::string(kError),
-                   RouteRequestResult::TIMED_OUT);
+             mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            std::move(cb).Run(base::nullopt, std::string(kError),
+                              RouteRequestResult::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .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, url::Origin(GURL(kOrigin)), nullptr,
       route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute", RouteRequestResult::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) {
   MediaRoute route = CreateMediaRoute();
 
   // 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_,
-      ConnectRouteByRouteId(
+      ConnectRouteByRouteIdInternal(
           kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
           base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
-      .WillOnce(Invoke([&route](
-          const std::string& source, const std::string& route_id,
-          const std::string& presentation_id, const url::Origin& origin,
-          int tab_id, base::TimeDelta timeout, bool incognito,
-          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(route, std::string(), RouteRequestResult::OK);
-      }));
+      .WillOnce(Invoke(
+          [&route](const std::string& source, const std::string& route_id,
+                   const std::string& presentation_id,
+                   const url::Origin& origin, int tab_id,
+                   base::TimeDelta timeout, bool incognito,
+                   mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            std::move(cb).Run(route, std::string(), RouteRequestResult::OK);
+          }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
                                 RouteRequestResult::INCOGNITO_MISMATCH))
       .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, url::Origin(GURL(kOrigin)), nullptr,
       route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute", RouteRequestResult::INCOGNITO_MISMATCH,
                           1);
 }
 
 TEST_F(MediaRouterMojoImplTest, DetachRoute) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->DetachRoute(kRouteId);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, TerminateRoute) {
   base::RunLoop run_loop;
-  EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _))
-      .WillOnce(Invoke(
-          [](const std::string& route_id,
-             const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
-            cb.Run(base::nullopt, RouteRequestResult::OK);
+  EXPECT_CALL(mock_media_route_provider_, TerminateRouteInternal(kRouteId, _))
+      .WillOnce(
+          Invoke([](const std::string& route_id,
+                    mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+            std::move(cb).Run(base::nullopt, RouteRequestResult::OK);
           }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, TerminateRouteFails) {
   base::RunLoop run_loop;
-  EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _))
-      .WillOnce(Invoke(
-          [](const std::string& route_id,
-             const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
-            cb.Run(std::string("timed out"), RouteRequestResult::TIMED_OUT);
+  EXPECT_CALL(mock_media_route_provider_, TerminateRouteInternal(kRouteId, _))
+      .WillOnce(
+          Invoke([](const std::string& route_id,
+                    mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+            std::move(cb).Run(std::string("timed out"),
+                              RouteRequestResult::TIMED_OUT);
           }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute", RouteRequestResult::OK, 0);
   ExpectResultBucketCount("TerminateRoute", RouteRequestResult::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, HandleIssue) {
   MockIssuesObserver issue_observer1(router());
   MockIssuesObserver issue_observer2(router());
@@ skipping 288 matching lines @@
   // Kill the final observer, and expect the provider to be woken-up and called
   // with the "stop observing" notification.
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaRoutes(media_source.id()))
       .Times(1);
   observer3.reset();
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteMessage) {
-  EXPECT_CALL(
-      mock_media_route_provider_, SendRouteMessage(kRouteId, kMessage, _))
-      .WillOnce(Invoke([](
-          const MediaRoute::Id& route_id, const std::string& message,
-          const mojom::MediaRouteProvider::SendRouteMessageCallback& cb) {
-        cb.Run(true);
-      }));
+  EXPECT_CALL(mock_media_route_provider_,
+              SendRouteMessageInternal(kRouteId, kMessage, _))
+      .WillOnce(
+          Invoke([](const MediaRoute::Id& route_id, const std::string& message,
+                    mojom::MediaRouteProvider::SendRouteMessageCallback& cb) {
+            std::move(cb).Run(true);
+          }));
 
   base::RunLoop run_loop;
   SendMessageCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(true))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->SendRouteMessage(kRouteId, kMessage,
                              base::Bind(&SendMessageCallbackHandler::Invoke,
                                         base::Unretained(&handler)));
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteBinaryMessage) {
   std::unique_ptr<std::vector<uint8_t>> expected_binary_data(
       new std::vector<uint8_t>(kBinaryMessage,
                                kBinaryMessage + arraysize(kBinaryMessage)));
 
   EXPECT_CALL(mock_media_route_provider_,
               SendRouteBinaryMessageInternal(kRouteId, _, _))
-      .WillOnce(Invoke([](
-          const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
-          const mojom::MediaRouteProvider::SendRouteMessageCallback& cb) {
-        EXPECT_EQ(
-            0, memcmp(kBinaryMessage, &(data[0]), arraysize(kBinaryMessage)));
-        cb.Run(true);
-      }));
+      .WillOnce(Invoke(
+          [](const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
+             mojom::MediaRouteProvider::SendRouteMessageCallback& cb) {
+            EXPECT_EQ(0, memcmp(kBinaryMessage, &(data[0]),
+                                arraysize(kBinaryMessage)));
+            std::move(cb).Run(true);
+          }));
 
   base::RunLoop run_loop;
   SendMessageCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(true))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->SendRouteBinaryMessage(
       kRouteId, std::move(expected_binary_data),
       base::Bind(&SendMessageCallbackHandler::Invoke,
                  base::Unretained(&handler)));
   run_loop.Run();
@@ skipping 211 matching lines @@
   std::string search_input("input");
   std::string domain("google.com");
   MediaSource media_source(kSource);
 
   EXPECT_CALL(mock_media_route_provider_,
               SearchSinksInternal(kSinkId, kSource, _, _))
       .WillOnce(
           Invoke([&search_input, &domain](
                      const std::string& sink_id, const std::string& source,
                      const mojom::SinkSearchCriteriaPtr& search_criteria,
-                     const mojom::MediaRouteProvider::SearchSinksCallback& cb) {
+                     mojom::MediaRouteProvider::SearchSinksCallback& cb) {
             EXPECT_EQ(search_input, search_criteria->input);
             EXPECT_EQ(domain, search_criteria->domain);
-            cb.Run(kSinkId2);
+            std::move(cb).Run(kSinkId2);
           }));
 
   SinkResponseCallbackHandler sink_handler;
   EXPECT_CALL(sink_handler, Invoke(kSinkId2)).Times(1);
   MediaSinkSearchResponseCallback sink_callback = base::Bind(
       &SinkResponseCallbackHandler::Invoke, base::Unretained(&sink_handler));
 
   router()->SearchSinks(kSinkId, kSource, search_input, domain, sink_callback);
 
   base::RunLoop run_loop;
@@ skipping 23 matching lines @@
   MockMediaController media_controller;
   mojom::MediaStatusObserverPtr route_controller_as_observer;
   MediaStatus media_status;
   media_status.title = "test title";
 
   router()->OnRoutesUpdated({CreateMediaRoute()}, std::string(),
                             std::vector<std::string>());
 
   EXPECT_CALL(mock_media_route_provider_,
               CreateMediaRouteControllerInternal(kRouteId, _, _, _))
-      .WillOnce(Invoke([&media_controller, &route_controller_as_observer](
-                           const std::string& route_id,
-                           mojom::MediaControllerRequest& request,
-                           mojom::MediaStatusObserverPtr& observer,
-                           const mojom::MediaRouteProvider::
-                               CreateMediaRouteControllerCallback& cb) {
-        media_controller.Bind(std::move(request));
-        route_controller_as_observer = std::move(observer);
-        cb.Run(true);
-      }));
+      .WillOnce(Invoke(
+          [&media_controller, &route_controller_as_observer](
+              const std::string& route_id,
+              mojom::MediaControllerRequest& request,
+              mojom::MediaStatusObserverPtr& observer,
+              mojom::MediaRouteProvider::CreateMediaRouteControllerCallback&
+                  cb) {
+            media_controller.Bind(std::move(request));
+            route_controller_as_observer = std::move(observer);
+            std::move(cb).Run(true);
+          }));
   // GetRouteController() should return a MediaRouteController that is connected
   // to the MediaController provided by the MediaRouteProvider, and will also be
   // subscribed to MediaStatus updates.
   scoped_refptr<MediaRouteController> route_controller =
       router()->GetRouteController(kRouteId);
   base::RunLoop().RunUntilIdle();
 
   // Media commands sent to the MediaRouteController should be forwarded to the
   // MediaController created by the MediaRouteProvider.
   EXPECT_CALL(media_controller, Play());
@@ skipping 95 matching lines @@
 }
 
 TEST_F(MediaRouterMojoImplTest, FailToCreateRouteController) {
   router()->OnRoutesUpdated({CreateMediaRoute()}, std::string(),
                             std::vector<std::string>());
 
   EXPECT_CALL(mock_media_route_provider_,
               CreateMediaRouteControllerInternal(kRouteId, _, _, _))
       .WillOnce(Invoke(
           [](Unused, Unused, Unused,
-             const mojom::MediaRouteProvider::
-                 CreateMediaRouteControllerCallback& cb) { cb.Run(false); }));
+             mojom::MediaRouteProvider::CreateMediaRouteControllerCallback&
+                 cb) { std::move(cb).Run(false); }));
   MockMediaRouteControllerObserver observer(
       router()->GetRouteController(kRouteId));
 
   // When the MediaRouter is notified that the MediaRouteProvider failed to
   // create a controller, the browser-side controller should be invalidated.
   EXPECT_CALL(observer, OnControllerInvalidated());
 
   base::RunLoop().RunUntilIdle();
 }
 
@@ skipping 425 matching lines @@
     EXPECT_CALL(mock_media_route_provider_,
                 StartListeningForRouteMessages(media_source.id()));
     media_router_->OnConnectionError();
     BindMediaRouteProvider();
     RegisterMediaRouteProvider();
     base::RunLoop().RunUntilIdle();
   }
 }
 
 }  // namespace media_router