[Media Router] Rename mojo namespace from interfaces to 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>
@@ skipping 41 matching lines @@
 using testing::Mock;
 using testing::Not;
 using testing::Pointee;
 using testing::Return;
 using testing::ReturnRef;
 using testing::SaveArg;
 
 namespace media_router {
 
 using PresentationConnectionState =
-    interfaces::MediaRouter::PresentationConnectionState;
+    mojom::MediaRouter::PresentationConnectionState;
 using PresentationConnectionCloseReason =
-    interfaces::MediaRouter::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";
@@ skipping 11 matching lines @@
 bool ArePresentationSessionMessagesEqual(
     const content::PresentationSessionMessage* expected,
     const content::PresentationSessionMessage* actual) {
   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();
+mojom::IssuePtr CreateMojoIssue(const std::string& title) {
+  mojom::IssuePtr mojoIssue = mojom::Issue::New();
   mojoIssue->title = title;
   mojoIssue->message = std::string("msg");
   mojoIssue->route_id = std::string();
-  mojoIssue->default_action = interfaces::Issue::ActionType::DISMISS;
-  mojoIssue->secondary_actions = std::vector<interfaces::Issue::ActionType>();
-  mojoIssue->severity = interfaces::Issue::Severity::WARNING;
+  mojoIssue->default_action = mojom::Issue::ActionType::DISMISS;
+  mojoIssue->secondary_actions = std::vector<mojom::Issue::ActionType>();
+  mojoIssue->severity = mojom::Issue::Severity::WARNING;
   mojoIssue->is_blocking = false;
   mojoIssue->help_page_id = -1;
   return mojoIssue;
 }
 
-interfaces::MediaRoutePtr CreateMojoRoute() {
-  interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
+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->incognito = false;
   return route;
 }
 
@@ skipping 110 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, int64_t timeout_millis, bool incognito,
-             const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
+             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(CreateMojoRoute(), std::string(),
-                   interfaces::RouteRequestResultCode::OK);
+                   mojom::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)));
@@ skipping 11 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, int64_t timeout_millis, bool incognito,
-             const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
-            interfaces::MediaRoutePtr route = CreateMojoRoute();
+             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+            mojom::MediaRoutePtr route = CreateMojoRoute();
             route->custom_controller_path =
                 std::string("custom/controller/path");
             route->incognito = true;
             cb.Run(std::move(route), std::string(),
-                   interfaces::RouteRequestResultCode::OK);
+                   mojom::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(kSource, kSinkId, _, kOrigin, kInvalidTabId, kTimeoutMillis,
                   _, _))
       .WillOnce(Invoke(
           [](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(), std::string(kError),
-                   interfaces::RouteRequestResultCode::TIMED_OUT);
+             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+            cb.Run(mojom::MediaRoutePtr(), std::string(kError),
+                   mojom::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(kSource, kSinkId, _, kOrigin, kInvalidTabId,
                           kTimeoutMillis, true, _))
       .WillOnce(Invoke(
           [](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) {
+             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(CreateMojoRoute(), std::string(),
-                   interfaces::RouteRequestResultCode::OK);
+                   mojom::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();
+  mojom::MediaRoutePtr route = CreateMojoRoute();
   route->incognito = true;
 
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
                           kTimeoutMillis, true, _))
       .WillOnce(Invoke(
           [](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();
+             const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
+            mojom::MediaRoutePtr route = CreateMojoRoute();
             route->incognito = true;
             cb.Run(std::move(route), std::string(),
-                   interfaces::RouteRequestResultCode::OK);
+                   mojom::RouteRequestResultCode::OK);
           }));
   base::RunLoop run_loop;
   router()->CreateRoute(kSource, kSinkId, GURL(kOrigin), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
-  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<mojom::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   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(kRouteId, _))
       .WillOnce(Invoke([](
           const std::string& route_id,
-          const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
-         cb.Run(base::nullopt, interfaces::RouteRequestResultCode::OK);
+          const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+         cb.Run(base::nullopt, mojom::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();
+  mojom::MediaRoutePtr route = CreateMojoRoute();
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
-  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<mojom::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   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(kSource, kPresentationId, kOrigin, kInvalidTabId,
                 kTimeoutMillis, _, _))
       .WillOnce(Invoke([&route](
           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) {
+          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
-               interfaces::RouteRequestResultCode::OK);
+               mojom::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)));
@@ skipping 14 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.
-  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<mojom::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = CreateMojoRoute();
   router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
                             std::vector<std::string>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
                 kTimeoutMillis, _, _))
       .WillOnce(Invoke(
           [](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(), std::string(kError),
-                   interfaces::RouteRequestResultCode::TIMED_OUT);
+             const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            cb.Run(mojom::MediaRoutePtr(), std::string(kError),
+                   mojom::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();
+  mojom::MediaRoutePtr route = CreateMojoRoute();
 
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
-  std::vector<interfaces::MediaRoutePtr> mojo_routes(1);
+  std::vector<mojom::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   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(kSource, kPresentationId, kOrigin, kInvalidTabId,
                 kTimeoutMillis, true, _))
       .WillOnce(Invoke([&route](
           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) {
+          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
-               interfaces::RouteRequestResultCode::OK);
+               mojom::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()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteId) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(false);
-  interfaces::MediaRoutePtr route = CreateMojoRoute();
+  mojom::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(kSource, kRouteId, _, kOrigin, kInvalidTabId,
                             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, int64_t timeout_millis, bool incognito,
-          const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
+          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
-               interfaces::RouteRequestResultCode::OK);
+               mojom::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(kSource, kRouteId, _, kOrigin, kInvalidTabId,
                             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, int64_t timeout_millis, bool incognito,
-             const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-            cb.Run(interfaces::MediaRoutePtr(), std::string(kError),
-                   interfaces::RouteRequestResultCode::TIMED_OUT);
+             const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
+            cb.Run(mojom::MediaRoutePtr(), std::string(kError),
+                   mojom::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();
+  mojom::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(kSource, kRouteId, _, kOrigin, kInvalidTabId,
                             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, int64_t timeout_millis, bool incognito,
-          const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
+          const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
-               interfaces::RouteRequestResultCode::OK);
+               mojom::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(
@@ skipping 10 matching lines @@
       .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([&run_loop](
           const std::string& route_id,
-          const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
-         cb.Run(base::nullopt, interfaces::RouteRequestResultCode::OK);
+          const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
+         cb.Run(base::nullopt, mojom::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(kRouteId, _))
       .WillOnce(Invoke([&run_loop](
           const mojo::String& route_id,
-          const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
+          const mojom::MediaRouteProvider::TerminateRouteCallback& cb) {
          cb.Run(std::string("timed out"),
-                interfaces::RouteRequestResultCode::TIMED_OUT);
+                mojom::RouteRequestResultCode::TIMED_OUT);
       }));
   router()->TerminateRoute(kRouteId);
   run_loop.RunUntilIdle();
   ExpectResultBucketCount("TerminateRoute",
                           RouteRequestResult::ResultCode::OK,
                           0);
   ExpectResultBucketCount("TerminateRoute",
                           RouteRequestResult::ResultCode::TIMED_OUT,
                           1);
 }
 
 TEST_F(MediaRouterMojoImplTest, HandleIssue) {
   MockIssuesObserver issue_observer1(router());
   MockIssuesObserver issue_observer2(router());
   issue_observer1.RegisterObserver();
   issue_observer2.RegisterObserver();
 
-  interfaces::IssuePtr mojo_issue1 = CreateMojoIssue("title 1");
+  mojom::IssuePtr mojo_issue1 = CreateMojoIssue("title 1");
   const Issue& expected_issue1 = mojo_issue1.To<Issue>();
 
   const Issue* issue;
   EXPECT_CALL(issue_observer1,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))))
       .WillOnce(SaveArg<0>(&issue));
   base::RunLoop run_loop;
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   media_router_proxy_->OnIssue(std::move(mojo_issue1));
   run_loop.Run();
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer1, OnIssueUpdated(nullptr));
   EXPECT_CALL(issue_observer2, OnIssueUpdated(nullptr));
 
   router()->ClearIssue(issue->id());
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
   router()->UnregisterIssuesObserver(&issue_observer1);
-  interfaces::IssuePtr mojo_issue2 = CreateMojoIssue("title 2");
+  mojom::IssuePtr mojo_issue2 = CreateMojoIssue("title 2");
   const Issue& expected_issue2 = mojo_issue2.To<Issue>();
 
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))));
   router()->AddIssue(expected_issue2);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer2, OnIssueUpdated(nullptr));
   router()->ClearIssue(issue->id());
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   base::RunLoop run_loop2;
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   media_router_proxy_->OnIssue(std::move(mojo_issue2));
   run_loop2.Run();
 
   issue_observer1.UnregisterObserver();
   issue_observer2.UnregisterObserver();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
-      interfaces::MediaRouter::SinkAvailability::AVAILABLE);
+      mojom::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(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));
 
-  std::vector<interfaces::MediaSinkPtr> mojo_sinks(2);
-  mojo_sinks[0] = interfaces::MediaSink::New();
+  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::interfaces::MediaSink::IconType::CAST;
-  mojo_sinks[1] = interfaces::MediaSink::New();
+      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::interfaces::MediaSink::IconType::CAST;
+      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),
       std::vector<std::string>(1, origin.spec()));
   run_loop.Run();
@@ skipping 25 matching lines @@
   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);
+      mojom::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(kSource))
       .Times(0);
   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);
+      mojom::MediaRouter::SinkAvailability::AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource))
       .Times(1);
   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);
+      mojom::MediaRouter::SinkAvailability::AVAILABLE);
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource))
       .Times(0);
   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);
+      mojom::MediaRouter::SinkAvailability::UNAVAILABLE);
   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);
+      mojom::MediaRouter::SinkAvailability::AVAILABLE);
   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_,
@@ skipping 28 matching lines @@
   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<interfaces::MediaRoutePtr> mojo_routes(2);
+  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]->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));
@@ skipping 21 matching lines @@
       mock_media_route_provider_,
       StopObservingMediaRoutes(different_media_source.id()));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteMessage) {
   EXPECT_CALL(
       mock_media_route_provider_, SendRouteMessage(kRouteId, kMessage, _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::string& message,
-          const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
+          const mojom::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(kRouteId, _, _))
       .WillOnce(Invoke([](
           const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
-          const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
+          const mojom::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) {
-  std::vector<interfaces::RouteMessagePtr> mojo_messages(2);
-  mojo_messages[0] = interfaces::RouteMessage::New();
-  mojo_messages[0]->type = interfaces::RouteMessage::Type::TEXT;
+  std::vector<mojom::RouteMessagePtr> mojo_messages(2);
+  mojo_messages[0] = mojom::RouteMessage::New();
+  mojo_messages[0]->type = mojom::RouteMessage::Type::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] = mojom::RouteMessage::New();
+  mojo_messages[1]->type = mojom::RouteMessage::Type::BINARY;
   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(
@@ skipping 18 matching lines @@
                      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) {
-  std::vector<interfaces::RouteMessagePtr> mojo_messages(2);
-  mojo_messages[0] = interfaces::RouteMessage::New();
-  mojo_messages[0]->type = interfaces::RouteMessage::Type::TEXT;
+  std::vector<mojom::RouteMessagePtr> mojo_messages(2);
+  mojo_messages[0] = mojom::RouteMessage::New();
+  mojo_messages[0]->type = mojom::RouteMessage::Type::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] = mojom::RouteMessage::New();
+  mojo_messages[1]->type = mojom::RouteMessage::Type::BINARY;
   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(
@@ skipping 117 matching lines @@
 
 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_(kSinkId, kSource, _, _))
       .WillOnce(Invoke([&search_input, &domain](
           const std::string& sink_id, const std::string& source,
-          const interfaces::SinkSearchCriteriaPtr& search_criteria,
-          const interfaces::MediaRouteProvider::SearchSinksCallback& cb) {
+          const mojom::SinkSearchCriteriaPtr& search_criteria,
+          const mojom::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(
       &SinkResponseCallbackHandler::Invoke, base::Unretained(&sink_handler));
 
@@ skipping 34 matching lines @@
 
   void TearDown() override {
     media_router_.reset();
     profile_.reset();
   }
 
   // Constructs bindings so that |media_router_| delegates calls to
   // |mojo_media_router_|, which are then handled by
   // |mock_media_route_provider_service_|.
   void BindMediaRouteProvider() {
-    binding_.reset(new mojo::Binding<interfaces::MediaRouteProvider>(
+    binding_.reset(new mojo::Binding<mojom::MediaRouteProvider>(
         &mock_media_route_provider_,
         mojo::GetProxy(&media_route_provider_proxy_)));
     media_router_->BindToMojoRequest(mojo::GetProxy(&media_router_proxy_),
                                      *extension_);
   }
 
   void ResetMediaRouteProvider() {
     binding_.reset();
     media_router_->BindToMojoRequest(mojo::GetProxy(&media_router_proxy_),
                                      *extension_);
@@ skipping 27 matching lines @@
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.Wakeup",
                                         static_cast<int>(wakeup),
                                         expected_count);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<MediaRouterMojoImpl> media_router_;
   RegisterMediaRouteProviderHandler provide_handler_;
   TestProcessManager* process_manager_;
   testing::StrictMock<MockMediaRouteProvider> mock_media_route_provider_;
-  interfaces::MediaRouterPtr media_router_proxy_;
+  mojom::MediaRouterPtr media_router_proxy_;
   scoped_refptr<extensions::Extension> extension_;
 
  private:
   std::unique_ptr<TestingProfile> profile_;
-  interfaces::MediaRouteProviderPtr media_route_provider_proxy_;
-  std::unique_ptr<mojo::Binding<interfaces::MediaRouteProvider>> binding_;
+  mojom::MediaRouteProviderPtr media_route_provider_proxy_;
+  std::unique_ptr<mojo::Binding<mojom::MediaRouteProvider>> binding_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoExtensionTest);
 };
 
 TEST_F(MediaRouterMojoExtensionTest, DeferredBindingAndSuspension) {
   // DetachRoute is called before *any* extension has connected.
   // It should be queued.
   media_router_->DetachRoute(kRouteId);
 
@@ skipping 267 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router