[Presentation API] Add support to content/ for multiple URLs per 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();
 
+  std::vector<url::mojom::UrlPtr> urls(presentationUrls.size());
+  std::transform(presentationUrls.begin(), presentationUrls.end(), urls.begin(),
+                 [](const blink::WebString& url) {
+                   url::mojom::UrlPtr mojo_url = url::mojom::Url::New();
+                   mojo_url->url = url.utf8();
+                   return mojo_url;
+                 });
+
   // 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(),
+      std::move(urls),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
-          base::Unretained(this),
-          base::Owned(callback)));
+                 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();
 
+  std::vector<url::mojom::UrlPtr> urls(presentationUrls.size());
+  std::transform(presentationUrls.begin(), presentationUrls.end(), urls.begin(),
+                 [](const blink::WebString& url) {
+                   url::mojom::UrlPtr mojo_url = url::mojom::Url::New();
+                   mojo_url->url = url.utf8();
+                   return mojo_url;
+                 });
+
   // 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(),
-      presentationId.utf8(),
+      std::move(urls), presentationId.utf8(),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
-          base::Unretained(this),
-          base::Owned(callback)));
+                 base::Unretained(this), base::Owned(callback)));
 }
 
 void PresentationDispatcher::sendString(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message) {
   if (message.utf8().size() > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
@@ skipping 76 matching lines @@
   if (!message_request_queue_.empty()) {
     DoSendMessage(message_request_queue_.front().get());
   }
 }
 
 void PresentationDispatcher::closeSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
-  presentation_service_->CloseConnection(presentationUrl.utf8(),
-                                         presentationId.utf8());
+  url::mojom::UrlPtr url = url::mojom::Url::New();
+  url->url = presentationUrl.utf8();
+
+  presentation_service_->CloseConnection(std::move(url), presentationId.utf8());
 }
 
 void PresentationDispatcher::terminateSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
-  presentation_service_->Terminate(presentationUrl.utf8(),
-                                   presentationId.utf8());
+  url::mojom::UrlPtr url = url::mojom::Url::New();
+  url->url = presentationUrl.utf8();
+
+  presentation_service_->Terminate(std::move(url), presentationId.utf8());
 }
 
 void PresentationDispatcher::getAvailability(
     const blink::WebString& availabilityUrl,
     blink::WebPresentationAvailabilityCallbacks* callbacks) {
   const std::string& availability_url = availabilityUrl.utf8();
   AvailabilityStatus* status = nullptr;
   auto status_it = availability_status_.find(availability_url);
   if (status_it == availability_status_.end()) {
     status = new AvailabilityStatus(availability_url);
@@ skipping 32 matching lines @@
   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>& presentationUrls) {
   ConnectToPresentationServiceIfNeeded();
-  presentation_service_->SetDefaultPresentationURL(url.utf8());
+
+  std::vector<url::mojom::UrlPtr> urls(presentationUrls.size());
+  std::transform(presentationUrls.begin(), presentationUrls.end(), urls.begin(),
+                 [](const blink::WebString& url) {
+                   url::mojom::UrlPtr mojo_url = url::mojom::Url::New();
+                   mojo_url->url = url.utf8();
+                   return mojo_url;
+                 });
+  presentation_service_->SetDefaultPresentationUrls(std::move(urls));
 }
 
 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;
 
   // Remove all pending send message requests.
   MessageRequestQueue empty;
   std::swap(message_request_queue_, empty);
 }
 
 void PresentationDispatcher::OnDestruct() {
   delete this;
 }
 
-void PresentationDispatcher::OnScreenAvailabilityUpdated(const std::string& url,
+void PresentationDispatcher::OnScreenAvailabilityUpdated(url::mojom::UrlPtr url,
                                                          bool available) {
-  auto status_it = availability_status_.find(url);
+  auto status_it = availability_status_.find(url->url);
   if (status_it == availability_status_.end())
     return;
   AvailabilityStatus* status = status_it->second.get();
   DCHECK(status);
 
   if (status->listening_state == ListeningState::WAITING)
     status->listening_state = ListeningState::ACTIVE;
 
   for (auto* observer : status->availability_observers)
     observer->availabilityChanged(available);
 
   for (AvailabilityCallbacksMap::iterator iter(&status->availability_callbacks);
        !iter.IsAtEnd(); iter.Advance()) {
     iter.GetCurrentValue()->onSuccess(available);
   }
   status->last_known_availability = available;
   status->availability_callbacks.Clear();
   UpdateListeningState(status);
 }
 
 void PresentationDispatcher::OnScreenAvailabilityNotSupported(
-    const std::string& url) {
-  auto status_it = availability_status_.find(url);
+    url::mojom::UrlPtr url) {
+  auto status_it = availability_status_.find(url->url);
   if (status_it == availability_status_.end())
     return;
   AvailabilityStatus* status = status_it->second.get();
   DCHECK(status);
   DCHECK(status->listening_state == ListeningState::WAITING);
 
   const blink::WebString& not_supported_error = blink::WebString::fromUTF8(
       "getAvailability() isn't supported at the moment. It can be due to "
       "a permanent or temporary system limitation. It is recommended to "
       "try to blindly start a session in that case.");
@@ skipping 67 matching lines @@
 void PresentationDispatcher::OnSessionMessagesReceived(
     blink::mojom::PresentationSessionInfoPtr session_info,
     std::vector<blink::mojom::SessionMessagePtr> messages) {
   if (!controller_)
     return;
 
   for (size_t i = 0; i < messages.size(); ++i) {
     // Note: Passing batches of messages to the Blink layer would be more
     // efficient.
     std::unique_ptr<PresentationConnectionClient> session_client(
-        new PresentationConnectionClient(session_info->url, session_info->id));
+        new PresentationConnectionClient(session_info->url->url,
+                                         session_info->id));
     switch (messages[i]->type) {
       case blink::mojom::PresentationMessageType::TEXT: {
         // TODO(mfoltz): Do we need to DCHECK(messages[i]->message)?
         controller_->didReceiveSessionTextMessage(
             session_client.release(),
             blink::WebString::fromUTF8(messages[i]->message.value()));
         break;
       }
       case blink::mojom::PresentationMessageType::ARRAY_BUFFER:
       case blink::mojom::PresentationMessageType::BLOB: {
@@ skipping 21 matching lines @@
 
 void PresentationDispatcher::UpdateListeningState(AvailabilityStatus* status) {
   bool should_listen = !status->availability_callbacks.IsEmpty() ||
                        !status->availability_observers.empty();
   bool is_listening = status->listening_state != ListeningState::INACTIVE;
 
   if (should_listen == is_listening)
     return;
 
   ConnectToPresentationServiceIfNeeded();
+  url::mojom::UrlPtr url = url::mojom::Url::New();
+  url->url = status->url;
   if (should_listen) {
     status->listening_state = ListeningState::WAITING;
-    presentation_service_->ListenForScreenAvailability(status->url);
+    presentation_service_->ListenForScreenAvailability(std::move(url));
   } else {
     status->listening_state = ListeningState::INACTIVE;
-    presentation_service_->StopListeningForScreenAvailability(status->url);
+    presentation_service_->StopListeningForScreenAvailability(std::move(url));
   }
 }
 
 PresentationDispatcher::SendMessageRequest::SendMessageRequest(
     blink::mojom::PresentationSessionInfoPtr session_info,
     blink::mojom::SessionMessagePtr message)
     : session_info(std::move(session_info)), message(std::move(message)) {}
 
 PresentationDispatcher::SendMessageRequest::~SendMessageRequest() {}
 
 // static
 PresentationDispatcher::SendMessageRequest*
 PresentationDispatcher::CreateSendTextMessageRequest(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message) {
   blink::mojom::PresentationSessionInfoPtr session_info =
       blink::mojom::PresentationSessionInfo::New();
-  session_info->url = presentationUrl.utf8();
+  url::mojom::UrlPtr url = url::mojom::Url::New();
+  url->url = presentationUrl.utf8();
+  session_info->url = std::move(url);
   session_info->id = presentationId.utf8();
 
   blink::mojom::SessionMessagePtr session_message =
       blink::mojom::SessionMessage::New();
   session_message->type = blink::mojom::PresentationMessageType::TEXT;
   session_message->message = message.utf8();
   return new SendMessageRequest(std::move(session_info),
                                 std::move(session_message));
 }
 
 // static
 PresentationDispatcher::SendMessageRequest*
 PresentationDispatcher::CreateSendBinaryMessageRequest(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     blink::mojom::PresentationMessageType type,
     const uint8_t* data,
     size_t length) {
   blink::mojom::PresentationSessionInfoPtr session_info =
       blink::mojom::PresentationSessionInfo::New();
-  session_info->url = presentationUrl.utf8();
+  url::mojom::UrlPtr url = url::mojom::Url::New();

[dcheng, 2016/08/24 22:14:19]

What's the status on typemapping? We shouldn't have to manually marshall stuff
like this.

[mark a. foltz, 2016/08/24 22:37:11]

Sorry I don't understand the question.  The revised API takes a UrlPtr for
|session_info|.

[dcheng, 2016/08/24 23:12:17]

At this point, it's quite unusual to use the raw mojo types directly. It's much
nicer for code to just deal with some native Blink C++ struct. Then we use a
typemap + StructTraits to turn it into the mojo wire format, and then the same
thing on the other end to turn it back into a native C++ struct.

This is important, because the StructTraits actually have some checks: for
example, for GURL, it checks that the resulting GURL is actually valid and that
doesn't exceed max chars:
https://cs.chromium.org/chromium/src/url/mojo/url_gurl_struct_traits.h?rcl=0&...

It also results in simpler client code. For example, let's say we have:

interface PageLoadMetrics {
  void ReportLoaded(url.mojom.Url url);
};

Without typemapping, I'd have to write something like this:
  url::mojom::UrlPtr url = url::mojom::Url::New();
  url->url = gurl.possibly_invalid_spec();
  metrics->ReportLoaded(std::move(url));

But with typemapping, I can just write this:
  metrics->ReportLoaded(gurl);

FWIW, there's basically already a bug filed for this:
https://bugs.chromium.org/p/chromium/issues/detail?id=632623

[mark a. foltz, 2016/08/29 23:54:54]

Now passing GURL into all the Mojo interfaces.

+  url->url = presentationUrl.utf8();
+  session_info->url = std::move(url);
   session_info->id = presentationId.utf8();
 
   blink::mojom::SessionMessagePtr session_message =
       blink::mojom::SessionMessage::New();
   session_message->type = type;
   session_message->data = std::vector<uint8_t>(data, data + length);
   return new SendMessageRequest(std::move(session_info),
                                 std::move(session_message));
 }
 
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
     const std::string& availability_url)
     : url(availability_url),
       last_known_availability(false),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
 }
 
 }  // namespace content