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

chrome/browser/ui/webui/media_router/media_router_ui.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 <algorithm>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ skipping 259 matching lines @@
       icu::Collator::createInstance(icu::Locale(locale.c_str()), error));
   if (U_FAILURE(error)) {
     DLOG(ERROR) << "Failed to create collator for locale " << locale;
     collator_.reset();
   }
 
   query_result_manager_.reset(new QueryResultManager(router_));
   query_result_manager_->AddObserver(this);
 
   // Use a placeholder URL as origin for mirroring.
-  url::Origin origin{GURL(chrome::kChromeUIMediaRouterURL)};
+  GURL origin(chrome::kChromeUIMediaRouterURL);
 
   // Desktop mirror mode is always available.
   query_result_manager_->SetSourcesForCastMode(
       MediaCastMode::DESKTOP_MIRROR, {MediaSourceForDesktop()}, origin);
   initiator_ = initiator;
   SessionID::id_type tab_id = SessionTabHelper::IdForTab(initiator);
   if (tab_id != -1) {
     MediaSource mirroring_source(MediaSourceForTab(tab_id));
     query_result_manager_->SetSourcesForCastMode(MediaCastMode::TAB_MIRROR,
                                                  {mirroring_source}, origin);
@@ skipping 20 matching lines @@
     OnDefaultPresentationChanged(
         create_session_request_->presentation_request());
   }
 }
 
 void MediaRouterUI::OnDefaultPresentationChanged(
     const PresentationRequest& presentation_request) {
   std::vector<MediaSource> sources = presentation_request.GetMediaSources();
   presentation_request_.reset(new PresentationRequest(presentation_request));
   query_result_manager_->SetSourcesForCastMode(
-      MediaCastMode::DEFAULT, sources, presentation_request_->frame_origin());
+      MediaCastMode::DEFAULT, sources,
+      presentation_request_->frame_url().GetOrigin());
   // Register for MediaRoute updates.  NOTE(mfoltz): If there are multiple
   // sources that can be connected to via the dialog, this will break.  We will
   // need to observe multiple sources (keyed by sinks) in that case.  As this is
   // Cast-specific for the forseeable future, it may be simpler to plumb a new
   // observer API for this case.
   const MediaSource source_for_route_observer =
       GetSourceForRouteObserver(sources);
   routes_observer_.reset(new UIMediaRoutesObserver(
       router_, source_for_route_observer.id(),
       base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
@@ skipping 51 matching lines @@
   ui_initialized_ = true;
 
   // Register for Issue updates.
   issues_observer_.reset(new UIIssuesObserver(router_, this));
   issues_observer_->Init();
 }
 
 bool MediaRouterUI::CreateRoute(const MediaSink::Id& sink_id,
                                 MediaCastMode cast_mode) {
   MediaSource::Id source_id;
-  url::Origin origin;
+  GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
   bool incognito;
   if (!SetRouteParameters(sink_id, cast_mode, &source_id, &origin,
                           &route_response_callbacks, &timeout, &incognito)) {
     SendIssueForUnableToCast(cast_mode);
     return false;
   }
   router_->CreateRoute(source_id, sink_id, origin, initiator_,
                        route_response_callbacks, timeout, incognito);
   return true;
 }
 
 bool MediaRouterUI::SetRouteParameters(
     const MediaSink::Id& sink_id,
     MediaCastMode cast_mode,
     MediaSource::Id* source_id,
-    url::Origin* origin,
+    GURL* origin,
     std::vector<MediaRouteResponseCallback>* route_response_callbacks,
     base::TimeDelta* timeout,
     bool* incognito) {
   DCHECK(query_result_manager_.get());
   DCHECK(initiator_);
 
   // Note that there is a rarely-encountered bug, where the MediaCastMode to
   // MediaSource mapping could have been updated, between when the user clicked
   // on the UI to start a create route request, and when this function is
   // called. However, since the user does not have visibility into the
   // MediaSource, and that it occurs very rarely in practice, we leave it as-is
   // for now.
   std::unique_ptr<MediaSource> source =
       query_result_manager_->GetSourceForCastModeAndSink(cast_mode, sink_id);
   if (!source) {
     LOG(ERROR) << "No corresponding MediaSource for cast mode "
                << static_cast<int>(cast_mode) << " and sink " << sink_id;
     return false;
   }
   *source_id = source->id();
 
   bool for_default_source = cast_mode == MediaCastMode::DEFAULT;
   if (for_default_source && !presentation_request_) {
     DLOG(ERROR) << "Requested to create a route for presentation, but "
                 << "presentation request is missing.";
     return false;
   }
 
   current_route_request_id_ = ++route_request_counter_;
-  *origin = for_default_source
-                ? presentation_request_->frame_origin()
-                : url::Origin(GURL(chrome::kChromeUIMediaRouterURL));
+  *origin = for_default_source ? presentation_request_->frame_url().GetOrigin()
+                               : GURL(chrome::kChromeUIMediaRouterURL);
   DVLOG(1) << "DoCreateRoute: origin: " << *origin;
 
   // There are 3 cases. In cases (1) and (3) the MediaRouterUI will need to be
   // notified. In case (2) the dialog will be closed.
   // (1) Non-presentation route request (e.g., mirroring). No additional
   // notification necessary.
   // (2) Presentation route request for a Presentation API startSession call.
   // The startSession (CreatePresentationConnectionRequest) will need to be
   // answered with the route response.
   // (3) Browser-initiated presentation route request. If successful,
@@ skipping 25 matching lines @@
 
   *timeout = GetRouteRequestTimeout(cast_mode);
   *incognito = Profile::FromWebUI(web_ui())->IsOffTheRecord();
 
   return true;
 }
 
 bool MediaRouterUI::ConnectRoute(const MediaSink::Id& sink_id,
                                  const MediaRoute::Id& route_id) {
   MediaSource::Id source_id;
-  url::Origin origin;
+  GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
   bool incognito;
   if (!SetRouteParameters(sink_id, MediaCastMode::DEFAULT, &source_id, &origin,
                           &route_response_callbacks, &timeout, &incognito)) {
     SendIssueForUnableToCast(MediaCastMode::DEFAULT);
     return false;
   }
   router_->ConnectRouteByRouteId(source_id, route_id, origin, initiator_,
                                  route_response_callbacks, timeout, incognito);
@@ skipping 145 matching lines @@
   Close();
 }
 
 void MediaRouterUI::OnSearchSinkResponseReceived(
     MediaCastMode cast_mode,
     const MediaSink::Id& found_sink_id) {
   DVLOG(1) << "OnSearchSinkResponseReceived";
   handler_->ReturnSearchResult(found_sink_id);
 
   MediaSource::Id source_id;
-  url::Origin origin;
+  GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
   bool incognito;
   if (!SetRouteParameters(found_sink_id, cast_mode, &source_id, &origin,
                           &route_response_callbacks, &timeout, &incognito)) {
     SendIssueForUnableToCast(cast_mode);
     return;
   }
   router_->CreateRoute(source_id, found_sink_id, origin, initiator_,
                        route_response_callbacks, timeout, incognito);
@@ skipping 34 matching lines @@
       (cast_mode == MediaCastMode::DESKTOP_MIRROR)
           ? l10n_util::GetStringUTF8(
                 IDS_MEDIA_ROUTER_ISSUE_UNABLE_TO_CAST_DESKTOP)
           : l10n_util::GetStringUTF8(
                 IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB);
   AddIssue(IssueInfo(issue_title, IssueInfo::Action::DISMISS,
                      IssueInfo::Severity::WARNING));
 }
 
 GURL MediaRouterUI::GetFrameURL() const {
-  return presentation_request_ ? presentation_request_->frame_origin().GetURL()
-                               : GURL();
+  return presentation_request_ ? presentation_request_->frame_url() : GURL();
 }
 
 std::string MediaRouterUI::GetPresentationRequestSourceName() const {
   GURL gurl = GetFrameURL();
   return gurl.SchemeIs(extensions::kExtensionScheme)
              ? GetExtensionName(gurl, extensions::ExtensionRegistry::Get(
                                           Profile::FromWebUI(web_ui())))
              : GetHostFromURL(gurl);
 }
 
@@ skipping 40 matching lines @@
 }
 
 std::string MediaRouterUI::GetSerializedInitiatorOrigin() const {
   url::Origin origin = initiator_
                            ? url::Origin(initiator_->GetLastCommittedURL())
                            : url::Origin();
   return origin.Serialize();
 }
 
 }  // namespace media_router