[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"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "modules/EventTargetModules.h"
 #include "modules/presentation/PresentationAvailability.h"
 #include "modules/presentation/PresentationAvailabilityCallbacks.h"
 #include "modules/presentation/PresentationConnection.h"
 #include "modules/presentation/PresentationConnectionCallbacks.h"
 #include "modules/presentation/PresentationController.h"
 #include "modules/presentation/PresentationError.h"
 #include "platform/UserGestureIndicator.h"
+#include "wtf/text/WTFString.h"
 
 namespace blink {
 
 namespace {
 
 // TODO(mlamouri): refactor in one common place.
 WebPresentationClient* presentationClient(ExecutionContext* executionContext)
 {
     DCHECK(executionContext);
 
@@ skipping 10 matching lines @@
 
     Document* document = toDocument(executionContext);
     return document->settings();
 }
 
 } // 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());
+    for (size_t i = 0; i < urls.size(); ++i) {
+        const KURL& parsedUrl = KURL(executionContext->url(), urls[i]);
+        if (!parsedUrl.isValid() || parsedUrl.protocolIsAbout()) {
+            exceptionState.throwTypeError("'" + urls[i] + "' can't be resolved to a valid URL.");
+            return nullptr;
+        }
+        parsedUrls[i] = parsedUrl;
     }
-
-    PresentationRequest* request = new PresentationRequest(executionContext, parsedUrl);
+    PresentationRequest* request = new PresentationRequest(executionContext, parsedUrls);
     request->suspendIfNeeded();
     return request;
 }
 
 const AtomicString& PresentationRequest::interfaceName() const
 {
     return EventTargetNames::PresentationRequest;
 }
 
 ExecutionContext* PresentationRequest::getExecutionContext() const
@@ skipping 34 matching lines @@
     if (toDocument(getExecutionContext())->isSandboxed(SandboxPresentation)) {
         resolver->reject(DOMException::create(SecurityError, "The document is sandboxed and lacks the 'allow-presentation' flag."));
         return promise;
     }
 
     WebPresentationClient* client = presentationClient(getExecutionContext());
     if (!client) {
         resolver->reject(DOMException::create(InvalidStateError, "The PresentationRequest is no longer associated to a frame."));
         return promise;
     }
-    client->startSession(m_url.getString(), new PresentationConnectionCallbacks(resolver, this));
+    client->startSession(m_urls, new PresentationConnectionCallbacks(resolver, this));
     return promise;
 }
 
 ScriptPromise PresentationRequest::reconnect(ScriptState* scriptState, const String& id)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     if (toDocument(getExecutionContext())->isSandboxed(SandboxPresentation)) {
         resolver->reject(DOMException::create(SecurityError, "The document is sandboxed and lacks the 'allow-presentation' flag."));
         return promise;
     }
 
     WebPresentationClient* client = presentationClient(getExecutionContext());
     if (!client) {
         resolver->reject(DOMException::create(InvalidStateError, "The PresentationRequest is no longer associated to a frame."));
         return promise;
     }
-    client->joinSession(m_url.getString(), id, new PresentationConnectionCallbacks(resolver, this));
+    client->joinSession(m_urls, id, new PresentationConnectionCallbacks(resolver, this));
     return promise;
 }
 
 ScriptPromise PresentationRequest::getAvailability(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     if (toDocument(getExecutionContext())->isSandboxed(SandboxPresentation)) {
         resolver->reject(DOMException::create(SecurityError, "The document is sandboxed and lacks the 'allow-presentation' flag."));
         return promise;
     }
 
     WebPresentationClient* client = presentationClient(getExecutionContext());
     if (!client) {
         resolver->reject(DOMException::create(InvalidStateError, "The object is no longer associated to a frame."));
         return promise;
     }
-    client->getAvailability(m_url.getString(), new PresentationAvailabilityCallbacks(resolver, m_url));
+
+    client->getAvailability(m_urls, new PresentationAvailabilityCallbacks(resolver, m_urls));
     return promise;
 }
 
-const KURL& PresentationRequest::url() const
+const WTF::Vector<KURL>& PresentationRequest::urls() const
 {
-    return m_url;
+    return m_urls;
 }
 
 DEFINE_TRACE(PresentationRequest)
 {
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
-PresentationRequest::PresentationRequest(ExecutionContext* executionContext, const KURL& url)
+PresentationRequest::PresentationRequest(ExecutionContext* executionContext, const WTF::Vector<KURL>& urls)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(executionContext)
-    , m_url(url)
+    , m_urls(urls)
 {
 }
 
 } // namespace blink