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

third_party/WebKit/Source/modules/presentation/PresentationRequest.cpp

 // 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 "modules/presentation/PresentationRequest.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 28 matching lines @@
   return controller ? controller->client() : nullptr;
 }
 
 Settings* settings(ExecutionContext* executionContext) {
   DCHECK(executionContext);
 
   Document* document = toDocument(executionContext);
   return document->settings();
 }
 
-ScriptPromise rejectWithMixedContentException(ScriptState* scriptState,
-                                              const String& url) {
-  return ScriptPromise::rejectWithDOMException(
-      scriptState,
-      DOMException::create(SecurityError,
-                           "Presentation of an insecure document [" + url +
-                               "] is prohibited from a secure context."));
-}
-
 ScriptPromise rejectWithSandBoxException(ScriptState* scriptState) {
   return ScriptPromise::rejectWithDOMException(
       scriptState, DOMException::create(SecurityError,
                                         "The document is sandboxed and lacks "
                                         "the 'allow-presentation' flag."));
 }
 
 }  // anonymous namespace
 
 // static
 PresentationRequest* PresentationRequest::create(
     ExecutionContext* executionContext,
     const String& url,
     ExceptionState& exceptionState) {
-  KURL parsedUrl = KURL(executionContext->url(), url);
-  if (!parsedUrl.isValid() || parsedUrl.protocolIsAbout()) {
-    exceptionState.throwTypeError("'" + url +
-                                  "' can't be resolved to a valid URL.");
-    return nullptr;
+  WTF::Vector<String> urls(1);
+  urls[0] = url;
+  return create(executionContext, urls, exceptionState);
+}
+
+PresentationRequest* PresentationRequest::create(
+    ExecutionContext* executionContext,
+    const WTF::Vector<String>& urls,
+    ExceptionState& exceptionState) {
+  WTF::Vector<KURL> parsedUrls(urls.size());

[imcheng, 2016/12/20 20:11:27]

We should handle the case of passing an empty array into the constructor. It
seems the code downstream (PresentationDispatcher) depends on it having at least
one URL. Ok to address in a separate patch with tests.

https://github.com/w3c/presentation-api/issues/327

+  for (size_t i = 0; i < urls.size(); ++i) {
+    const KURL& parsedUrl = KURL(executionContext->url(), urls[i]);
+
+    if (!parsedUrl.isValid() || parsedUrl.protocolIsAbout()) {
+      exceptionState.throwDOMException(
+          SyntaxError, "'" + urls[i] + "' can't be resolved to a valid URL.");
+      return nullptr;
+    }
+
+    if (MixedContentChecker::isMixedContent(
+            executionContext->getSecurityOrigin(), parsedUrl)) {
+      exceptionState.throwDOMException(
+          SecurityError, "Presentation of an insecure document [" + urls[i] +
+                             "] is prohibited from a secure context.");
+      return nullptr;
+    }
+
+    parsedUrls[i] = parsedUrl;
   }
-
   PresentationRequest* request =
-      new PresentationRequest(executionContext, parsedUrl);
+      new PresentationRequest(executionContext, parsedUrls);
   request->suspendIfNeeded();
   return request;
 }
 
 const AtomicString& PresentationRequest::interfaceName() const {
   return EventTargetNames::PresentationRequest;
 }
 
 ExecutionContext* PresentationRequest::getExecutionContext() const {
   return SuspendableObject::getExecutionContext();
@@ skipping 23 matching lines @@
   bool isUserGestureRequired =
       !contextSettings || contextSettings->presentationRequiresUserGesture();
 
   if (isUserGestureRequired && !UserGestureIndicator::utilizeUserGesture())
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
             InvalidAccessError,
             "PresentationRequest::start() requires user gesture."));
 
-  if (MixedContentChecker::isMixedContent(
-          getExecutionContext()->getSecurityOrigin(), m_url)) {
-    return rejectWithMixedContentException(scriptState, m_url.getString());
-  }
-
   if (toDocument(getExecutionContext())->isSandboxed(SandboxPresentation))
     return rejectWithSandBoxException(scriptState);
 
   WebPresentationClient* client = presentationClient(getExecutionContext());
   if (!client)
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
             InvalidStateError,
             "The PresentationRequest is no longer associated to a frame."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
-  // TODO(crbug.com/627655): Accept multiple URLs per PresentationRequest.
-  WebVector<WebURL> presentationUrls(static_cast<size_t>(1U));
-  presentationUrls[0] = m_url;
   client->startSession(
-      presentationUrls,
-      WTF::makeUnique<PresentationConnectionCallbacks>(resolver, this));
+      m_urls, WTF::makeUnique<PresentationConnectionCallbacks>(resolver, this));
   return resolver->promise();
 }
 
 ScriptPromise PresentationRequest::reconnect(ScriptState* scriptState,
                                              const String& id) {
-  if (MixedContentChecker::isMixedContent(
-          getExecutionContext()->getSecurityOrigin(), m_url)) {
-    return rejectWithMixedContentException(scriptState, m_url.getString());
-  }
-
   if (toDocument(getExecutionContext())->isSandboxed(SandboxPresentation))
     return rejectWithSandBoxException(scriptState);
 
   WebPresentationClient* client = presentationClient(getExecutionContext());
   if (!client)
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
             InvalidStateError,
             "The PresentationRequest is no longer associated to a frame."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
-  // TODO(crbug.com/627655): Accept multiple URLs per PresentationRequest.
-  WebVector<WebURL> presentationUrls(static_cast<size_t>(1U));
-  presentationUrls[0] = m_url;
   client->joinSession(
-      presentationUrls, id,
+      m_urls, id,
       WTF::makeUnique<PresentationConnectionCallbacks>(resolver, this));
   return resolver->promise();
 }
 
 ScriptPromise PresentationRequest::getAvailability(ScriptState* scriptState) {
-  if (MixedContentChecker::isMixedContent(
-          getExecutionContext()->getSecurityOrigin(), m_url)) {
-    return rejectWithMixedContentException(scriptState, m_url.getString());
-  }
-
   if (toDocument(getExecutionContext())->isSandboxed(SandboxPresentation))
     return rejectWithSandBoxException(scriptState);
 
   WebPresentationClient* client = presentationClient(getExecutionContext());
   if (!client)
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(
             InvalidStateError,
             "The PresentationRequest is no longer associated to a frame."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   client->getAvailability(
-      m_url,
-      WTF::makeUnique<PresentationAvailabilityCallbacks>(resolver, m_url));
+      m_urls,
+      WTF::makeUnique<PresentationAvailabilityCallbacks>(resolver, m_urls));
   return resolver->promise();
 }
 
-const KURL& PresentationRequest::url() const {
-  return m_url;
+const WTF::Vector<KURL>& PresentationRequest::urls() const {
+  return m_urls;
 }
 
 DEFINE_TRACE(PresentationRequest) {
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 PresentationRequest::PresentationRequest(ExecutionContext* executionContext,
-                                         const KURL& url)
+                                         const WTF::Vector<KURL>& urls)
     : ActiveScriptWrappable(this),
       SuspendableObject(executionContext),
-      m_url(url) {}
+      m_urls(urls) {}
 
 }  // namespace blink