Reland: Web MIDI: use mojom::blink::PermissionService directly to ask permission

third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.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/webmidi/MIDIAccessInitializer.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/frame/LocalFrame.h"
 #include "core/frame/Navigator.h"
 #include "modules/webmidi/MIDIAccess.h"
-#include "modules/webmidi/MIDIController.h"
 #include "modules/webmidi/MIDIOptions.h"
 #include "modules/webmidi/MIDIPort.h"
+#include "platform/UserGestureIndicator.h"
+#include "platform/mojo/MojoHelper.h"
+#include "public/platform/ServiceRegistry.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission.mojom-blink.h"
 
 namespace blink {
 
 using PortState = WebMIDIAccessorClient::MIDIPortState;
 
+using mojom::blink::PermissionName;
+using mojom::blink::PermissionStatus;
+
 MIDIAccessInitializer::MIDIAccessInitializer(ScriptState* scriptState, const MIDIOptions& options)
     : ScriptPromiseResolver(scriptState)
     , m_options(options)
-    , m_hasBeenDisposed(false)
-    , m_permissionResolved(false)
 {
 }
 
-MIDIAccessInitializer::~MIDIAccessInitializer()
-{
-    dispose();
-}
-
 void MIDIAccessInitializer::contextDestroyed()
 {
-    dispose();
+    m_permissionService.reset();
     LifecycleObserver::contextDestroyed();
 }
 
-void MIDIAccessInitializer::dispose()
-{
-    if (m_hasBeenDisposed)
-        return;
-
-    if (!getExecutionContext())
-        return;
-
-    if (!m_permissionResolved) {
-        Document* document = toDocument(getExecutionContext());
-        DCHECK(document);
-        if (MIDIController* controller = MIDIController::from(document->frame()))
-            controller->cancelPermissionRequest(this);
-        m_permissionResolved = true;
-    }
-
-    m_hasBeenDisposed = true;
-}
-
 ScriptPromise MIDIAccessInitializer::start()
 {
     ScriptPromise promise = this->promise();
     m_accessor = MIDIAccessor::create(this);
 
     Document* document = toDocument(getExecutionContext());
     DCHECK(document);
-    if (MIDIController* controller = MIDIController::from(document->frame()))
-        controller->requestPermission(this, m_options);
-    else
-        reject(DOMException::create(SecurityError));
+
+    document->frame()->serviceRegistry()->connectToRemoteService(mojo::GetProxy(&m_permissionService));
+
+    bool requestSysEx = m_options.hasSysex() && m_options.sysex();
+    if (requestSysEx) {
+        Vector<PermissionName> permissions = { PermissionName::MIDI, PermissionName::MIDI_SYSEX };
+        m_permissionService->RequestPermissions(
+            mojo::WTFArray<PermissionName>(std::move(permissions)),
+            getExecutionContext()->getSecurityOrigin()->toString(),
+            UserGestureIndicator::processingUserGesture(),
+            createBaseCallback(WTF::bind(&MIDIAccessInitializer::onPermissionsUpdated, wrapPersistent(this))));
+    } else {
+        // TODO(toyoshim): Merge this MIDI only code path to the other one for

[Takashi Toyoshima, 2016/07/07 11:03:11]

Here is TODO.
AwPermissionManagerTest.java's change is not a workaround, but needed even after
a right fix. This is because if sysex is requested, two permissions, MIDI and
MIDI_SYSEX, are requested in the new implementation. Before this change, MIDI
permission is short-circuited to be granted without client decision. That's why
{sysex: true} is specified in the test. But after this change, it isn't needed,
and should not have to work correctly.

+        // MIDI and MIDI_SYSEX. This is a workaround to pass
+        // org.chromium.android_webview.test.AwPermissionManagerTest#testRequestMultiple
+        // because of RequestPermissions not implemented in AndroidWebView.
+        m_permissionService->RequestPermission(
+            PermissionName::MIDI,
+            getExecutionContext()->getSecurityOrigin()->toString(),
+            UserGestureIndicator::processingUserGesture(),
+            createBaseCallback(WTF::bind(&MIDIAccessInitializer::onPermissionUpdated, wrapPersistent(this))));
+    }
 
     return promise;
 }
 
 void MIDIAccessInitializer::didAddInputPort(const String& id, const String& manufacturer, const String& name, const String& version, PortState state)
 {
     DCHECK(m_accessor);
     m_portDescriptors.append(PortDescriptor(id, manufacturer, name, MIDIPort::TypeInput, version, state));
 }
 
@@ skipping 37 matching lines @@
             ec = AbortError;
         } else if (error == DOMException::getErrorName(InvalidStateError)) {
             ec = InvalidStateError;
         } else if (error == DOMException::getErrorName(NotSupportedError)) {
             ec = NotSupportedError;
         }
         reject(DOMException::create(ec, message));
     }
 }
 
-void MIDIAccessInitializer::resolvePermission(bool allowed)
-{
-    m_permissionResolved = true;
-    if (allowed)
-        m_accessor->startSession();
-    else
-        reject(DOMException::create(SecurityError));
-}
-
-SecurityOrigin* MIDIAccessInitializer::getSecurityOrigin() const
-{
-    return getExecutionContext()->getSecurityOrigin();
-}
-
 ExecutionContext* MIDIAccessInitializer::getExecutionContext() const
 {
     return getScriptState()->getExecutionContext();
 }
 
+void MIDIAccessInitializer::onPermissionsUpdated(mojo::WTFArray<PermissionStatus> statusArray)
+{
+    bool allowed = true;
+    for (const auto status : statusArray.storage()) {
+        if (status != PermissionStatus::GRANTED) {
+            allowed = false;
+            break;
+        }
+    }
+    m_permissionService.reset();
+    if (allowed)
+        m_accessor->startSession();
+    else
+        reject(DOMException::create(SecurityError));
+
+}
+
+void MIDIAccessInitializer::onPermissionUpdated(PermissionStatus status)
+{
+    m_permissionService.reset();
+    if (status == PermissionStatus::GRANTED)
+        m_accessor->startSession();
+    else
+        reject(DOMException::create(SecurityError));
+}
+
 } // namespace blink