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"
 #include "bindings/modules/v8/V8MidiPermissionDescriptor.h"
 #include "bindings/modules/v8/V8PermissionDescriptor.h"
 #include "bindings/modules/v8/V8PushPermissionDescriptor.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/permissions/PermissionDescriptor.h"
 #include "modules/permissions/PermissionStatus.h"
+#include "modules/permissions/PermissionUtils.h"
 #include "platform/UserGestureIndicator.h"
-#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 {
 
+// 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.
-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)
+PermissionDescriptorPtr 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>();
+        return nullptr;
     }
 
-    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) {
+    const String& name = permission.name();
+    PermissionName permissionName;
+    if (name == "geolocation") {
+        permissionName = PermissionName::GEOLOCATION;
+    } else if (name == "notifications") {
+        permissionName = PermissionName::NOTIFICATIONS;
+    } else if (name == "push") {
         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>();
+            return nullptr;
         }
+
+        permissionName = PermissionName::PUSH_NOTIFICATIONS;
+    } else if (name == "midi") {
+        MidiPermissionDescriptor midiPermission = NativeValueTraits<MidiPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState);
+        return createMidiPermissionDescriptor(midiPermission.sysex());
+    } else if (name == "background-sync") {
+        permissionName = PermissionName::BACKGROUND_SYNC;
+    } else {
+        return nullptr;
     }
 
-    return Nullable<PermissionName>(name);
+    return createPermissionDescriptor(permissionName);

[mlamouri (slow - plz ping), 2016/09/13 09:57:50]

I find it a bit confusing that some if statements end up returning and some will
set `permissionName` which is used here for the final return. Given that this
helper is a one-liner, can we make this a bit easier to read with a flow like:

```
if (name == "geolocation")
  return createPermissionDescriptor(PermissionName::GEOLOCATION)

if (name == "notifications")
  return createPermissionDescriptor(PermissionName::NOTIFICATIONS)

[...]
```

[Reilly Grant (use Gerrit), 2016/09/27 10:34:28]

Done. You're right, that's cleaner.

 }
 
 } // 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);

[mlamouri (slow - plz ping), 2016/09/13 09:57:50]

can you explicitly put `PermissionDescriptor` instead of `auto`?

[Reilly Grant (use Gerrit), 2016/09/27 10:34:28]

Done.

     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();

[mlamouri (slow - plz ping), 2016/09/13 09:57:50]

ditto and all the instances below.

[Reilly Grant (use Gerrit), 2016/09/27 10:34:28]

Done.

+    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;

[mlamouri (slow - plz ping), 2016/09/13 09:57:50]

What about using `kNotFound`?

[Reilly Grant (use Gerrit), 2016/09/27 10:34:28]

I didn't know kNotFound was a common type. Neat.

+        for (size_t j = 0; j < internalPermissions.size(); ++j) {
+            if (internalPermissions[j]->name == descriptor->name) {
+                internalIndex = j;
+                break;
+            }
+        }
+        if (internalIndex == -1) {

[mlamouri (slow - plz ping), 2016/09/13 09:57:50]

... and here you can do `if (internalIndex == kNotFound)`

[Reilly Grant (use Gerrit), 2016/09/27 10:34:28]

Done.

             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)))
+    if (!m_service && connectToPermissionService(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