Add PermissionDescriptor to the permissions Mojo interface.

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

Index: third_party/WebKit/Source/modules/permissions/Permissions.cpp
diff --git a/third_party/WebKit/Source/modules/permissions/Permissions.cpp b/third_party/WebKit/Source/modules/permissions/Permissions.cpp
index 08781a8b9649b49d8dfccc72a4298592df79b773..9851dbfd1fc7c7e1e8be8a2f504861eb9352bcb7 100644
--- a/third_party/WebKit/Source/modules/permissions/Permissions.cpp
+++ b/third_party/WebKit/Source/modules/permissions/Permissions.cpp
@@ -28,70 +28,64 @@
 
 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;
-
-    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>();
-    }
+    // 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);
 
-    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
@@ -116,7 +110,7 @@ bool Permissions::connectToService(ExecutionContext* executionContext, mojom::bl
 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);
 
@@ -133,14 +127,15 @@ ScriptPromise Permissions::query(ScriptState* scriptState, const Dictionary& raw
     // 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);
 
@@ -153,14 +148,15 @@ ScriptPromise Permissions::request(ScriptState* scriptState, const Dictionary& r
     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);
 
@@ -173,32 +169,35 @@ ScriptPromise Permissions::revoke(ScriptState* scriptState, const Dictionary& ra
     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;
     }
@@ -212,8 +211,13 @@ ScriptPromise Permissions::requestAll(ScriptState* scriptState, const Vector<Dic
     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;
 }
 
@@ -229,14 +233,14 @@ 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;
@@ -247,7 +251,7 @@ void Permissions::batchTaskComplete(ScriptPromiseResolver* resolver, Vector<Perm
     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);
 }