Media Router Mojo: Use new wrapper types.

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 78 matching lines @@
   if (expected->type != actual->type)
     return false;
 
   return expected->is_binary() ? *expected->data == *actual->data
                                : expected->message == actual->message;
 }
 
 interfaces::IssuePtr CreateMojoIssue(const std::string& title) {
   interfaces::IssuePtr mojoIssue = interfaces::Issue::New();
   mojoIssue->title = title;
-  mojoIssue->message = "msg";
-  mojoIssue->route_id = "";
+  mojoIssue->message = std::string("msg");
+  mojoIssue->route_id = std::string();
   mojoIssue->default_action = interfaces::Issue::ActionType::DISMISS;
-  mojoIssue->secondary_actions =
-      mojo::Array<interfaces::Issue::ActionType>::New(0);
+  mojoIssue->secondary_actions = std::vector<interfaces::Issue::ActionType>();
   mojoIssue->severity = interfaces::Issue::Severity::WARNING;
   mojoIssue->is_blocking = false;
   mojoIssue->help_page_id = -1;
   return mojoIssue;
 }
 
 interfaces::MediaRoutePtr CreateMojoRoute() {
   interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
-  route->media_source = kSource;
+  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->incognito = false;
   return route;
 }
 
 }  // namespace
@@ skipping 92 matching lines @@
                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(mojo::String instance_id));
+  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(mojo::String(kSource), mojo::String(kSinkId), _,
-                          mojo::String(kOrigin), kInvalidTabId, _, _, _))
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& sink,
-             const mojo::String& presentation_id, const mojo::String& origin,
+          [](const std::string& source, const std::string& sink,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(CreateMojoRoute(), mojo::String(),
+            cb.Run(CreateMojoRoute(), std::string(),
                    interfaces::RouteRequestResultCode::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();
 }
 
 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(mojo::String(kSource), mojo::String(kSinkId), _,
-                          mojo::String(kOrigin), kInvalidTabId, _, _, _))
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& sink,
-             const mojo::String& presentation_id, const mojo::String& origin,
+          [](const std::string& source, const std::string& sink,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             interfaces::MediaRoutePtr route = CreateMojoRoute();
-            route->custom_controller_path = "custom/controller/path";
+            route->custom_controller_path =
+                std::string("custom/controller/path");
             route->incognito = true;
-            cb.Run(std::move(route), mojo::String(),
+            cb.Run(std::move(route), std::string(),
                    interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
-                  mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
+      CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId, kTimeoutMillis,
+                  _, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& sink,
-             const mojo::String& presentation_id, const mojo::String& origin,
+          [](const std::string& source, const std::string& sink,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
+            cb.Run(interfaces::MediaRoutePtr(), std::string(kError),
                    interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) {
   EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
-                          mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis,
-                          true, _))
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
+                          kTimeoutMillis, true, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& sink,
-             const mojo::String& presentation_id, const mojo::String& origin,
+          [](const std::string& source, const std::string& sink,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
-            cb.Run(CreateMojoRoute(), mojo::String(),
+            cb.Run(CreateMojoRoute(), std::string(),
                    interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) {
   interfaces::MediaRoutePtr route = CreateMojoRoute();
   route->incognito = true;
 
   EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
-                          mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis,
-                          true, _))
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
+                          kTimeoutMillis, true, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& sink,
-             const mojo::String& presentation_id, const mojo::String& origin,
+          [](const std::string& source, const std::string& sink,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             interfaces::MediaRoutePtr route = CreateMojoRoute();
             route->incognito = true;
-            cb.Run(std::move(route), mojo::String(),
+            cb.Run(std::move(route), std::string(),
                    interfaces::RouteRequestResultCode::OK);
           }));
   base::RunLoop run_loop;
   router()->CreateRoute(kSource, kSinkId, GURL(kOrigin), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
-  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
-  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
-                            mojo::Array<mojo::String>());
+  router()->OnRoutesUpdated(std::move(mojo_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(mojo::String(kRouteId), _))
+  EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _))
       .WillOnce(Invoke([](
-          const mojo::String& route_id,
+          const std::string& route_id,
           const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
-         cb.Run(mojo::String(), interfaces::RouteRequestResultCode::OK);
+         cb.Run(base::nullopt, interfaces::RouteRequestResultCode::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);
 
   interfaces::MediaRoutePtr route = CreateMojoRoute();
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
-  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
-  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
-                            mojo::Array<mojo::String>());
+  router()->OnRoutesUpdated(std::move(mojo_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(mojo::String(kSource), mojo::String(kPresentationId),
-                mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
+      JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
+                kTimeoutMillis, _, _))
       .WillOnce(Invoke([&route](
-          const mojo::String& source, const mojo::String& presentation_id,
-          const mojo::String& origin, int tab_id, int64_t timeout_millis,
+          const std::string& source, const std::string& presentation_id,
+          const std::string& origin, int tab_id, int64_t timeout_millis,
           bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), mojo::String(),
+        cb.Run(std::move(route), std::string(),
                interfaces::RouteRequestResultCode::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(
@@ skipping 15 matching lines @@
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteTimedOutFails) {
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
-  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = CreateMojoRoute();
-  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
-                            mojo::Array<mojo::String>());
+  router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
+                            std::vector<std::string>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   EXPECT_CALL(
       mock_media_route_provider_,
-      JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
-                mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
+      JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
+                kTimeoutMillis, _, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& presentation_id,
-             const mojo::String& origin, int tab_id, int64_t timeout_millis,
+          [](const std::string& source, const std::string& presentation_id,
+             const std::string& origin, int tab_id, int64_t timeout_millis,
              bool incognito,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
+            cb.Run(interfaces::MediaRoutePtr(), std::string(kError),
                    interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteIncognitoMismatchFails) {
   interfaces::MediaRoutePtr route = CreateMojoRoute();
 
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
-  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
-  router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
-                            mojo::Array<mojo::String>());
+  router()->OnRoutesUpdated(std::move(mojo_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(mojo::String(kSource), mojo::String(kPresentationId),
-                mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, true, _))
+      JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
+                kTimeoutMillis, true, _))
       .WillOnce(Invoke([&route](
-          const mojo::String& source, const mojo::String& presentation_id,
-          const mojo::String& origin, int tab_id, int64_t timeout_millis,
+          const std::string& source, const std::string& presentation_id,
+          const std::string& origin, int tab_id, int64_t timeout_millis,
           bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), mojo::String(),
+        cb.Run(std::move(route), std::string(),
                interfaces::RouteRequestResultCode::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;
@@ skipping 10 matching lines @@
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(false);
   interfaces::MediaRoutePtr route = CreateMojoRoute();
 
   // 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(mojo::String(kSource), mojo::String(kRouteId), _,
-                            mojo::String(kOrigin), kInvalidTabId,
+      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
                             kTimeoutMillis, false, _))
       .WillOnce(Invoke([&route](
-          const mojo::String& source, const mojo::String& route_id,
-          const mojo::String& presentation_id, const mojo::String& origin,
+          const std::string& source, const std::string& route_id,
+          const std::string& presentation_id, const std::string& origin,
           int tab_id, int64_t timeout_millis, bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), mojo::String(),
+        cb.Run(std::move(route), std::string(),
                interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      ConnectRouteByRouteId(mojo::String(kSource), mojo::String(kRouteId), _,
-                            mojo::String(kOrigin), kInvalidTabId,
+      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
                             kTimeoutMillis, true, _))
       .WillOnce(Invoke(
-          [](const mojo::String& source, const mojo::String& route_id,
-             const mojo::String& presentation_id, const mojo::String& origin,
+          [](const std::string& source, const std::string& route_id,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
+            cb.Run(interfaces::MediaRoutePtr(), std::string(kError),
                    interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) {
   interfaces::MediaRoutePtr route = CreateMojoRoute();
 
   // 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(mojo::String(kSource), mojo::String(kRouteId), _,
-                            mojo::String(kOrigin), kInvalidTabId,
+      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
                             kTimeoutMillis, true, _))
       .WillOnce(Invoke([&route](
-          const mojo::String& source, const mojo::String& route_id,
-          const mojo::String& presentation_id, const mojo::String& origin,
+          const std::string& source, const std::string& route_id,
+          const std::string& presentation_id, const std::string& origin,
           int tab_id, int64_t timeout_millis, bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(std::move(route), mojo::String(),
+        cb.Run(std::move(route), std::string(),
                interfaces::RouteRequestResultCode::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();
 }
 
 TEST_F(MediaRouterMojoImplTest, DetachRoute) {
   base::RunLoop run_loop;
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)))
+  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(mojo::String(kRouteId), _))
+  EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _))
       .WillOnce(Invoke([&run_loop](
-          const mojo::String& route_id,
+          const std::string& route_id,
           const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
-        cb.Run(mojo::String(), interfaces::RouteRequestResultCode::OK);
+         cb.Run(base::nullopt, interfaces::RouteRequestResultCode::OK);
       }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute",
                           RouteRequestResult::ResultCode::OK,
                           1);
 }
 
 TEST_F(MediaRouterMojoImplTest, TerminateRouteFails) {
   base::RunLoop run_loop;
-  EXPECT_CALL(mock_media_route_provider_,
-              TerminateRoute(mojo::String(kRouteId), _))
+  EXPECT_CALL(mock_media_route_provider_, TerminateRoute(kRouteId, _))
       .WillOnce(Invoke([&run_loop](
           const mojo::String& route_id,
           const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
-        cb.Run(mojo::String(), interfaces::RouteRequestResultCode::TIMED_OUT);
+         cb.Run(std::string("timed out"),
+                interfaces::RouteRequestResultCode::TIMED_OUT);
       }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute",
                           RouteRequestResult::ResultCode::OK,
                           0);
   ExpectResultBucketCount("TerminateRoute",
                           RouteRequestResult::ResultCode::TIMED_OUT,
                           1);
 }
@@ skipping 53 matching lines @@
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
   MediaSource media_source(kSource);
   GURL origin("https://google.com");
 
   // These should only be called once even if there is more than one observer
   // for a given source.
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)));
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)));
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource));
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource2));
 
   std::unique_ptr<MockMediaSinksObserver> sinks_observer(
       new MockMediaSinksObserver(router(), media_source, origin));
   EXPECT_TRUE(sinks_observer->Init());
   std::unique_ptr<MockMediaSinksObserver> extra_sinks_observer(
       new MockMediaSinksObserver(router(), media_source, origin));
   EXPECT_TRUE(extra_sinks_observer->Init());
   std::unique_ptr<MockMediaSinksObserver> unrelated_sinks_observer(
       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));
 
-  mojo::Array<interfaces::MediaSinkPtr> mojo_sinks(2);
+  std::vector<interfaces::MediaSinkPtr> mojo_sinks(2);
   mojo_sinks[0] = interfaces::MediaSink::New();
   mojo_sinks[0]->sink_id = kSinkId;
   mojo_sinks[0]->name = kSinkName;
   mojo_sinks[0]->icon_type =
       media_router::interfaces::MediaSink::IconType::CAST;
   mojo_sinks[1] = interfaces::MediaSink::New();
   mojo_sinks[1]->sink_id = kSinkId2;
   mojo_sinks[1]->name = kSinkName;
   mojo_sinks[1]->icon_type =
       media_router::interfaces::MediaSink::IconType::CAST;
 
-  mojo::Array<mojo::String> mojo_origins(1);
-  mojo_origins[0] = origin.spec();
-
   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),
-                                       std::move(mojo_origins));
+  media_router_proxy_->OnSinksReceived(
+      media_source.id(), std::move(mojo_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)));
   EXPECT_TRUE(cached_sinks_observer->Init());
 
   // Different origin from cached result. Empty list will be returned.
   std::unique_ptr<MockMediaSinksObserver> cached_sinks_observer2(
       new MockMediaSinksObserver(router(), media_source,
                                  GURL("https://youtube.com")));
   EXPECT_CALL(*cached_sinks_observer2, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(cached_sinks_observer2->Init());
 
   base::RunLoop run_loop2;
-  EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource)));
-  EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource2)))
+  EXPECT_CALL(mock_media_route_provider_, StopObservingMediaSinks(kSource));
+  EXPECT_CALL(mock_media_route_provider_, StopObservingMediaSinks(kSource2))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   sinks_observer.reset();
   extra_sinks_observer.reset();
   unrelated_sinks_observer.reset();
   cached_sinks_observer.reset();
   cached_sinks_observer2.reset();
   run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest,
        RegisterMediaSinksObserverWithAvailabilityChange) {
   GURL origin("https://google.com");
 
   // When availability is UNAVAILABLE, no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::UNAVAILABLE);
   MediaSource media_source(kSource);
   std::unique_ptr<MockMediaSinksObserver> sinks_observer(
       new MockMediaSinksObserver(router(), media_source, origin));
   EXPECT_CALL(*sinks_observer, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer->Init());
   MediaSource media_source2(kSource2);
   std::unique_ptr<MockMediaSinksObserver> sinks_observer2(
       new MockMediaSinksObserver(router(), media_source2, origin));
   EXPECT_CALL(*sinks_observer2, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer2->Init());
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)))
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource))
       .Times(0);
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)))
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource2))
       .Times(0);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability transitions AVAILABLE, existing sink queries should be
   // sent to MRPM.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)))
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource))
       .Times(1);
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)))
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource2))
       .Times(1);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // No change in availability status; no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource)))
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource))
       .Times(0);
-  EXPECT_CALL(mock_media_route_provider_,
-              StartObservingMediaSinks(mojo::String(kSource2)))
+  EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource2))
       .Times(0);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability is UNAVAILABLE, queries are already removed from MRPM.
   // Unregistering observer won't result in call to MRPM to remove query.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::UNAVAILABLE);
-  EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource)))
+  EXPECT_CALL(mock_media_route_provider_, StopObservingMediaSinks(kSource))
       .Times(0);
   sinks_observer.reset();
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability is AVAILABLE, call is made to MRPM to remove query when
   // observer is unregistered.
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SinkAvailability::AVAILABLE);
-  EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaSinks(mojo::String(kSource2)));
+  EXPECT_CALL(mock_media_route_provider_, StopObservingMediaSinks(kSource2));
   sinks_observer2.reset();
   ProcessEventLoop();
 }
 
 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())))
+              StartObservingMediaRoutes(media_source.id()))
       .Times(2);
   EXPECT_CALL(
       mock_media_route_provider_,
-      StartObservingMediaRoutes(mojo::String(different_media_source.id())))
+      StartObservingMediaRoutes(different_media_source.id()))
       .Times(1);
 
   MediaRoutesObserver* observer_captured;
   EXPECT_CALL(mock_router, RegisterMediaRoutesObserver(_))
       .Times(3)
       .WillRepeatedly(SaveArg<0>(&observer_captured));
   MockMediaRoutesObserver routes_observer(&mock_router, media_source.id());
   EXPECT_EQ(observer_captured, &routes_observer);
   MockMediaRoutesObserver extra_routes_observer(&mock_router,
                                                 media_source.id());
   EXPECT_EQ(observer_captured, &extra_routes_observer);
   MockMediaRoutesObserver different_routes_observer(
       &mock_router, different_media_source.id());
   EXPECT_EQ(observer_captured, &different_routes_observer);
   router()->RegisterMediaRoutesObserver(&routes_observer);
   router()->RegisterMediaRoutesObserver(&extra_routes_observer);
   router()->RegisterMediaRoutesObserver(&different_routes_observer);
 
   std::vector<MediaRoute> expected_routes;
   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);
 
-  mojo::Array<mojo::String> mojo_joinable_routes(2);
+  std::vector<std::string> mojo_joinable_routes(2);
   mojo_joinable_routes[0] = kJoinableRouteId;
   mojo_joinable_routes[1] = kJoinableRouteId2;
 
-  mojo::Array<interfaces::MediaRoutePtr> mojo_routes(2);
+  std::vector<interfaces::MediaRoutePtr> mojo_routes(2);
   mojo_routes[0] = CreateMojoRoute();
   mojo_routes[1] = CreateMojoRoute();
   mojo_routes[1]->media_route_id = kRouteId2;
   mojo_routes[1]->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));
   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);
   EXPECT_CALL(mock_media_route_provider_,
-              StopObservingMediaRoutes(mojo::String(media_source.id())))
+              StopObservingMediaRoutes(media_source.id()))
       .Times(1);
   EXPECT_CALL(
       mock_media_route_provider_,
-      StopObservingMediaRoutes(mojo::String(different_media_source.id())));
+      StopObservingMediaRoutes(different_media_source.id()));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteMessage) {
   EXPECT_CALL(
-      mock_media_route_provider_,
-      SendRouteMessage(mojo::String(kRouteId), mojo::String(kMessage), _))
+      mock_media_route_provider_, SendRouteMessage(kRouteId, kMessage, _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::string& message,
           const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
         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(mojo::String(kRouteId), _, _))
+              SendRouteBinaryMessageInternal(kRouteId, _, _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
           const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
         EXPECT_EQ(
             0, memcmp(kBinaryMessage, &(data[0]), arraysize(kBinaryMessage)));
         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();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesSingleObserver) {
-  mojo::Array<interfaces::RouteMessagePtr> mojo_messages(2);
+  std::vector<interfaces::RouteMessagePtr> mojo_messages(2);
   mojo_messages[0] = interfaces::RouteMessage::New();
   mojo_messages[0]->type = interfaces::RouteMessage::Type::TEXT;
-  mojo_messages[0]->message = "text";
+  mojo_messages[0]->message = std::string("text");
   mojo_messages[1] = interfaces::RouteMessage::New();
   mojo_messages[1]->type = interfaces::RouteMessage::Type::BINARY;
-  mojo_messages[1]->data.push_back(1);
+  mojo_messages[1]->data = std::vector<uint8_t>(1, UINT8_C(1));
 
   ScopedVector<content::PresentationSessionMessage> expected_messages;
   std::unique_ptr<content::PresentationSessionMessage> message;
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::TEXT));
   message->message = "text";
   expected_messages.push_back(std::move(message));
 
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::ARRAY_BUFFER));
-  message->data.reset(new std::vector<uint8_t>(1, 1));
+  message->data.reset(new std::vector<uint8_t>(1, UINT8_C(1)));
   expected_messages.push_back(std::move(message));
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   EXPECT_CALL(mock_media_route_provider_,
               StartListeningForRouteMessages(Eq(expected_route_id)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
 
   // |pass_ownership| param is |true| here because there is only one observer.
   ListenForMessagesCallbackHandler handler(std::move(expected_messages), true);
 
   // Creating PresentationSessionMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
   std::unique_ptr<PresentationSessionMessagesObserver> observer(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   run_loop.Run();
 
   EXPECT_CALL(handler, InvokeObserver());
   router()->OnRouteMessagesReceived(expected_route_id,
                                     std::move(mojo_messages));
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesMultipleObservers) {
-  mojo::Array<interfaces::RouteMessagePtr> mojo_messages(2);
+  std::vector<interfaces::RouteMessagePtr> mojo_messages(2);
   mojo_messages[0] = interfaces::RouteMessage::New();
   mojo_messages[0]->type = interfaces::RouteMessage::Type::TEXT;
-  mojo_messages[0]->message = "text";
+  mojo_messages[0]->message = std::string("text");
   mojo_messages[1] = interfaces::RouteMessage::New();
   mojo_messages[1]->type = interfaces::RouteMessage::Type::BINARY;
-  mojo_messages[1]->data.push_back(1);
+  mojo_messages[1]->data = std::vector<uint8_t>(1, UINT8_C(1));
 
   ScopedVector<content::PresentationSessionMessage> expected_messages;
   std::unique_ptr<content::PresentationSessionMessage> message;
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::TEXT));
   message->message = "text";
   expected_messages.push_back(std::move(message));
 
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::ARRAY_BUFFER));
-  message->data.reset(new std::vector<uint8_t>(1, 1));
+  message->data.reset(new std::vector<uint8_t>(1, UINT8_C(1)));
   expected_messages.push_back(std::move(message));
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   EXPECT_CALL(mock_media_route_provider_,
               StartListeningForRouteMessages(Eq(expected_route_id)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
 
   // |pass_ownership| param is |false| here because there are more than one
   // observers.
@@ skipping 90 matching lines @@
       .Times(2)
       .WillOnce(Return(true))
       .WillOnce(DoAll(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }),
                       Return(true)));
   router()->DetachRoute(kRouteId);
   router()->DetachRoute(kRouteId2);
   run_loop.Run();
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(2)
       .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(kRouteId));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2));
   ConnectProviderManagerService();
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, SearchSinks) {
   std::string search_input("input");
   std::string domain("google.com");
   MediaSource media_source(kSource);
 
   EXPECT_CALL(
-      mock_media_route_provider_,
-      SearchSinks_(mojo::String(kSinkId), mojo::String(kSource), _, _))
+      mock_media_route_provider_, SearchSinks_(kSinkId, kSource, _, _))
       .WillOnce(Invoke([&search_input, &domain](
-          const mojo::String& sink_id, const mojo::String& source,
+          const std::string& sink_id, const std::string& source,
           const interfaces::SinkSearchCriteriaPtr& search_criteria,
           const interfaces::MediaRouteProvider::SearchSinksCallback& cb) {
         EXPECT_EQ(search_input, search_criteria->input);
         EXPECT_EQ(domain, search_criteria->domain);
         cb.Run(kSinkId2);
       }));
 
   SinkResponseCallbackHandler sink_handler;
   EXPECT_CALL(sink_handler, Invoke(kSinkId2)).Times(1);
   MediaSinkSearchResponseCallback sink_callback = base::Bind(
@@ skipping 114 matching lines @@
   // |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("")))
       .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(mojo::String(kRouteId)))
+  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("")))
       .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(mojo::String(kRouteId2)))
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2))
       .WillOnce(InvokeWithoutArgs([&run_loop5]() { run_loop5.Quit(); }));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   run_loop4.Run();
   run_loop5.Run();
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
   ExpectWakeupBucketCount(MediaRouteProviderWakeup::SUCCESS, 1);
   ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
                            1);
 }
@@ skipping 88 matching lines @@
   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("")))
       .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(mojo::String(kRouteId2)))
+  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(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false)).WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_,
-              UpdateMediaSinks(mojo::String(MediaSourceForDesktop().id())))
+              UpdateMediaSinks(MediaSourceForDesktop().id()))
       .Times(2);
   // EnableMdnsDisocvery() is never called except on Windows.
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
                   run_loop2.Quit();
                 }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
   // Should not call EnableMdnsDiscovery, but will call UpdateMediaSinks
@@ skipping 19 matching lines @@
   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(*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(mojo::String(kRouteId)));
+  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId));
   EXPECT_CALL(mock_media_route_provider_,
-              UpdateMediaSinks(mojo::String(MediaSourceForDesktop().id())));
+              UpdateMediaSinks(MediaSourceForDesktop().id()));
   // EnableMdnsDisocvery() 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
@@ skipping 26 matching lines @@
   run_loop.Run();
 
   media_router_->OnUserGesture();
 
   base::RunLoop run_loop2;
 
 #if defined(OS_WIN)
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery());
 #endif
   EXPECT_CALL(mock_media_route_provider_,
-              UpdateMediaSinks(mojo::String(MediaSourceForDesktop().id())))
+              UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router