Revert of Convert MediaRouter mojom apis to intake url::Origin objects instead of strings

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 177 matching lines @@
 
 TEST_F(MediaRouterMojoImplTest, CreateRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                          kInvalidTabId, _, _, _))
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(CreateMojoRoute(), std::string(),
                    mojom::RouteRequestResultCode::OK);
           }));
 
   base::RunLoop run_loop;
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
-  router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
-                        route_response_callbacks,
-                        base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                        false);
+  router()->CreateRoute(
+      kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
+      base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute", RouteRequestResult::ResultCode::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateIncognitoRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(true);
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
-              CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                          kInvalidTabId, _, _, _))
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             mojom::MediaRoutePtr route = CreateMojoRoute();
             route->custom_controller_path =
                 std::string("custom/controller/path");
             route->is_incognito = true;
             cb.Run(std::move(route), std::string(),
                    mojom::RouteRequestResultCode::OK);
           }));
 
   base::RunLoop run_loop;
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
-  router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
-                        route_response_callbacks,
-                        base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                        true);
+  router()->CreateRoute(
+      kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
+      base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute", RouteRequestResult::ResultCode::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                  kInvalidTabId,
+      CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
                   base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(mojom::MediaRoutePtr(), std::string(kError),
                    mojom::RouteRequestResultCode::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
-  router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
-                        route_response_callbacks,
-                        base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                        false);
+  router()->CreateRoute(
+      kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
+      base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("CreateRoute",
                           RouteRequestResult::ResultCode::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) {
-  EXPECT_CALL(
-      mock_media_route_provider_,
-      CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                  kInvalidTabId,
-                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
+                          base::TimeDelta::FromMilliseconds(kTimeoutMillis),
+                          true, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(CreateMojoRoute(), std::string(),
                    mojom::RouteRequestResultCode::OK);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
                                 RouteRequestResult::INCOGNITO_MISMATCH))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
-  router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
-                        route_response_callbacks,
-                        base::TimeDelta::FromMilliseconds(kTimeoutMillis),
-                        true);
+  router()->CreateRoute(
+      kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
+      base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount(
       "CreateRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) {
   mojom::MediaRoutePtr route = CreateMojoRoute();
   route->is_incognito = true;
 
-  EXPECT_CALL(
-      mock_media_route_provider_,
-      CreateRoute(kSource, kSinkId, _, url::Origin(GURL(kOrigin)),
-                  kInvalidTabId,
-                  base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+  EXPECT_CALL(mock_media_route_provider_,
+              CreateRoute(kSource, kSinkId, _, kOrigin, kInvalidTabId,
+                          base::TimeDelta::FromMilliseconds(kTimeoutMillis),
+                          true, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& sink,
-             const std::string& presentation_id, const url::Origin& origin,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::CreateRouteCallback& cb) {
             mojom::MediaRoutePtr route = CreateMojoRoute();
             route->is_incognito = true;
             cb.Run(std::move(route), std::string(),
                    mojom::RouteRequestResultCode::OK);
           }));
   base::RunLoop run_loop;
-  router()->CreateRoute(kSource, kSinkId, url::Origin(GURL(kOrigin)), nullptr,
+  router()->CreateRoute(kSource, kSinkId, GURL(kOrigin), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
   std::vector<mojom::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
                             std::vector<std::string>());
 
   // TODO(mfoltz): Where possible, convert other tests to use RunUntilIdle
   // instead of manually calling Run/Quit on the run loop.
@@ skipping 23 matching lines @@
   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, url::Origin(GURL(kOrigin)),
-                kInvalidTabId,
+      JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
                 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke([&route](
           const std::string& source, const std::string& presentation_id,
-          const url::Origin& origin, int tab_id, base::TimeDelta timeout,
+          const std::string& origin, int tab_id, base::TimeDelta timeout,
           bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
                mojom::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
-  router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
-                      nullptr, route_response_callbacks,
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
+                      route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute", RouteRequestResult::ResultCode::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteNotFoundFails) {
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(nullptr, "", "Route not found",
                                 RouteRequestResult::ROUTE_NOT_FOUND))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
-  router()->JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
-                      nullptr, route_response_callbacks,
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
+                      route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute",
                           RouteRequestResult::ResultCode::ROUTE_NOT_FOUND, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteTimedOutFails) {
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
   std::vector<mojom::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = CreateMojoRoute();
   router()->OnRoutesUpdated(std::move(mojo_routes), std::string(),
                             std::vector<std::string>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   EXPECT_CALL(
       mock_media_route_provider_,
-      JoinRoute(kSource, kPresentationId, url::Origin(GURL(kOrigin)),
-                kInvalidTabId,
+      JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
                 base::TimeDelta::FromMilliseconds(kTimeoutMillis), _, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& presentation_id,
-             const url::Origin& origin, int tab_id, base::TimeDelta timeout,
+             const std::string& origin, int tab_id, base::TimeDelta timeout,
              bool incognito,
              const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(mojom::MediaRoutePtr(), std::string(kError),
                    mojom::RouteRequestResultCode::TIMED_OUT);
           }));
 
   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, url::Origin(GURL(kOrigin)),
-                      nullptr, route_response_callbacks,
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
+                      route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute",
                           RouteRequestResult::ResultCode::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRouteIncognitoMismatchFails) {
   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<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, url::Origin(GURL(kOrigin)),
-                kInvalidTabId,
+      JoinRoute(kSource, kPresentationId, kOrigin, kInvalidTabId,
                 base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
       .WillOnce(Invoke([&route](
           const std::string& source, const std::string& presentation_id,
-          const url::Origin& origin, int tab_id, base::TimeDelta timeout,
+          const std::string& origin, int tab_id, base::TimeDelta timeout,
           bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
                mojom::RouteRequestResultCode::OK);
       }));
 
   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, url::Origin(GURL(kOrigin)),
-                      nullptr, route_response_callbacks,
+  router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
+                      route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount(
       "JoinRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteId) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
   expected_route.set_incognito(false);
   mojom::MediaRoutePtr route = CreateMojoRoute();
 
   // 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, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
-          base::TimeDelta::FromMilliseconds(kTimeoutMillis), false, _))
+      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
+                            base::TimeDelta::FromMilliseconds(kTimeoutMillis),
+                            false, _))
       .WillOnce(Invoke([&route](
           const std::string& source, const std::string& route_id,
-          const std::string& presentation_id, const url::Origin& origin,
+          const std::string& presentation_id, const std::string& origin,
           int tab_id, base::TimeDelta timeout, bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
                mojom::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
-      kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr,
-      route_response_callbacks,
+      kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute", RouteRequestResult::ResultCode::OK, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
-      ConnectRouteByRouteId(
-          kSource, kRouteId, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
-          base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
+                            base::TimeDelta::FromMilliseconds(kTimeoutMillis),
+                            true, _))
       .WillOnce(Invoke(
           [](const std::string& source, const std::string& route_id,
-             const std::string& presentation_id, const url::Origin& origin,
+             const std::string& presentation_id, const std::string& origin,
              int tab_id, base::TimeDelta timeout, bool incognito,
              const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(mojom::MediaRoutePtr(), std::string(kError),
                    mojom::RouteRequestResultCode::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
-      kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr,
-      route_response_callbacks,
+      kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount("JoinRoute",
                           RouteRequestResult::ResultCode::TIMED_OUT, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) {
   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, _, url::Origin(GURL(kOrigin)), kInvalidTabId,
-          base::TimeDelta::FromMilliseconds(kTimeoutMillis), true, _))
+      ConnectRouteByRouteId(kSource, kRouteId, _, kOrigin, kInvalidTabId,
+                            base::TimeDelta::FromMilliseconds(kTimeoutMillis),
+                            true, _))
       .WillOnce(Invoke([&route](
           const std::string& source, const std::string& route_id,
-          const std::string& presentation_id, const url::Origin& origin,
+          const std::string& presentation_id, const std::string& origin,
           int tab_id, base::TimeDelta timeout, bool incognito,
           const mojom::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), std::string(),
                mojom::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
                                 RouteRequestResult::INCOGNITO_MISMATCH))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
-      kSource, kRouteId, url::Origin(GURL(kOrigin)), nullptr,
-      route_response_callbacks,
+      kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
   ExpectResultBucketCount(
       "JoinRoute", RouteRequestResult::ResultCode::INCOGNITO_MISMATCH, 1);
 }
 
 TEST_F(MediaRouterMojoImplTest, DetachRoute) {
   base::RunLoop run_loop;
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
@@ skipping 67 matching lines @@
   router()->ClearIssue(issue_from_observer1.id());
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
       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,
-                                 url::Origin(GURL(kOrigin))));
+      new MockMediaSinksObserver(router(), media_source, origin));
   EXPECT_TRUE(sinks_observer->Init());
   std::unique_ptr<MockMediaSinksObserver> extra_sinks_observer(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL(kOrigin))));
+      new MockMediaSinksObserver(router(), media_source, origin));
   EXPECT_TRUE(extra_sinks_observer->Init());
   std::unique_ptr<MockMediaSinksObserver> unrelated_sinks_observer(
-      new MockMediaSinksObserver(router(), MediaSource(kSource2),
-                                 url::Origin(GURL(kOrigin))));
+      new MockMediaSinksObserver(router(), MediaSource(kSource2), origin));
   EXPECT_TRUE(unrelated_sinks_observer->Init());
   ProcessEventLoop();
 
   std::vector<MediaSink> expected_sinks;
   expected_sinks.push_back(
       MediaSink(kSinkId, kSinkName, MediaSink::IconType::CAST));
   expected_sinks.push_back(
       MediaSink(kSinkId2, kSinkName, MediaSink::IconType::CAST));
 
   std::vector<mojom::MediaSinkPtr> mojo_sinks(2);
   mojo_sinks[0] = mojom::MediaSink::New();
   mojo_sinks[0]->sink_id = kSinkId;
   mojo_sinks[0]->name = kSinkName;
   mojo_sinks[0]->icon_type =
       media_router::mojom::MediaSink::IconType::CAST;
   mojo_sinks[1] = mojom::MediaSink::New();
   mojo_sinks[1]->sink_id = kSinkId2;
   mojo_sinks[1]->name = kSinkName;
   mojo_sinks[1]->icon_type =
       media_router::mojom::MediaSink::IconType::CAST;
 
   base::RunLoop run_loop;
   EXPECT_CALL(*sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks)));
   EXPECT_CALL(*extra_sinks_observer,
               OnSinksReceived(SequenceEquals(expected_sinks)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   media_router_proxy_->OnSinksReceived(
       media_source.id(), std::move(mojo_sinks),
-      std::vector<url::Origin>(1, url::Origin(GURL(kOrigin))));
+      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,
-                                 url::Origin(GURL(kOrigin))));
+      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,
-                                 url::Origin(GURL("https://youtube.com"))));
+                                 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(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(
       mojom::MediaRouter::SinkAvailability::UNAVAILABLE);
   MediaSource media_source(kSource);
   std::unique_ptr<MockMediaSinksObserver> sinks_observer(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL(kOrigin))));
+      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,
-                                 url::Origin(GURL(kOrigin))));
+      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
@@ skipping 762 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router