[Presentation API] Add support to content/ for multiple URLs per PresentationRequest.

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
-#include <string>
 #include <utility>
-#include <vector>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/browser/presentation/presentation_type_converters.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/presentation_session_message.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 152 matching lines @@
       this, std::move(request)));
 }
 
 void PresentationServiceImpl::SetClient(
     blink::mojom::PresentationServiceClientPtr client) {
   DCHECK(!client_.get());
   // TODO(imcheng): Set ErrorHandler to listen for errors.
   client_ = std::move(client);
 }
 
-void PresentationServiceImpl::ListenForScreenAvailability(
-    const std::string& url) {
+void PresentationServiceImpl::ListenForScreenAvailability(const GURL& url) {
   DVLOG(2) << "ListenForScreenAvailability " << url;
   if (!delegate_) {
     client_->OnScreenAvailabilityUpdated(url, false);
     return;
   }
 
-  if (screen_availability_listeners_.count(url))
+  if (screen_availability_listeners_.count(url.spec()))
     return;
 
   std::unique_ptr<ScreenAvailabilityListenerImpl> listener(
-      new ScreenAvailabilityListenerImpl(url, this));
+      new ScreenAvailabilityListenerImpl(url.spec(), this));
   if (delegate_->AddScreenAvailabilityListener(
       render_process_id_,
       render_frame_id_,
       listener.get())) {
-    screen_availability_listeners_[url] = std::move(listener);
+    screen_availability_listeners_[url.spec()] = std::move(listener);
   } else {
     DVLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
   }
 }
 
 void PresentationServiceImpl::StopListeningForScreenAvailability(
-    const std::string& url) {
-  DVLOG(2) << "StopListeningForScreenAvailability " << url;
+    const GURL& url) {
+  DVLOG(2) << "StopListeningForScreenAvailability " << url.spec();
   if (!delegate_)
     return;
 
-  auto listener_it = screen_availability_listeners_.find(url);
+  auto listener_it = screen_availability_listeners_.find(url.spec());
   if (listener_it == screen_availability_listeners_.end())
     return;
 
   delegate_->RemoveScreenAvailabilityListener(
       render_process_id_, render_frame_id_, listener_it->second.get());
   screen_availability_listeners_.erase(listener_it);
 }
 
-void PresentationServiceImpl::StartSession(const std::string& presentation_url,
-                                           const NewSessionCallback& callback) {
+void PresentationServiceImpl::StartSession(
+    const std::vector<GURL>& presentation_urls,
+    const NewSessionCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!delegate_) {
     callback.Run(
         blink::mojom::PresentationSessionInfoPtr(),
         blink::mojom::PresentationError::From(PresentationError(
             PRESENTATION_ERROR_NO_AVAILABLE_SCREENS, "No screens found.")));
     return;
   }
 
   // There is a StartSession request in progress. To avoid queueing up
   // requests, the incoming request is rejected.
   if (start_session_request_id_ != kInvalidRequestSessionId) {
     InvokeNewSessionCallbackWithError(callback);
     return;
   }
 
+  std::vector<std::string> presentation_urls_for_delegate(
+      presentation_urls.size());
+  std::transform(presentation_urls.begin(), presentation_urls.end(),
+                 presentation_urls_for_delegate.begin(),
+                 [](const GURL& url) { return url.spec(); });
+
   start_session_request_id_ = GetNextRequestSessionId();
   pending_start_session_cb_.reset(new NewSessionCallbackWrapper(callback));
   delegate_->StartSession(
-      render_process_id_, render_frame_id_, presentation_url,
+      render_process_id_, render_frame_id_, presentation_urls_for_delegate,
       base::Bind(&PresentationServiceImpl::OnStartSessionSucceeded,
                  weak_factory_.GetWeakPtr(), start_session_request_id_),
       base::Bind(&PresentationServiceImpl::OnStartSessionError,
                  weak_factory_.GetWeakPtr(), start_session_request_id_));
 }
 
 void PresentationServiceImpl::JoinSession(
-    const std::string& presentation_url,
+    const std::vector<GURL>& presentation_urls,
     const base::Optional<std::string>& presentation_id,
     const NewSessionCallback& callback) {
   DVLOG(2) << "JoinSession";
   if (!delegate_) {
     callback.Run(blink::mojom::PresentationSessionInfoPtr(),
                  blink::mojom::PresentationError::From(PresentationError(
                      PRESENTATION_ERROR_NO_PRESENTATION_FOUND,
                      "Error joining route: No matching route")));
     return;
   }
 
+  std::vector<std::string> presentation_urls_for_delegate(
+      presentation_urls.size());
+  std::transform(presentation_urls.begin(), presentation_urls.end(),
+                 presentation_urls_for_delegate.begin(),
+                 [](const GURL& url) { return url.spec(); });
+
   int request_session_id = RegisterJoinSessionCallback(callback);
   if (request_session_id == kInvalidRequestSessionId) {
     InvokeNewSessionCallbackWithError(callback);
     return;
   }
   delegate_->JoinSession(
-      render_process_id_, render_frame_id_, presentation_url,
+      render_process_id_, render_frame_id_, presentation_urls_for_delegate,
       presentation_id.value_or(std::string()),
       base::Bind(&PresentationServiceImpl::OnJoinSessionSucceeded,
                  weak_factory_.GetWeakPtr(), request_session_id),
       base::Bind(&PresentationServiceImpl::OnJoinSessionError,
                  weak_factory_.GetWeakPtr(), request_session_id));
 }
 
 int PresentationServiceImpl::RegisterJoinSessionCallback(
     const NewSessionCallback& callback) {
   if (pending_join_session_cbs_.size() >= kMaxNumQueuedSessionRequests)
@@ skipping 69 matching lines @@
   auto it = pending_join_session_cbs_.find(request_session_id);
   if (it == pending_join_session_cbs_.end())
     return false;
 
   DCHECK(it->second.get());
   it->second->Run(std::move(session), std::move(error));
   pending_join_session_cbs_.erase(it);
   return true;
 }
 
-void PresentationServiceImpl::SetDefaultPresentationURL(
-    const std::string& url) {
-  DVLOG(2) << "SetDefaultPresentationURL";
+void PresentationServiceImpl::SetDefaultPresentationUrls(
+    const std::vector<GURL>& presentation_urls) {
+  DVLOG(2) << "SetDefaultPresentationUrls";
   if (!delegate_)
     return;
 
-  if (default_presentation_url_ == url)
+  std::vector<std::string> presentation_urls_for_delegate(
+      presentation_urls.size());
+  std::transform(presentation_urls.begin(), presentation_urls.end(),
+                 presentation_urls_for_delegate.begin(),
+                 [](const GURL& url) { return url.spec(); });
+
+  if (default_presentation_urls_ == presentation_urls_for_delegate)
     return;
 
-  default_presentation_url_ = url;
-  delegate_->SetDefaultPresentationUrl(
-      render_process_id_, render_frame_id_, url,
+  default_presentation_urls_ = presentation_urls_for_delegate;
+  delegate_->SetDefaultPresentationUrls(
+      render_process_id_, render_frame_id_, presentation_urls_for_delegate,
       base::Bind(&PresentationServiceImpl::OnDefaultPresentationStarted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PresentationServiceImpl::SendSessionMessage(
     blink::mojom::PresentationSessionInfoPtr session,
     blink::mojom::SessionMessagePtr session_message,
     const SendSessionMessageCallback& callback) {
   DVLOG(2) << "SendSessionMessage";
   DCHECK(!session_message.is_null());
@@ skipping 16 matching lines @@
 void PresentationServiceImpl::OnSendMessageCallback(bool sent) {
   // It is possible that Reset() is invoked before receiving this callback.
   // So, always check send_message_callback_ for non-null.
   if (send_message_callback_) {
     send_message_callback_->Run(sent);
     send_message_callback_.reset();
   }
 }
 
 void PresentationServiceImpl::CloseConnection(
-    const std::string& presentation_url,
+    const GURL& presentation_url,
     const std::string& presentation_id) {
   DVLOG(2) << "CloseConnection " << presentation_id;
   if (delegate_)
     delegate_->CloseConnection(render_process_id_, render_frame_id_,
                                presentation_id);
 }
 
-void PresentationServiceImpl::Terminate(const std::string& presentation_url,
+void PresentationServiceImpl::Terminate(const GURL& presentation_url,
                                         const std::string& presentation_id) {
   DVLOG(2) << "Terminate " << presentation_id;
   if (delegate_)
     delegate_->Terminate(render_process_id_, render_frame_id_, presentation_id);
 }
 
 void PresentationServiceImpl::OnConnectionStateChanged(
     const PresentationSessionInfo& connection,
     const PresentationConnectionStateChangeInfo& info) {
   DCHECK(client_.get());
@@ skipping 90 matching lines @@
              << "should've been deleted during RenderFrameDeleted().";
   Reset();
   delete this;
 }
 
 void PresentationServiceImpl::Reset() {
   DVLOG(2) << "PresentationServiceImpl::Reset";
   if (delegate_)
     delegate_->Reset(render_process_id_, render_frame_id_);
 
-  default_presentation_url_.clear();
+  default_presentation_urls_.clear();
 
   screen_availability_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
   if (on_session_messages_callback_.get()) {
     on_session_messages_callback_->Run(
@@ skipping 37 matching lines @@
 ~ScreenAvailabilityListenerImpl() {
 }
 
 std::string PresentationServiceImpl::ScreenAvailabilityListenerImpl
     ::GetAvailabilityUrl() const {
   return availability_url_;
 }
 
 void PresentationServiceImpl::ScreenAvailabilityListenerImpl
 ::OnScreenAvailabilityChanged(bool available) {
-  service_->client_->OnScreenAvailabilityUpdated(availability_url_, available);
+  service_->client_->OnScreenAvailabilityUpdated(GURL(availability_url_),
+                                                 available);
 }
 
 void PresentationServiceImpl::ScreenAvailabilityListenerImpl
 ::OnScreenAvailabilityNotSupported() {
-  service_->client_->OnScreenAvailabilityNotSupported(availability_url_);
+  service_->client_->OnScreenAvailabilityNotSupported(GURL(availability_url_));
 }
 
 PresentationServiceImpl::NewSessionCallbackWrapper
 ::NewSessionCallbackWrapper(const NewSessionCallback& callback)
     : callback_(callback) {
 }
 
 PresentationServiceImpl::NewSessionCallbackWrapper
 ::~NewSessionCallbackWrapper() {
   if (!callback_.is_null())
     InvokeNewSessionCallbackWithError(callback_);
 }
 
 void PresentationServiceImpl::NewSessionCallbackWrapper::Run(
     blink::mojom::PresentationSessionInfoPtr session,
     blink::mojom::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
   callback_.Run(std::move(session), std::move(error));
   callback_.Reset();
 }
 
 }  // namespace content