Add PermissionDescriptor to the permissions Mojo interface.

third_party/WebKit/Source/modules/permissions/Permissions.cpp

 // Copyright 2014 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/permissions/Permissions.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 10 matching lines @@
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "wtf/Functional.h"
 #include "wtf/NotFound.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <memory>
 
 namespace blink {
 
+using mojom::blink::PermissionDescriptorPtr;
 using mojom::blink::PermissionName;
 using mojom::blink::PermissionService;
 
 namespace {
 
-// Websites will be able to run code when `name()` is called, changing the
-// current context. The caller should make sure that no assumption is made
-// after this has been called.
-PermissionName getPermissionName(ScriptState* scriptState, const Dictionary& rawPermission, const PermissionDescriptor& permission, ExceptionState& exceptionState)
-{
-    const String& name = permission.name();
-    if (name == "geolocation")
-        return PermissionName::GEOLOCATION;
-    if (name == "notifications")
-        return PermissionName::NOTIFICATIONS;
-    if (name == "push")
-        return PermissionName::PUSH_NOTIFICATIONS;
-    if (name == "midi") {
-        MidiPermissionDescriptor midiPermission = NativeValueTraits<MidiPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
-        return midiPermission.sysex() ? PermissionName::MIDI_SYSEX : PermissionName::MIDI;
-    }
-    if (name == "background-sync")
-        return PermissionName::BACKGROUND_SYNC;
+    // Parses the raw permission dictionary and returns the Mojo
+    // PermissionDescriptor if parsing was successful. If an exception occurs, it
+    // will be stored in |exceptionState| and null will be returned. Therefore, the
+    // |exceptionState| should be checked before attempting to use the returned
+    // permission as the non-null assert will be fired otherwise.
+    //
+    // Websites will be able to run code when `name()` is called, changing the
+    // current context. The caller should make sure that no assumption is made
+    // after this has been called.
+    PermissionDescriptorPtr parsePermission(ScriptState* scriptState, const Dictionary rawPermission, ExceptionState& exceptionState)
+    {
+        PermissionDescriptor permission = NativeValueTraits<PermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
 
-    ASSERT_NOT_REACHED();
-    return PermissionName::GEOLOCATION;
-}
-
-// Parses the raw permission dictionary and returns the PermissionType if
-// parsing was successful. If an exception occurs, it will be stored in
-// |exceptionState| and null will be returned. Therefore, the |exceptionState|
-// should be checked before attempting to use the returned permission as the
-// non-null assert will be fired otherwise.
-Nullable<PermissionName> parsePermission(ScriptState* scriptState, const Dictionary rawPermission, ExceptionState& exceptionState)
-{
-    PermissionDescriptor permission = NativeValueTraits<PermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
-
-    if (exceptionState.hadException()) {
-        exceptionState.throwTypeError(exceptionState.message());
-        return Nullable<PermissionName>();
-    }
-
-    PermissionName name = getPermissionName(scriptState, rawPermission, permission, exceptionState);
-    if (exceptionState.hadException()) {
-        exceptionState.throwTypeError(exceptionState.message());
-        return Nullable<PermissionName>();
-    }
-
-    // Here we reject any permissions which are not yet supported by Blink.
-    if (name == PermissionName::PUSH_NOTIFICATIONS) {
-        PushPermissionDescriptor pushPermission = NativeValueTraits<PushPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
         if (exceptionState.hadException()) {
             exceptionState.throwTypeError(exceptionState.message());
-            return Nullable<PermissionName>();
+            return nullptr;
         }
 
-        // Only "userVisibleOnly" push is supported for now.
-        if (!pushPermission.userVisibleOnly()) {
-            exceptionState.throwDOMException(NotSupportedError, "Push Permission without userVisibleOnly:true isn't supported yet.");
-            return Nullable<PermissionName>();
+        auto permissionDescriptor = mojom::blink::PermissionDescriptor::New();
+        const String& name = permission.name();
+        if (name == "geolocation") {
+            permissionDescriptor->name = PermissionName::GEOLOCATION;
+        } else if (name == "notifications") {
+            permissionDescriptor->name = PermissionName::NOTIFICATIONS;
+        } else if (name == "push") {
+            PushPermissionDescriptor pushPermission = NativeValueTraits<PushPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
+            if (exceptionState.hadException()) {
+                exceptionState.throwTypeError(exceptionState.message());
+                return nullptr;
+            }
+
+            // Only "userVisibleOnly" push is supported for now.
+            if (!pushPermission.userVisibleOnly()) {
+                exceptionState.throwDOMException(NotSupportedError, "Push Permission without userVisibleOnly:true isn't supported yet.");
+                return nullptr;
+            }
+
+            permissionDescriptor->name = PermissionName::PUSH_NOTIFICATIONS;
+        } else if (name == "midi") {
+            MidiPermissionDescriptor midiPermission = NativeValueTraits<MidiPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
+            permissionDescriptor->name = PermissionName::MIDI;
+            auto midiPermissionDescriptor = mojom::blink::MidiPermissionDescriptor::New();
+            midiPermissionDescriptor->sysex = midiPermission.sysex();
+            permissionDescriptor->extension = mojom::blink::PermissionDescriptorExtension::New();
+            permissionDescriptor->extension->set_midi(std::move(midiPermissionDescriptor));
+        } else if (name == "background-sync") {
+            permissionDescriptor->name = PermissionName::BACKGROUND_SYNC;
+        } else {
+            return nullptr;
         }
-    }
 
-    return Nullable<PermissionName>(name);
+        return permissionDescriptor;
 }
 
 } // anonymous namespace
 
 // static
 bool Permissions::connectToService(ExecutionContext* executionContext, mojom::blink::PermissionServiceRequest request)
 {
     InterfaceProvider* interfaceProvider = nullptr;
     if (executionContext->isDocument()) {
         Document* document = toDocument(executionContext);
         if (document->frame())
             interfaceProvider = document->frame()->interfaceProvider();
     } else {
         interfaceProvider = Platform::current()->interfaceProvider();
     }
 
     if (interfaceProvider)
         interfaceProvider->getInterface(std::move(request));
     return interfaceProvider;
 }
 
 ScriptPromise Permissions::query(ScriptState* scriptState, const Dictionary& rawPermission)
 {
     ExceptionState exceptionState(ExceptionState::GetterContext,  "query", "Permissions", scriptState->context()->Global(), scriptState->isolate());
-    Nullable<PermissionName> name = parsePermission(scriptState, rawPermission, exceptionState);
+    auto descriptor = parsePermission(scriptState, rawPermission, exceptionState);
     if (exceptionState.hadException())
         return exceptionState.reject(scriptState);
 
     // This must be called after `parsePermission` because the website might
     // be able to run code.
     PermissionService* service = getService(scriptState->getExecutionContext());
     if (!service)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "In its current state, the global scope can't query permissions."));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     // If the current origin is a file scheme, it will unlikely return a
     // meaningful value because most APIs are broken on file scheme and no
     // permission prompt will be shown even if the returned permission will most
     // likely be "prompt".
-    service->HasPermission(name.get(), scriptState->getExecutionContext()->getSecurityOrigin(), convertToBaseCallback(WTF::bind(&Permissions::taskComplete, wrapPersistent(this), wrapPersistent(resolver), name.get())));
+    auto descriptorCopy = descriptor->Clone();
+    service->HasPermission(std::move(descriptor), scriptState->getExecutionContext()->getSecurityOrigin(), convertToBaseCallback(WTF::bind(&Permissions::taskComplete, wrapPersistent(this), wrapPersistent(resolver), passed(std::move(descriptorCopy)))));
     return promise;
 }
 
 ScriptPromise Permissions::request(ScriptState* scriptState, const Dictionary& rawPermission)
 {
     ExceptionState exceptionState(ExceptionState::GetterContext,  "request", "Permissions", scriptState->context()->Global(), scriptState->isolate());
-    Nullable<PermissionName> name = parsePermission(scriptState, rawPermission, exceptionState);
+    auto descriptor = parsePermission(scriptState, rawPermission, exceptionState);
     if (exceptionState.hadException())
         return exceptionState.reject(scriptState);
 
     // This must be called after `parsePermission` because the website might
     // be able to run code.
     PermissionService* service = getService(scriptState->getExecutionContext());
     if (!service)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "In its current state, the global scope can't request permissions."));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
-    service->RequestPermission(name.get(), scriptState->getExecutionContext()->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(), convertToBaseCallback(WTF::bind(&Permissions::taskComplete, wrapPersistent(this), wrapPersistent(resolver), name.get())));
+    auto descriptorCopy = descriptor->Clone();
+    service->RequestPermission(std::move(descriptor), scriptState->getExecutionContext()->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(), convertToBaseCallback(WTF::bind(&Permissions::taskComplete, wrapPersistent(this), wrapPersistent(resolver), passed(std::move(descriptorCopy)))));
     return promise;
 }
 
 ScriptPromise Permissions::revoke(ScriptState* scriptState, const Dictionary& rawPermission)
 {
     ExceptionState exceptionState(ExceptionState::GetterContext,  "revoke", "Permissions", scriptState->context()->Global(), scriptState->isolate());
-    Nullable<PermissionName> name = parsePermission(scriptState, rawPermission, exceptionState);
+    auto descriptor = parsePermission(scriptState, rawPermission, exceptionState);
     if (exceptionState.hadException())
         return exceptionState.reject(scriptState);
 
     // This must be called after `parsePermission` because the website might
     // be able to run code.
     PermissionService* service = getService(scriptState->getExecutionContext());
     if (!service)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "In its current state, the global scope can't revoke permissions."));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
-    service->RevokePermission(name.get(), scriptState->getExecutionContext()->getSecurityOrigin(), convertToBaseCallback(WTF::bind(&Permissions::taskComplete, wrapPersistent(this), wrapPersistent(resolver), name.get())));
+    auto descriptorCopy = descriptor->Clone();
+    service->RevokePermission(std::move(descriptor), scriptState->getExecutionContext()->getSecurityOrigin(), convertToBaseCallback(WTF::bind(&Permissions::taskComplete, wrapPersistent(this), wrapPersistent(resolver), passed(std::move(descriptorCopy)))));
     return promise;
 }
 
 ScriptPromise Permissions::requestAll(ScriptState* scriptState, const Vector<Dictionary>& rawPermissions)
 {
     ExceptionState exceptionState(ExceptionState::GetterContext,  "request", "Permissions", scriptState->context()->Global(), scriptState->isolate());
-    Vector<PermissionName> internalPermissions;
+    Vector<PermissionDescriptorPtr> internalPermissions;
     Vector<int> callerIndexToInternalIndex;
     callerIndexToInternalIndex.resize(rawPermissions.size());
     for (size_t i = 0; i < rawPermissions.size(); ++i) {
         const Dictionary& rawPermission = rawPermissions[i];
 
-        Nullable<PermissionName> name = parsePermission(scriptState, rawPermission, exceptionState);
+        auto descriptor = parsePermission(scriptState, rawPermission, exceptionState);
         if (exceptionState.hadException())
             return exceptionState.reject(scriptState);
 
-        // Only append permissions to the vector that is passed to the client if it is not already
-        // in the vector (i.e. do not duplicate permisison types).
-        int internalIndex;
-        auto it = internalPermissions.find(name.get());
-        if (it == kNotFound) {
+        // Only append permissions types that are not already present in the vector.
+        int internalIndex = -1;
+        for (size_t j = 0; j < internalPermissions.size(); ++j) {
+            if (internalPermissions[j]->name == descriptor->name) {
+                internalIndex = j;
+                break;
+            }
+        }
+        if (internalIndex == -1) {
             internalIndex = internalPermissions.size();
-            internalPermissions.append(name.get());
-        } else {
-            internalIndex = it;
+            internalPermissions.append(std::move(descriptor));
         }
         callerIndexToInternalIndex[i] = internalIndex;
     }
 
     // This must be called after `parsePermission` because the website might
     // be able to run code.
     PermissionService* service = getService(scriptState->getExecutionContext());
     if (!service)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "In its current state, the global scope can't request permissions."));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
-    service->RequestPermissions(internalPermissions, scriptState->getExecutionContext()->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(),
-        convertToBaseCallback(WTF::bind(&Permissions::batchTaskComplete, wrapPersistent(this), wrapPersistent(resolver), internalPermissions, callerIndexToInternalIndex)));
+    Vector<PermissionDescriptorPtr> internalPermissionsCopy;
+    internalPermissionsCopy.reserveCapacity(internalPermissions.size());
+    for (const auto& descriptor : internalPermissions)
+        internalPermissionsCopy.append(descriptor->Clone());
+
+    service->RequestPermissions(std::move(internalPermissions), scriptState->getExecutionContext()->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(),
+        convertToBaseCallback(WTF::bind(&Permissions::batchTaskComplete, wrapPersistent(this), wrapPersistent(resolver), passed(std::move(internalPermissionsCopy)), passed(std::move(callerIndexToInternalIndex)))));
     return promise;
 }
 
 PermissionService* Permissions::getService(ExecutionContext* executionContext)
 {
     if (!m_service && connectToService(executionContext, mojo::GetProxy(&m_service)))
         m_service.set_connection_error_handler(convertToBaseCallback(WTF::bind(&Permissions::serviceConnectionError, wrapWeakPersistent(this))));
     return m_service.get();
 }
 
 void Permissions::serviceConnectionError()
 {
     m_service.reset();
 }
 
-void Permissions::taskComplete(ScriptPromiseResolver* resolver, PermissionName name, mojom::blink::PermissionStatus result)
+void Permissions::taskComplete(ScriptPromiseResolver* resolver, mojom::blink::PermissionDescriptorPtr descriptor, mojom::blink::PermissionStatus result)
 {
     if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
         return;
-    resolver->resolve(PermissionStatus::take(resolver, result, name));
+    resolver->resolve(PermissionStatus::take(resolver, result, std::move(descriptor)));
 }
 
-void Permissions::batchTaskComplete(ScriptPromiseResolver* resolver, Vector<PermissionName> names, Vector<int> callerIndexToInternalIndex, const Vector<mojom::blink::PermissionStatus>& results)
+void Permissions::batchTaskComplete(ScriptPromiseResolver* resolver, Vector<mojom::blink::PermissionDescriptorPtr> descriptors, Vector<int> callerIndexToInternalIndex, const Vector<mojom::blink::PermissionStatus>& results)
 {
     if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
         return;
 
     // Create the response vector by finding the status for each index by
     // using the caller to internal index mapping and looking up the status
     // using the internal index obtained.
     HeapVector<Member<PermissionStatus>> result;
     result.reserveInitialCapacity(callerIndexToInternalIndex.size());
     for (int internalIndex : callerIndexToInternalIndex)
-        result.append(PermissionStatus::createAndListen(resolver->getExecutionContext(), results[internalIndex], names[internalIndex]));
+        result.append(PermissionStatus::createAndListen(resolver->getExecutionContext(), results[internalIndex], descriptors[internalIndex]->Clone()));
     resolver->resolve(result);
 }
 
 } // namespace blink