[Presentation API] Add support for multiple URLs in PresentationRequest on Media Router UI side

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>
 
 #include "base/guid.h"
 #include "base/i18n/string_compare.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 259 matching lines @@
   }
 
   query_result_manager_.reset(new QueryResultManager(router_));
   query_result_manager_->AddObserver(this);
 
   // Use a placeholder URL as origin for mirroring.
   GURL origin(chrome::kChromeUIMediaRouterURL);
 
   // Desktop mirror mode is always available.
   query_result_manager_->StartSinksQuery(MediaCastMode::DESKTOP_MIRROR,
-                                         MediaSourceForDesktop(), origin);
+                                         {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_->StartSinksQuery(MediaCastMode::TAB_MIRROR,
-                                           mirroring_source, origin);
+                                           {mirroring_source}, origin);
   }
   UpdateCastModes();
 }
 
 void MediaRouterUI::InitForTest(
     MediaRouter* router,
     content::WebContents* initiator,
     MediaRouterWebUIMessageHandler* handler,
     std::unique_ptr<CreatePresentationConnectionRequest>
         create_session_request) {
   router_ = router;
   handler_ = handler;
   create_session_request_ = std::move(create_session_request);
   InitCommon(initiator);
   if (create_session_request_) {
     OnDefaultPresentationChanged(
         create_session_request_->presentation_request());
   }
 }
 
 void MediaRouterUI::OnDefaultPresentationChanged(
     const PresentationRequest& presentation_request) {
-  MediaSource source = presentation_request.GetMediaSource();
+  std::vector<MediaSource> sources = presentation_request.GetMediaSources();
   presentation_request_.reset(new PresentationRequest(presentation_request));
   query_result_manager_->StartSinksQuery(
-      MediaCastMode::DEFAULT, source,
+      MediaCastMode::DEFAULT, sources,
       presentation_request_->frame_url().GetOrigin());
   // Register for MediaRoute updates.
+  // TODO(crbug.com/627655): Use multiple URLs.

[mark a. foltz, 2016/08/31 05:18:55]

Sigh, this is not straightforward.  The MediaRoutesObserver needs to be
redesigned to remove the need to take a MediaSource and we need to find another
way to pass the "joinable route ids".

[takumif, 2016/09/01 21:09:25]

Yeah, I wasn't sure what to do here.

   routes_observer_.reset(new UIMediaRoutesObserver(
-      router_, source.id(),
+      router_, sources[0].id(),
       base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
 
   UpdateCastModes();
 }
 
 void MediaRouterUI::OnDefaultPresentationRemoved() {
   presentation_request_.reset();
   query_result_manager_->StopSinksQuery(MediaCastMode::DEFAULT);
   // Register for MediaRoute updates without a media source.
   routes_observer_.reset(new UIMediaRoutesObserver(
@@ skipping 55 matching lines @@
     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.
-  MediaSource source = query_result_manager_->GetSourceForCastMode(cast_mode);
+  MediaSource source =
+      query_result_manager_->GetSourceForCastModeAndSink(cast_mode, sink_id);
   if (source.Empty()) {
     LOG(ERROR) << "No corresponding MediaSource for cast mode "
-               << static_cast<int>(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;
   }
@@ skipping 70 matching lines @@
 
 void MediaRouterUI::ClearIssue(const std::string& issue_id) {
   router_->ClearIssue(issue_id);
 }
 
 void MediaRouterUI::SearchSinksAndCreateRoute(
     const MediaSink::Id& sink_id,
     const std::string& search_criteria,
     const std::string& domain,
     MediaCastMode cast_mode) {
-  auto source_id = query_result_manager_->GetSourceForCastMode(cast_mode).id();
+  auto source_id = query_result_manager_->
+      GetSourceForCastModeAndSink(cast_mode, sink_id).id();
   // The CreateRoute() part of the function is accomplished in the callback
   // OnSearchSinkResponseReceived().
   router_->SearchSinks(
       sink_id, source_id, search_criteria, domain,
       base::Bind(&MediaRouterUI::OnSearchSinkResponseReceived,
                  weak_factory_.GetWeakPtr(), cast_mode));
 }
 
 void MediaRouterUI::OnResultsUpdated(
     const std::vector<MediaSinkWithCastModes>& sinks) {
@@ skipping 30 matching lines @@
 }
 
 void MediaRouterUI::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
   routes_ = routes;
   joinable_route_ids_ = joinable_route_ids;
 
   std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
   for (const auto& cast_mode : cast_modes_) {
-    available_source_map.insert(std::make_pair(
-        query_result_manager_->GetSourceForCastMode(cast_mode).id(),
-        cast_mode));
+    for (const auto& source :
+         query_result_manager_->GetSourcesForCastMode(cast_mode)) {
+      available_source_map.insert(std::make_pair(source.id(), cast_mode));
+    }
   }
 
   current_cast_modes_.clear();
   for (const auto& route : routes) {
     auto source_entry = available_source_map.find(route.media_source().id());
     if (source_entry != available_source_map.end()) {
       current_cast_modes_.insert(
           std::make_pair(route.media_route_id(), source_entry->second));
     }
   }
@@ skipping 140 matching lines @@
         base::Time::Now() - start_time_);
     start_time_ = base::Time();
   }
 }
 
 void MediaRouterUI::UpdateMaxDialogHeight(int height) {
   handler_->UpdateMaxDialogHeight(height);
 }
 
 }  // namespace media_router