[Presentation API] Adds DOMString[] constructor to PresentationRequest.

content/renderer/presentation/presentation_dispatcher.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/renderer/presentation/presentation_dispatcher.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "content/public/common/presentation_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/presentation/presentation_connection_client.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/platform/WebURL.h"
+#include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationError.h"
 #include "third_party/WebKit/public/platform/modules/presentation/presentation.mojom.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
 namespace {
 
 blink::WebPresentationError::ErrorType GetWebPresentationErrorTypeFromMojo(
@@ skipping 63 matching lines @@
     blink::WebPresentationController* controller) {
   // There shouldn't be any swapping from one non-null controller to another.
   DCHECK(controller != controller_ && (!controller || !controller_));
   controller_ = controller;
   // The controller is set to null when the frame is about to be detached.
   // Nothing is listening for screen availability anymore but the Mojo service
   // will know about the frame being detached anyway.
 }
 
 void PresentationDispatcher::startSession(
-    const blink::WebString& presentationUrl,
+    const blink::WebVector<blink::WebString>& presentationUrls,
     blink::WebPresentationConnectionClientCallbacks* callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
+  // TODO(mfoltz): Pass all URLs to PresentationService.

[mlamouri (slow - plz ping), 2016/07/19 12:45:03]

Should this be implemented first? or at least, I think we should have
DOMString[] ctor working by taking one URL that would be supported (instead of
the first in the list) in order to ship.

What I would recommend to minimise the boilerplate is to pass all the URLs to
the service and as soon as we reach the chrome/ layer, pick one and ignore all
the others.

[mark a. foltz, 2016/07/19 17:38:47]

We don't know which URL is valid yet (they all need to get passed to the MR to
create a sink -> URL map for the UI).

I could land a patch to modify the PresentationService and downstream code to
support multiple URLs first and land this afterwards, but we'd need to modify
the dispatcher to convert the single URL argument to an array.

[mlamouri (slow - plz ping), 2016/07/20 13:02:10]

Maybe the simplest change would be to pass all the URLs to the
PresentationService then add a method in PresentationServiceImpl that ask the
PresentationServiceDelegate to pick one URL in the list? This way you minimise
the change but you still allow different embedders to have different
implementations. WDYT?

+
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
   // to be destroyed so we transfer its ownership to the mojo callback.
   presentation_service_->StartSession(
-      presentationUrl.utf8(),
+      presentationUrls[0].utf8(),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
           base::Unretained(this),
           base::Owned(callback)));
 }
 
 void PresentationDispatcher::joinSession(
-    const blink::WebString& presentationUrl,
+    const blink::WebVector<blink::WebString>& presentationUrls,
     const blink::WebString& presentationId,
     blink::WebPresentationConnectionClientCallbacks* callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
+  // TODO(mfoltz): Pass all URLs to PresentationService.
+
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
   // to be destroyed so we transfer its ownership to the mojo callback.
   presentation_service_->JoinSession(
-      presentationUrl.utf8(),
+      presentationUrls[0].utf8(),
       presentationId.utf8(),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
           base::Unretained(this),
           base::Owned(callback)));
 }
 
 void PresentationDispatcher::sendString(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message) {
@@ skipping 94 matching lines @@
 void PresentationDispatcher::terminateSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
   presentation_service_->Terminate(presentationUrl.utf8(),
                                    presentationId.utf8());
 }
 
 void PresentationDispatcher::getAvailability(
-    const blink::WebString& availabilityUrl,
+    const blink::WebVector<blink::WebString>& availabilityUrls,
     blink::WebPresentationAvailabilityCallbacks* callbacks) {
-  const std::string& availability_url = availabilityUrl.utf8();
+  // TODO(mfoltz): Pass all URLs to PresentationService.
+  const std::string& availability_url = availabilityUrls[0].utf8();
   AvailabilityStatus* status = nullptr;
   auto status_it = availability_status_.find(availability_url);
   if (status_it == availability_status_.end()) {
     status = new AvailabilityStatus(availability_url);
     availability_status_[availability_url] = base::WrapUnique(status);
   } else {
     status = status_it->second.get();
   }
   DCHECK(status);
 
   if (status->listening_state == ListeningState::ACTIVE) {
     callbacks->onSuccess(status->last_known_availability);
     delete callbacks;
     return;
   }
 
   status->availability_callbacks.Add(callbacks);
   UpdateListeningState(status);
 }
 
 void PresentationDispatcher::startListening(
     blink::WebPresentationAvailabilityObserver* observer) {
-  const std::string& availability_url = observer->url().string().utf8();
+  // TODO(mfoltz): Pass all URLs to PresentationService.
+  const std::string& availability_url = observer->urls()[0].string().utf8();
   auto status_it = availability_status_.find(availability_url);
   if (status_it == availability_status_.end()) {
     DLOG(WARNING) << "Start listening for availability for unknown URL "
                   << availability_url;
     return;
   }
   status_it->second->availability_observers.insert(observer);
   UpdateListeningState(status_it->second.get());
 }
 
 void PresentationDispatcher::stopListening(
     blink::WebPresentationAvailabilityObserver* observer) {
-  const std::string& availability_url = observer->url().string().utf8();
+  // TODO(mfoltz): Pass all URLs to PresentationService.
+  const std::string& availability_url = observer->urls()[0].string().utf8();
   auto status_it = availability_status_.find(availability_url);
   if (status_it == availability_status_.end()) {
     DLOG(WARNING) << "Stop listening for availability for unknown URL "
                   << availability_url;
     return;
   }
   status_it->second->availability_observers.erase(observer);
   UpdateListeningState(status_it->second.get());
 }
 
-void PresentationDispatcher::setDefaultPresentationUrl(
-    const blink::WebString& url) {
+void PresentationDispatcher::setDefaultPresentationUrls(
+    const blink::WebVector<blink::WebString>& urls) {
   ConnectToPresentationServiceIfNeeded();
-  presentation_service_->SetDefaultPresentationURL(url.utf8());
+  // TODO(mfoltz): Pass all URLs to PresentationService.
+  presentation_service_->SetDefaultPresentationURL(urls[0].utf8());
 }
 
 void PresentationDispatcher::DidCommitProvisionalLoad(
     bool is_new_navigation,
     bool is_same_page_navigation) {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   // If not top-level navigation.
   if (frame->parent() || is_same_page_navigation)
     return;
 
@@ skipping 221 matching lines @@
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
     const std::string& availability_url)
     : url(availability_url),
       last_known_availability(false),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
 }
 
 }  // namespace content