[Media Router] Handle multiple Presentation URLs when creating routes.

chrome/browser/media/router/presentation_service_delegate_impl.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/media/router/presentation_service_delegate_impl.h"
 
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ skipping 443 matching lines @@
 
 void PresentationFrameManager::OnPresentationSessionStarted(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->OnPresentationSessionStarted(session, route_id);
 }
 
 void PresentationFrameManager::OnDefaultPresentationSessionStarted(
-    const PresentationRequest& request,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
   const auto it = presentation_frames_.find(request.render_frame_host_id());
   if (it != presentation_frames_.end())
     it->second->OnPresentationSessionStarted(session, route_id);
 
   if (default_presentation_request_ &&
       default_presentation_request_->Equals(request)) {
     default_presentation_started_callback_.Run(session);
   }
@@ skipping 56 matching lines @@
   const auto it = presentation_frames_.find(render_frame_host_id);
   if (it == presentation_frames_.end()) {
     DVLOG(2) << "ListenForSessionMessages: PresentationFrame does not exist "
              << "for: (" << render_frame_host_id.first << ", "
              << render_frame_host_id.second << ")";
     return;
   }
   it->second->ListenForSessionMessages(session, message_cb);
 }
 
-void PresentationFrameManager::SetDefaultPresentationUrl(
+void PresentationFrameManager::SetDefaultPresentationUrls(
     const RenderFrameHostId& render_frame_host_id,
-    const GURL& default_presentation_url,
+    const vector<GURL>& default_presentation_urls,
     const content::PresentationSessionStartedCallback& callback) {
   if (!IsMainFrame(render_frame_host_id))
     return;
 
-  if (default_presentation_url.is_empty()) {
+  if (default_presentation_urls.is_empty()) {
     ClearDefaultPresentationRequest();
   } else {
     DCHECK(!callback.is_null());
     GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
     PresentationRequest request(render_frame_host_id,
-                                std::vector<GURL>({default_presentation_url}),
+                                default_presentation_urls,
                                 frame_url);
     default_presentation_started_callback_ = callback;
     SetDefaultPresentationRequest(request);
   }
 }
 
 void PresentationFrameManager::AddDelegateObserver(
     const RenderFrameHostId& render_frame_host_id,
     DelegateObserver* observer) {
   auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
@@ skipping 146 matching lines @@
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   frame_manager_->Reset(render_frame_host_id);
 }
 
 void PresentationServiceDelegateImpl::SetDefaultPresentationUrls(
     int render_process_id,
     int render_frame_id,
     const std::vector<GURL>& default_presentation_urls,
     const content::PresentationSessionStartedCallback& callback) {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
-  if (default_presentation_urls.empty()) {
-    frame_manager_->SetDefaultPresentationUrl(render_frame_host_id, GURL(),
-                                              callback);
-  } else {
-    // TODO(crbug.com/627655): Handle multiple URLs.
-    frame_manager_->SetDefaultPresentationUrl(
-        render_frame_host_id, default_presentation_urls[0], callback);
-  }
+  frame_manager_->SetDefaultPresentationUrls(
+      render_frame_host_id, default_presentation_urls, callback);
 }
 
 void PresentationServiceDelegateImpl::OnJoinRouteResponse(
     int render_process_id,
     int render_frame_id,
     const content::PresentationSessionInfo& session,
     const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionErrorCallback& error_cb,
     const RouteRequestResult& result) {
   if (!result.route()) {
@@ skipping 33 matching lines @@
     int render_frame_id,
     const std::vector<GURL>& presentation_urls,
     const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionErrorCallback& error_cb) {
   if (presentation_urls.empty()) {
     error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
                                             "Invalid presentation arguments."));
     return;
   }
 
-  // TODO(crbug.com/627655): Handle multiple URLs.
-  const GURL& presentation_url = presentation_urls[0];
-  if (presentation_url.is_empty() ||
+  if (presentation_urls.is_empty() ||
+      std::find_if(
       !IsValidPresentationUrl(presentation_url)) {
     error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
                                             "Invalid presentation arguments."));
     return;
   }
 
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   std::unique_ptr<CreatePresentationConnectionRequest> request(
       new CreatePresentationConnectionRequest(
-          render_frame_host_id, presentation_url,
+          render_frame_host_id, presentation_urls,
           GetLastCommittedURLForFrame(render_frame_host_id),
           base::Bind(&PresentationServiceDelegateImpl::OnStartSessionSucceeded,
                      weak_factory_.GetWeakPtr(), render_process_id,
                      render_frame_id, success_cb),
           error_cb));
   MediaRouterDialogController* controller =
       MediaRouterDialogController::GetOrCreateForWebContents(web_contents_);
   if (!controller->ShowMediaRouterDialogForPresentation(std::move(request))) {
     LOG(ERROR) << "Media router dialog already exists. Ignoring StartSession.";
     error_cb.Run(content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN,
                                             "Unable to create dialog."));
     return;
   }
 }
 
 void PresentationServiceDelegateImpl::JoinSession(
     int render_process_id,
     int render_frame_id,
     const std::vector<GURL>& presentation_urls,
     const std::string& presentation_id,
     const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionErrorCallback& error_cb) {
   if (presentation_urls.empty()) {
     error_cb.Run(content::PresentationError(
         content::PRESENTATION_ERROR_NO_PRESENTATION_FOUND,
         "Invalid presentation arguments."));
   }
 
-  // TODO(crbug.com/627655): Handle multiple URLs.
-  const GURL& presentation_url = presentation_urls[0];
-  bool incognito = web_contents_->GetBrowserContext()->IsOffTheRecord();
-  std::vector<MediaRouteResponseCallback> route_response_callbacks;
-  route_response_callbacks.push_back(base::Bind(
-      &PresentationServiceDelegateImpl::OnJoinRouteResponse,
-      weak_factory_.GetWeakPtr(), render_process_id, render_frame_id,
-      content::PresentationSessionInfo(presentation_url, presentation_id),
-      success_cb, error_cb));
-  router_->JoinRoute(
-      MediaSourceForPresentationUrl(presentation_url).id(), presentation_id,
-      GetLastCommittedURLForFrame(
-          RenderFrameHostId(render_process_id, render_frame_id))
-          .GetOrigin(),
-      web_contents_, route_response_callbacks, base::TimeDelta(), incognito);
+  // TODO: Needs work
+  // bool incognito = web_contents_->GetBrowserContext()->IsOffTheRecord();
+  // std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  // route_response_callbacks.push_back(base::Bind(
+  //     &PresentationServiceDelegateImpl::OnJoinRouteResponse,
+  //     weak_factory_.GetWeakPtr(), render_process_id, render_frame_id,
+  //     content::PresentationSessionInfo(presentation_urls, presentation_id),
+  //     success_cb, error_cb));
+  // router_->JoinRoute(
+  //     MediaSourceForPresentationUrl(presentation_url).id(), presentation_id,
+  //     GetLastCommittedURLForFrame(
+  //         RenderFrameHostId(render_process_id, render_frame_id))
+  //         .GetOrigin(),
+  //     web_contents_, route_response_callbacks, base::TimeDelta(), incognito);
 }
 
 void PresentationServiceDelegateImpl::CloseConnection(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_id) {
   const RenderFrameHostId rfh_id(render_process_id, render_frame_id);
   const MediaRoute::Id& route_id =
       frame_manager_->GetRouteId(rfh_id, presentation_id);
   if (route_id.empty()) {
@@ skipping 62 matching lines @@
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   frame_manager_->ListenForConnectionStateChange(
       RenderFrameHostId(render_process_id, render_frame_id), connection,
       state_changed_cb);
 }
 
 void PresentationServiceDelegateImpl::OnRouteResponse(
     const PresentationRequest& presentation_request,
+    const GURL& presentation_url,
     const RouteRequestResult& result) {
-  if (!result.route())
+  if (!result.route() ||
+      base::STLCount(presentation_request.presentation_urls(),
+                     presentation_url) == 0) {
     return;
+  }
 
   content::PresentationSessionInfo session_info(
-      presentation_request.presentation_url(), result.presentation_id());
+      presentation_url, result.presentation_id());
   frame_manager_->OnDefaultPresentationSessionStarted(
       presentation_request, session_info, result.route()->media_route_id());
 }
 
 void PresentationServiceDelegateImpl::AddDefaultPresentationRequestObserver(
     DefaultPresentationRequestObserver* observer) {
   frame_manager_->AddDefaultPresentationRequestObserver(observer);
 }
 
 void PresentationServiceDelegateImpl::RemoveDefaultPresentationRequestObserver(
@@ skipping 25 matching lines @@
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router