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 258 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.
-  GURL origin(chrome::kChromeUIMediaRouterURL);
+  url::Origin origin((GURL(chrome::kChromeUIMediaRouterURL)));

[mark a. foltz, 2017/01/17 21:30:45]

Extra ()

[steimel, 2017/01/18 01:52:35]

The extra () are needed or else I get a compile error for the line
disambiguating into a function declaration. The error says to add the extra
parens to let the compiler know it's a variable

 
   // 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 21 matching lines @@
         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_url().GetOrigin());
+      url::Origin(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;
-  GURL origin;
+  url::Origin 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,
-    GURL* origin,
+    url::Origin* 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_url().GetOrigin()
-                               : GURL(chrome::kChromeUIMediaRouterURL);
+  *origin = for_default_source
+                ? url::Origin(presentation_request_->frame_url().GetOrigin())
+                : url::Origin(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;
-  GURL origin;
+  url::Origin 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;
-  GURL origin;
+  url::Origin 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 95 matching lines @@
 }
 
 std::string MediaRouterUI::GetSerializedInitiatorOrigin() const {
   url::Origin origin = initiator_
                            ? url::Origin(initiator_->GetLastCommittedURL())
                            : url::Origin();
   return origin.Serialize();
 }
 
 }  // namespace media_router