[Media Router] Convert to use typemaps for media_router.mojom.

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
-#include "chrome/browser/media/router/mojo/media_router_type_converters.h"
 #include "chrome/browser/media/router/route_message.h"
 #include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/version_info/version_info.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
@@ skipping 14 matching lines @@
 using testing::IsEmpty;
 using testing::Mock;
 using testing::Not;
 using testing::Pointee;
 using testing::Return;
 using testing::ReturnRef;
 using testing::SaveArg;
 
 namespace media_router {
 
-using PresentationConnectionState =
-    mojom::MediaRouter::PresentationConnectionState;
-using PresentationConnectionCloseReason =
-    mojom::MediaRouter::PresentationConnectionCloseReason;
-
 namespace {
 
 const char kDescription[] = "description";
 const char kError[] = "error";
 const char kMessage[] = "message";
 const char kSource[] = "source1";
 const char kSource2[] = "source2";
 const char kRouteId[] = "routeId";
 const char kRouteId2[] = "routeId2";
 const char kJoinableRouteId[] = "joinableRouteId";
 const char kJoinableRouteId2[] = "joinableRouteId2";
 const char kSinkId[] = "sink";
 const char kSinkId2[] = "sink2";
 const char kSinkName[] = "sinkName";
 const char kPresentationId[] = "presentationId";
 const char kOrigin[] = "http://origin/";
 const int kInvalidTabId = -1;
 const uint8_t kBinaryMessage[] = {0x01, 0x02, 0x03, 0x04};
 const int kTimeoutMillis = 5 * 1000;
 
 IssueInfo CreateIssueInfo(const std::string& title) {
   IssueInfo issue_info;
   issue_info.title = title;
   issue_info.message = std::string("msg");
   issue_info.default_action = IssueInfo::Action::DISMISS;
   issue_info.severity = IssueInfo::Severity::WARNING;
   return issue_info;
 }
 
-mojom::MediaRoutePtr CreateMojoRoute() {
-  mojom::MediaRoutePtr route = mojom::MediaRoute::New();
-  route->media_source = std::string(kSource);
-  route->media_sink_id = kSinkId;
-  route->media_route_id = kRouteId;
-  route->description = kDescription;
-  route->is_local = true;
-  route->for_display = true;
-  route->is_incognito = false;
-  return route;
+MediaRoute CreateMediaRoute() {
+  return MediaRoute(kRouteId, MediaSource(kSource), kSinkId, kDescription, true,
+                    "", true);

[dcheng, 2017/02/01 22:51:08]

Nit: std::string() instead of "".

[imcheng, 2017/02/02 21:20:37]

Done.

 }
 
 }  // namespace
 
 class RouteResponseCallbackHandler {
  public:
   void Invoke(const RouteRequestResult& result) {
     DoInvoke(result.route(), result.presentation_id(), result.error(),
              result.result_code());
   }
@@ skipping 78 matching lines @@
   // 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, _, kOrigin, kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
              const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(CreateMojoRoute(), std::string(),
-                   mojom::RouteRequestResultCode::OK);
+            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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
-  ExpectResultBucketCount("CreateRoute", RouteRequestResult::ResultCode::OK, 1);
+  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, _, kOrigin, kInvalidTabId, _, _, _))
-      .WillOnce(Invoke(
-          [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const std::string& origin,
-             int tab_id, base::TimeDelta timeout, bool incognito,
-             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            mojom::MediaRoutePtr route = CreateMojoRoute();
-            route->custom_controller_path =
-                std::string("custom/controller/path");
-            route->is_incognito = true;
-            cb.Run(std::move(route), std::string(),
-                   mojom::RouteRequestResultCode::OK);
-          }));
+      .WillOnce(Invoke([&expected_route](
+          const std::string& source, const std::string& sink,
+          const std::string& presentation_id, const std::string& origin,
+          int tab_id, base::TimeDelta timeout, bool incognito,
+          const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+        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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
-  ExpectResultBucketCount("CreateRoute", RouteRequestResult::ResultCode::OK, 1);
+  ExpectResultBucketCount("CreateRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
       CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
                   base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
              const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(mojom::MediaRoutePtr(), std::string(kError),
-                   mojom::RouteRequestResultCode::TIMED_OUT);
+            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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute",
-                          RouteRequestResult::ResultCode::TIMED_OUT, 1);
+                          RouteRequestResult::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) {
-  EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
-                          base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                          true, _))
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
+                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
              const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(CreateMojoRoute(), std::string(),
-                   mojom::RouteRequestResultCode::OK);
+            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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount(
-      "CreateRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1);
+      "CreateRoute", RouteRequestResult::INCOGNITO_MISMATCH, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) {
-  mojom::MediaRoutePtr route = CreateMojoRoute();
-  route->is_incognito = true;
+  MediaRoute route = CreateMediaRoute();
+  route.set_incognito(true);
 
-  EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
-                          base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                          true, _))
-      .WillOnce(Invoke(
-          [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const std::string& origin,
-             int tab_id, base::TimeDelta timeout, bool incognito,
-             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
-            mojom::MediaRoutePtr route = CreateMojoRoute();
-            route->is_incognito = true;
-            cb.Run(std::move(route), std::string(),
-                   mojom::RouteRequestResultCode::OK);
-          }));
+  EXPECT_CALL(
+      mock_media_route_provider_,
+      CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
+                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+      .WillOnce(Invoke([&route](
+          const std::string& source, const std::string& sink,
+          const std::string& presentation_id, const std::string& origin,
+          int tab_id, base::TimeDelta timeout, bool incognito,
+          const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+        cb.Run(route, std::string(), RouteRequestResult::OK);
+      }));
   base::RunLoop run_loop;
   router()->CreateRoute(kSource, kSinkId, GURL(kOrigin), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
-  std::vector<mojom::MediaRoutePtr> mojo_routes(1);
-  mojo_routes[0] = route->Clone();
-  router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
-                            std::vector<std::string>());
+  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, mojom::RouteRequestResultCode::OK);
-       }));
+      .WillOnce(Invoke(
+          [](const std::string& route_id,
+             const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+            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);
 
-  mojom::MediaRoutePtr route = CreateMojoRoute();
+  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<mojom::MediaRoutePtr> mojo_routes(1);
-  mojo_routes[0] = route->Clone();
-  router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
-                            std::vector<std::string>());
+  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, kOrigin, kInvalidTabId,
                 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke([&route](
           const std::string& source, const std::string& presentation_id,
           const std::string& origin, int tab_id, base::TimeDelta timeout,
           bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), std::string(),
-               mojom::RouteRequestResultCode::OK);
+        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, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
-  ExpectResultBucketCount("JoinRoute", RouteRequestResult::ResultCode::OK, 1);
+  ExpectResultBucketCount("JoinRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteNotFoundFails) {
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(nullptr, "", "Route not found",
                                 RouteRequestResult::ROUTE_NOT_FOUND))
       .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, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute",
-                          RouteRequestResult::ResultCode::ROUTE_NOT_FOUND, 1);
+                          RouteRequestResult::ROUTE_NOT_FOUND, 1);
 }
 
 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<mojom::MediaRoutePtr> mojo_routes(1);
-  mojo_routes[0] = CreateMojoRoute();
-  router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
-                            std::vector<std::string>());
+  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, kOrigin, kInvalidTabId,
                 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& presentation_id,
              const std::string& origin, int tab_id, base::TimeDelta timeout,
              bool incognito,
              const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(mojom::MediaRoutePtr(), std::string(kError),
-                   mojom::RouteRequestResultCode::TIMED_OUT);
+            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()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute",
-                          RouteRequestResult::ResultCode::TIMED_OUT, 1);
+                          RouteRequestResult::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteIncognitoMismatchFails) {
-  mojom::MediaRoutePtr route = CreateMojoRoute();
+  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<mojom::MediaRoutePtr> mojo_routes(1);
-  mojo_routes[0] = route->Clone();
-  router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
-                            std::vector<std::string>());
+  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, kOrigin, kInvalidTabId,
                 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
       .WillOnce(Invoke([&route](
           const std::string& source, const std::string& presentation_id,
           const std::string& origin, int tab_id, base::TimeDelta timeout,
           bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), std::string(),
-               mojom::RouteRequestResultCode::OK);
+        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()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount(
-      "JoinRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1);
+      "JoinRoute", RouteRequestResult::INCOGNITO_MISMATCH, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteId) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(false);
-  mojom::MediaRoutePtr route = CreateMojoRoute();
+  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(kSource, kRouteId, _, kOrigin, kInvalidTabId,
-                            base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                            false, _))
+  EXPECT_CALL(mock_media_route_provider_,
+              ConnectRouteByRouteId(
+                  kSource, kRouteId, _, 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 std::string& origin,
           int tab_id, base::TimeDelta timeout, bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), std::string(),
-               mojom::RouteRequestResultCode::OK);
+        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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
-  ExpectResultBucketCount("JoinRoute", RouteRequestResult::ResultCode::OK, 1);
+  ExpectResultBucketCount("JoinRoute", RouteRequestResult::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) {
-  EXPECT_CALL(
-      mock_media_route_provider_,
-      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
-                            base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                            true, _))
+  EXPECT_CALL(mock_media_route_provider_,
+              ConnectRouteByRouteId(
+                  kSource, kRouteId, _, kOrigin, kInvalidTabId,
+                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& route_id,
              const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(mojom::MediaRoutePtr(), std::string(kError),
-                   mojom::RouteRequestResultCode::TIMED_OUT);
+            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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute",
-                          RouteRequestResult::ResultCode::TIMED_OUT, 1);
+                          RouteRequestResult::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) {
-  mojom::MediaRoutePtr route = CreateMojoRoute();
+  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(kSource, kRouteId, _, kOrigin, kInvalidTabId,
-                            base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                            true, _))
+  EXPECT_CALL(mock_media_route_provider_,
+              ConnectRouteByRouteId(
+                  kSource, kRouteId, _, 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 std::string& origin,
           int tab_id, base::TimeDelta timeout, bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), std::string(),
-               mojom::RouteRequestResultCode::OK);
+        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, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount(
-      "JoinRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1);
+      "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, mojom::RouteRequestResultCode::OK);
-      }));
+      .WillOnce(Invoke(
+          [](const std::string& route_id,
+             const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+            cb.Run(base::nullopt, RouteRequestResult::OK);
+          }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute",
-                          RouteRequestResult::ResultCode::OK,
+                          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"),
-               mojom::RouteRequestResultCode::TIMED_OUT);
-      }));
+      .WillOnce(Invoke(
+          [](const std::string& route_id,
+             const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+            cb.Run(std::string("timed out"),
+                   RouteRequestResult::TIMED_OUT);
+          }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute",
-                          RouteRequestResult::ResultCode::OK,
+                          RouteRequestResult::OK,
                           0);
   ExpectResultBucketCount("TerminateRoute",
-                          RouteRequestResult::ResultCode::TIMED_OUT,
+                          RouteRequestResult::TIMED_OUT,
                           1);
 }
 
 TEST_F(MediaRouterMojoImplTest, HandleIssue) {
   MockIssuesObserver issue_observer1(router());
   MockIssuesObserver issue_observer2(router());
   issue_observer1.Init();
   issue_observer2.Init();
 
   IssueInfo issue_info = CreateIssueInfo("title 1");
@@ skipping 46 matching lines @@
       new MockMediaSinksObserver(router(), MediaSource(kSource2), origin));
   EXPECT_TRUE(unrelated_sinks_observer->Init());
   ProcessEventLoop();
 
   std::vector<MediaSink> expected_sinks;
   expected_sinks.push_back(
       MediaSink(kSinkId, kSinkName, MediaSink::IconType::CAST));
   expected_sinks.push_back(
       MediaSink(kSinkId2, kSinkName, MediaSink::IconType::CAST));
 
-  std::vector<mojom::MediaSinkPtr> mojo_sinks(2);
-  mojo_sinks[0] = mojom::MediaSink::New();
-  mojo_sinks[0]->sink_id = kSinkId;
-  mojo_sinks[0]->name = kSinkName;
-  mojo_sinks[0]->icon_type =
-      media_router::mojom::MediaSink::IconType::CAST;
-  mojo_sinks[1] = mojom::MediaSink::New();
-  mojo_sinks[1]->sink_id = kSinkId2;
-  mojo_sinks[1]->name = kSinkName;
-  mojo_sinks[1]->icon_type =
-      media_router::mojom::MediaSink::IconType::CAST;
-
   base::RunLoop run_loop;
   EXPECT_CALL(*sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks)));
   EXPECT_CALL(*extra_sinks_observer,
               OnSinksReceived(SequenceEquals(expected_sinks)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   media_router_proxy_->OnSinksReceived(
-      media_source.id(), std::move(mojo_sinks),
+      media_source.id(), expected_sinks,
       std::vector<std::string>(1, origin.spec()));
   run_loop.Run();
 
   // Since the MediaRouterMojoImpl has already received results for
   // |media_source|, return cached results to observers that are subsequently
   // registered.
   std::unique_ptr<MockMediaSinksObserver> cached_sinks_observer(
       new MockMediaSinksObserver(router(), media_source, origin));
   EXPECT_CALL(*cached_sinks_observer,
               OnSinksReceived(SequenceEquals(expected_sinks)));
@@ skipping 114 matching lines @@
   expected_routes.push_back(MediaRoute(kRouteId, media_source, kSinkId,
                                        kDescription, false, "", false));
   MediaRoute incognito_expected_route(kRouteId2, media_source, kSinkId,
                                       kDescription, false, "", false);
   incognito_expected_route.set_incognito(true);
   expected_routes.push_back(incognito_expected_route);
   std::vector<MediaRoute::Id> expected_joinable_route_ids;
   expected_joinable_route_ids.push_back(kJoinableRouteId);
   expected_joinable_route_ids.push_back(kJoinableRouteId2);
 
-  std::vector<std::string> mojo_joinable_routes(2);
-  mojo_joinable_routes[0] = kJoinableRouteId;
-  mojo_joinable_routes[1] = kJoinableRouteId2;
-
-  std::vector<mojom::MediaRoutePtr> mojo_routes(2);
-  mojo_routes[0] = CreateMojoRoute();
-  mojo_routes[1] = CreateMojoRoute();
-  mojo_routes[1]->media_route_id = kRouteId2;
-  mojo_routes[1]->is_incognito = true;
-
   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));
   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));
+  media_router_proxy_->OnRoutesUpdated(expected_routes, media_source.id(),
+                                       expected_joinable_route_ids);
   ProcessEventLoop();
 
   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);
@@ skipping 184 matching lines @@
     base::RunLoop run_loop;
     content::PresentationConnectionStateChangeInfo closed_info(
         content::PRESENTATION_CONNECTION_STATE_CLOSED);
     closed_info.close_reason =
         content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
     closed_info.message = "Foo";
 
     EXPECT_CALL(callback, Run(StateChangeInfoEquals(closed_info)))
         .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
     media_router_proxy_->OnPresentationConnectionClosed(
-        route_id, PresentationConnectionCloseReason::WENT_AWAY, "Foo");
+        route_id, content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY,
+        "Foo");
     run_loop.Run();
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback));
   }
 
   content::PresentationConnectionStateChangeInfo terminated_info(
       content::PRESENTATION_CONNECTION_STATE_TERMINATED);
   {
     base::RunLoop run_loop;
     EXPECT_CALL(callback, Run(StateChangeInfoEquals(terminated_info)))
         .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
     media_router_proxy_->OnPresentationConnectionStateChanged(
-        route_id, PresentationConnectionState::TERMINATED);
+        route_id, content::PRESENTATION_CONNECTION_STATE_TERMINATED);
     run_loop.Run();
 
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&callback));
   }
 }
 
 TEST_F(MediaRouterMojoImplTest,
        PresentationConnectionStateChangedCallbackRemoved) {
   MediaRoute::Id route_id("route-id");
   MockPresentationConnectionStateChangedCallback callback;
   std::unique_ptr<PresentationConnectionStateSubscription> subscription =
       router()->AddPresentationConnectionStateChangedCallback(
           route_id,
           base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
                      base::Unretained(&callback)));
 
   // Callback has been removed, so we don't expect it to be called anymore.
   subscription.reset();
   EXPECT_TRUE(router()->presentation_connection_state_callbacks_.empty());
 
   EXPECT_CALL(callback, Run(_)).Times(0);
   media_router_proxy_->OnPresentationConnectionStateChanged(
-      route_id, PresentationConnectionState::TERMINATED);
+      route_id, content::PRESENTATION_CONNECTION_STATE_TERMINATED);
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(2)
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _))
       .Times(2)
@@ skipping 412 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router