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

chrome/browser/ui/webui/media_router/media_router_ui_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 "chrome/browser/ui/webui/media_router/media_router_ui.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 96 matching lines @@
         .Times(AnyNumber());
     media_router_ui_->InitForTest(&mock_router_, web_contents(),
                                   message_handler_.get(),
                                   std::move(create_session_request_));
     message_handler_->SetWebUIForTest(&web_ui_);
   }
 
   MediaSink CreateSinkCompatibleWithAllSources() {
     MediaSink sink("sinkId", "sinkName", MediaSink::GENERIC);
     for (auto* observer : media_sinks_observers_)
-      observer->OnSinksUpdated({sink}, std::vector<GURL>());
+      observer->OnSinksUpdated({sink}, std::vector<url::Origin>());
     return sink;
   }
 
  protected:
   MockMediaRouter mock_router_;
   content::TestWebUI web_ui_;
   std::unique_ptr<WebContents> web_ui_contents_;
   std::unique_ptr<CreatePresentationConnectionRequest> create_session_request_;
   std::unique_ptr<MediaRouterUI> media_router_ui_;
   std::unique_ptr<MediaRouterWebUIMessageHandler> message_handler_;
@@ skipping 35 matching lines @@
   std::unique_ptr<RouteRequestResult> result =
       RouteRequestResult::FromError("Timed out", RouteRequestResult::TIMED_OUT);
   for (const auto& callback : callbacks)
     callback.Run(*result);
 }
 
 TEST_F(MediaRouterUITest, RouteCreationTimeoutForPresentation) {
   CreateMediaRouterUI(profile());
   PresentationRequest presentation_request(
       RenderFrameHostId(0, 0), {GURL("https://presentationurl.com")},
-      GURL("https://frameurl.fakeurl"));
+      url::Origin(GURL("https://frameurl.fakeurl")));
   media_router_ui_->OnDefaultPresentationChanged(presentation_request);
   std::vector<MediaRouteResponseCallback> callbacks;
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(20), false))
       .WillOnce(SaveArg<4>(&callbacks));
   media_router_ui_->CreateRoute(CreateSinkCompatibleWithAllSources().id(),
                                 MediaCastMode::DEFAULT);
 
   std::string expected_title =
@@ skipping 17 matching lines @@
                                               "domain", MediaCastMode::DEFAULT);
   std::string expected_title = l10n_util::GetStringUTF8(
       IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB);
   EXPECT_CALL(mock_router_, AddIssue(IssueTitleEquals(expected_title)));
   sink_callback.Run("foundSinkId");
 }
 
 TEST_F(MediaRouterUITest, RouteRequestFromIncognito) {
   CreateMediaRouterUI(profile()->GetOffTheRecordProfile());
 
-  PresentationRequest presentation_request(RenderFrameHostId(0, 0),
-                                           {GURL("https://foo.url.com/")},
-                                           GURL("https://frameUrl"));
+  PresentationRequest presentation_request(
+      RenderFrameHostId(0, 0), {GURL("https://foo.url.com/")},
+      url::Origin(GURL("https://frameUrl")));
   media_router_ui_->OnDefaultPresentationChanged(presentation_request);
 
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(20), true));
   media_router_ui_->CreateRoute(CreateSinkCompatibleWithAllSources().id(),
                                 MediaCastMode::DEFAULT);
 }
 
 TEST_F(MediaRouterUITest, SortedSinks) {
@@ skipping 246 matching lines @@
 }
 
 TEST_F(MediaRouterUITest, NotFoundErrorOnCloseWithNoSinks) {
   content::PresentationError expected_error(
       content::PresentationErrorType::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
       "No screens found.");
   PresentationRequestCallbacks request_callbacks(expected_error);
   create_session_request_.reset(new CreatePresentationConnectionRequest(
       RenderFrameHostId(0, 0), {GURL("http://google.com/presentation"),
                                 GURL("http://google.com/presentation2")},
-      GURL("http://google.com"),
+      url::Origin(GURL("http://google.com")),
       base::Bind(&PresentationRequestCallbacks::Success,
                  base::Unretained(&request_callbacks)),
       base::Bind(&PresentationRequestCallbacks::Error,
                  base::Unretained(&request_callbacks))));
   CreateMediaRouterUI(profile());
   // Destroying the UI should return the expected error from above to the error
   // callback.
   media_router_ui_.reset();
 }
 
 TEST_F(MediaRouterUITest, NotFoundErrorOnCloseWithNoCompatibleSinks) {
   content::PresentationError expected_error(
       content::PresentationErrorType::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
       "No screens found.");
   PresentationRequestCallbacks request_callbacks(expected_error);
   GURL presentation_url("http://google.com/presentation");
   create_session_request_.reset(new CreatePresentationConnectionRequest(
-      RenderFrameHostId(0, 0), {presentation_url}, GURL("http://google.com"),
+      RenderFrameHostId(0, 0), {presentation_url},
+      url::Origin(GURL("http://google.com")),
       base::Bind(&PresentationRequestCallbacks::Success,
                  base::Unretained(&request_callbacks)),
       base::Bind(&PresentationRequestCallbacks::Error,
                  base::Unretained(&request_callbacks))));
   CreateMediaRouterUI(profile());
 
   // Send a sink to the UI that is compatible with sources other than the
   // presentation url to cause a NotFoundError.
   std::vector<MediaSink> sinks;
   sinks.emplace_back("sink id", "sink name", MediaSink::GENERIC);
-  std::vector<GURL> origins;
+  std::vector<url::Origin> origins;
   for (auto* observer : media_sinks_observers_) {
     if (observer->source().id() != presentation_url.spec()) {
       observer->OnSinksUpdated(sinks, origins);
     }
   }
   // Destroying the UI should return the expected error from above to the error
   // callback.
   media_router_ui_.reset();
 }
 
 TEST_F(MediaRouterUITest, AbortErrorOnClose) {
   content::PresentationError expected_error(
       content::PresentationErrorType::
           PRESENTATION_ERROR_SESSION_REQUEST_CANCELLED,
       "Dialog closed.");
   PresentationRequestCallbacks request_callbacks(expected_error);
   GURL presentation_url("http://google.com/presentation");
   create_session_request_.reset(new CreatePresentationConnectionRequest(
-      RenderFrameHostId(0, 0), {presentation_url}, GURL("http://google.com"),
+      RenderFrameHostId(0, 0), {presentation_url},
+      url::Origin(GURL("http://google.com")),
       base::Bind(&PresentationRequestCallbacks::Success,
                  base::Unretained(&request_callbacks)),
       base::Bind(&PresentationRequestCallbacks::Error,
                  base::Unretained(&request_callbacks))));
   CreateMediaRouterUI(profile());
 
   // Send a sink to the UI that is compatible with the presentation url to avoid
   // a NotFoundError.
   std::vector<MediaSink> sinks;
   sinks.emplace_back("sink id", "sink name", MediaSink::GENERIC);
-  std::vector<GURL> origins;
+  std::vector<url::Origin> origins;
   MediaSource::Id presentation_source_id =
       MediaSourceForPresentationUrl(presentation_url).id();
   for (auto* observer : media_sinks_observers_) {
     if (observer->source().id() == presentation_source_id) {
       observer->OnSinksUpdated(sinks, origins);
     }
   }
   // Destroying the UI should return the expected error from above to the error
   // callback.
   media_router_ui_.reset();
@@ skipping 51 matching lines @@
   EXPECT_FALSE(media_router_ui_->UserSelectedTabMirroringForCurrentOrigin());
 
   media_router_ui_->RecordCastModeSelection(MediaCastMode::TAB_MIRROR);
   EXPECT_TRUE(media_router_ui_->UserSelectedTabMirroringForCurrentOrigin());
   media_router_ui_->RecordCastModeSelection(MediaCastMode::DESKTOP_MIRROR);
   // Selecting desktop mirroring should not change the recorded preferences.
   EXPECT_TRUE(media_router_ui_->UserSelectedTabMirroringForCurrentOrigin());
 }
 
 }  // namespace media_router