Update Chromium to beta version 37.0.2062.68

Change-Id: I188e3b5aff1bec75566014291b654eb19f5bc8ca
Reviewed-by: Andras Becsi <andras.becsi@digia.com>

31 files changed, 629 insertions, 543 deletions

diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.cpp
index 5a572fb276a..b7e5bf70702 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.cpp
@@ -31,154 +31,102 @@
 #include "config.h"
 #include "modules/webmidi/MIDIAccess.h"
 
-#include "core/dom/DOMError.h"
 #include "core/dom/Document.h"
 #include "core/loader/DocumentLoadTiming.h"
 #include "core/loader/DocumentLoader.h"
-#include "modules/webmidi/MIDIAccessPromise.h"
+#include "modules/webmidi/MIDIAccessInitializer.h"
 #include "modules/webmidi/MIDIConnectionEvent.h"
 #include "modules/webmidi/MIDIController.h"
+#include "modules/webmidi/MIDIOptions.h"
 #include "modules/webmidi/MIDIPort.h"
+#include "platform/AsyncMethodRunner.h"
+#include <v8.h>
 
 namespace WebCore {
 
-PassRefPtr<MIDIAccess> MIDIAccess::create(ExecutionContext* context, MIDIAccessPromise* promise)
-{
-    RefPtr<MIDIAccess> midiAccess(adoptRef(new MIDIAccess(context, promise)));
-    midiAccess->suspendIfNeeded();
-    midiAccess->startRequest();
-    return midiAccess.release();
-}
-
-MIDIAccess::~MIDIAccess()
-{
-    stop();
-}
-
-MIDIAccess::MIDIAccess(ExecutionContext* context, MIDIAccessPromise* promise)
-    : ActiveDOMObject(context)
-    , m_promise(promise)
-    , m_hasAccess(false)
-    , m_sysExEnabled(false)
-    , m_requesting(false)
+MIDIAccess::MIDIAccess(PassOwnPtr<MIDIAccessor> accessor, bool sysexEnabled, const Vector<MIDIAccessInitializer::PortDescriptor>& ports, ExecutionContext* executionContext)
+    : ActiveDOMObject(executionContext)
+    , m_accessor(accessor)
+    , m_sysexEnabled(sysexEnabled)
 {
     ScriptWrappable::init(this);
-    m_accessor = MIDIAccessor::create(this);
+    m_accessor->setClient(this);
+    for (size_t i = 0; i < ports.size(); ++i) {
+        const MIDIAccessInitializer::PortDescriptor& port = ports[i];
+        if (port.type == MIDIPort::MIDIPortTypeInput) {
+            m_inputs.append(MIDIInput::create(this, port.id, port.manufacturer, port.name, port.version));
+        } else {
+            m_outputs.append(MIDIOutput::create(this, m_outputs.size(), port.id, port.manufacturer, port.name, port.version));
+        }
+    }
 }
 
-void MIDIAccess::setSysExEnabled(bool enable)
+MIDIAccess::~MIDIAccess()
 {
-    m_requesting = false;
-    m_sysExEnabled = enable;
-    if (enable)
-        m_accessor->startSession();
-    else
-        permissionDenied();
 }
 
 void MIDIAccess::didAddInputPort(const String& id, const String& manufacturer, const String& name, const String& version)
 {
     ASSERT(isMainThread());
-
-    m_inputs.append(MIDIInput::create(this, executionContext(), id, manufacturer, name, version));
+    m_inputs.append(MIDIInput::create(this, id, manufacturer, name, version));
 }
 
 void MIDIAccess::didAddOutputPort(const String& id, const String& manufacturer, const String& name, const String& version)
 {
     ASSERT(isMainThread());
-
     unsigned portIndex = m_outputs.size();
-    m_outputs.append(MIDIOutput::create(this, portIndex, executionContext(), id, manufacturer, name, version));
-}
-
-void MIDIAccess::didStartSession(bool success)
-{
-    ASSERT(isMainThread());
-
-    m_hasAccess = success;
-    if (success)
-        m_promise->fulfill();
-    else
-        m_promise->reject(DOMError::create("InvalidStateError"));
+    m_outputs.append(MIDIOutput::create(this, portIndex, id, manufacturer, name, version));
 }
 
 void MIDIAccess::didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp)
 {
     ASSERT(isMainThread());
+    if (portIndex >= m_inputs.size())
+        return;
 
-    if (m_hasAccess && portIndex < m_inputs.size()) {
-        // Convert from time in seconds which is based on the time coordinate system of monotonicallyIncreasingTime()
-        // into time in milliseconds (a DOMHighResTimeStamp) according to the same time coordinate system as performance.now().
-        // This is how timestamps are defined in the Web MIDI spec.
-        Document* document = toDocument(executionContext());
-        ASSERT(document);
+    // Convert from time in seconds which is based on the time coordinate system of monotonicallyIncreasingTime()
+    // into time in milliseconds (a DOMHighResTimeStamp) according to the same time coordinate system as performance.now().
+    // This is how timestamps are defined in the Web MIDI spec.
+    Document* document = toDocument(executionContext());
+    ASSERT(document);
 
-        double timeStampInMilliseconds = 1000 * document->loader()->timing()->monotonicTimeToZeroBasedDocumentTime(timeStamp);
+    double timeStampInMilliseconds = 1000 * document->loader()->timing()->monotonicTimeToZeroBasedDocumentTime(timeStamp);
 
-        m_inputs[portIndex]->didReceiveMIDIData(portIndex, data, length, timeStampInMilliseconds);
-    }
+    m_inputs[portIndex]->didReceiveMIDIData(portIndex, data, length, timeStampInMilliseconds);
 }
 
 void MIDIAccess::sendMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStampInMilliseconds)
 {
-    if (m_hasAccess && portIndex < m_outputs.size() && data && length > 1) {
-        // Convert from a time in milliseconds (a DOMHighResTimeStamp) according to the same time coordinate system as performance.now()
-        // into a time in seconds which is based on the time coordinate system of monotonicallyIncreasingTime().
-        double timeStamp;
-
-        if (!timeStampInMilliseconds) {
-            // We treat a value of 0 (which is the default value) as special, meaning "now".
-            // We need to translate it exactly to 0 seconds.
-            timeStamp = 0;
-        } else {
-            Document* document = toDocument(executionContext());
-            ASSERT(document);
-            double documentStartTime = document->loader()->timing()->referenceMonotonicTime();
-            timeStamp = documentStartTime + 0.001 * timeStampInMilliseconds;
-        }
-
-        m_accessor->sendMIDIData(portIndex, data, length, timeStamp);
+    if (!data || !length || portIndex >= m_outputs.size())
+        return;
+    // Convert from a time in milliseconds (a DOMHighResTimeStamp) according to the same time coordinate system as performance.now()
+    // into a time in seconds which is based on the time coordinate system of monotonicallyIncreasingTime().
+    double timeStamp;
+
+    if (!timeStampInMilliseconds) {
+        // We treat a value of 0 (which is the default value) as special, meaning "now".
+        // We need to translate it exactly to 0 seconds.
+        timeStamp = 0;
+    } else {
+        Document* document = toDocument(executionContext());
+        ASSERT(document);
+        double documentStartTime = document->loader()->timing()->referenceMonotonicTime();
+        timeStamp = documentStartTime + 0.001 * timeStampInMilliseconds;
     }
+
+    m_accessor->sendMIDIData(portIndex, data, length, timeStamp);
 }
 
 void MIDIAccess::stop()
 {
-    m_hasAccess = false;
-    if (!m_requesting)
-        return;
-    m_requesting = false;
-    Document* document = toDocument(executionContext());
-    ASSERT(document);
-    MIDIController* controller = MIDIController::from(document->page());
-    ASSERT(controller);
-    controller->cancelSysExPermissionRequest(this);
-
     m_accessor.clear();
 }
 
-void MIDIAccess::startRequest()
+void MIDIAccess::trace(Visitor* visitor)
 {
-    if (!m_promise->options()->sysex) {
-        m_accessor->startSession();
-        return;
-    }
-    Document* document = toDocument(executionContext());
-    ASSERT(document);
-    MIDIController* controller = MIDIController::from(document->page());
-    if (controller) {
-        m_requesting = true;
-        controller->requestSysExPermission(this);
-    } else {
-        permissionDenied();
-    }
-}
-
-void MIDIAccess::permissionDenied()
-{
-    ASSERT(isMainThread());
-
-    m_hasAccess = false;
-    m_promise->reject(DOMError::create("SecurityError"));
+    visitor->trace(m_inputs);
+    visitor->trace(m_outputs);
+    EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.h
index 9f6aaaf0c85..b543ec989f5 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.h
@@ -31,13 +31,16 @@
 #ifndef MIDIAccess_h
 #define MIDIAccess_h
 
+#include "bindings/v8/ScriptPromise.h"
 #include "bindings/v8/ScriptWrappable.h"
 #include "core/dom/ActiveDOMObject.h"
-#include "core/events/EventTarget.h"
+#include "modules/EventTargetModules.h"
+#include "modules/webmidi/MIDIAccessInitializer.h"
 #include "modules/webmidi/MIDIAccessor.h"
 #include "modules/webmidi/MIDIAccessorClient.h"
 #include "modules/webmidi/MIDIInput.h"
 #include "modules/webmidi/MIDIOutput.h"
+#include "platform/heap/Handle.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
@@ -45,13 +48,19 @@
 namespace WebCore {
 
 class ExecutionContext;
-class MIDIAccessPromise;
+struct MIDIOptions;
 
-class MIDIAccess : public RefCounted<MIDIAccess>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MIDIAccessorClient {
+class MIDIAccess FINAL : public RefCountedWillBeRefCountedGarbageCollected<MIDIAccess>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MIDIAccessorClient {
     REFCOUNTED_EVENT_TARGET(MIDIAccess);
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MIDIAccess);
 public:
+    static PassRefPtrWillBeRawPtr<MIDIAccess> create(PassOwnPtr<MIDIAccessor> accessor, bool sysexEnabled, const Vector<MIDIAccessInitializer::PortDescriptor>& ports, ExecutionContext* executionContext)
+    {
+        RefPtrWillBeRawPtr<MIDIAccess> access = adoptRefWillBeRefCountedGarbageCollected(new MIDIAccess(accessor, sysexEnabled, ports, executionContext));
+        access->suspendIfNeeded();
+        return access;
+    }
     virtual ~MIDIAccess();
-    static PassRefPtr<MIDIAccess> create(ExecutionContext*, MIDIAccessPromise*);
 
     MIDIInputVector inputs() const { return m_inputs; }
     MIDIOutputVector outputs() const { return m_outputs; }
@@ -59,39 +68,38 @@ public:
     DEFINE_ATTRIBUTE_EVENT_LISTENER(connect);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(disconnect);
 
-    void setSysExEnabled(bool);
-    bool sysExEnabled() const { return m_sysExEnabled; }
+    bool sysexEnabled() const { return m_sysexEnabled; }
 
     // EventTarget
     virtual const AtomicString& interfaceName() const OVERRIDE { return EventTargetNames::MIDIAccess; }
     virtual ExecutionContext* executionContext() const OVERRIDE { return ActiveDOMObject::executionContext(); }
 
     // ActiveDOMObject
-    virtual void stop();
+    virtual void stop() OVERRIDE;
 
     // MIDIAccessorClient
     virtual void didAddInputPort(const String& id, const String& manufacturer, const String& name, const String& version) OVERRIDE;
     virtual void didAddOutputPort(const String& id, const String& manufacturer, const String& name, const String& version) OVERRIDE;
-    virtual void didStartSession(bool success) OVERRIDE;
+    virtual void didStartSession(bool success, const String& error, const String& message) OVERRIDE
+    {
+        // This method is for MIDIAccess initialization: MIDIAccessInitializer
+        // has the implementation.
+        ASSERT_NOT_REACHED();
+    }
     virtual void didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp) OVERRIDE;
 
     // |timeStampInMilliseconds| is in the same time coordinate system as performance.now().
     void sendMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStampInMilliseconds);
 
-private:
-    MIDIAccess(ExecutionContext*, MIDIAccessPromise*);
+    virtual void trace(Visitor*) OVERRIDE;
 
-    void startRequest();
-    virtual void permissionDenied();
+private:
+    MIDIAccess(PassOwnPtr<MIDIAccessor>, bool sysexEnabled, const Vector<MIDIAccessInitializer::PortDescriptor>&, ExecutionContext*);
 
+    OwnPtr<MIDIAccessor> m_accessor;
+    bool m_sysexEnabled;
     MIDIInputVector m_inputs;
     MIDIOutputVector m_outputs;
-    MIDIAccessPromise* m_promise;
-
-    OwnPtr<MIDIAccessor> m_accessor;
-    bool m_hasAccess;
-    bool m_sysExEnabled;
-    bool m_requesting;
 };
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.idl b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.idl
index a20b6bc692f..5ffcfac784d 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.idl
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccess.idl
@@ -35,6 +35,8 @@
     sequence<MIDIInput> inputs();
     sequence<MIDIOutput> outputs();
 
+    readonly attribute boolean sysexEnabled;
+
     attribute EventHandler onconnect;
     attribute EventHandler ondisconnect;
 };
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.cpp
new file mode 100644
index 00000000000..5a53ba83417
--- /dev/null
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.cpp
@@ -0,0 +1,98 @@
+// 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 "config.h"
+#include "modules/webmidi/MIDIAccessInitializer.h"
+
+#include "bindings/v8/ScriptPromise.h"
+#include "bindings/v8/ScriptPromiseResolverWithContext.h"
+#include "core/dom/DOMError.h"
+#include "core/dom/Document.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"
+
+namespace WebCore {
+
+MIDIAccessInitializer::MIDIAccessInitializer(ScriptState* scriptState, const MIDIOptions& options)
+    : ScriptPromiseResolverWithContext(scriptState)
+    , m_options(options)
+    , m_sysexEnabled(false)
+{
+}
+
+MIDIAccessInitializer::~MIDIAccessInitializer()
+{
+    // It is safe to cancel a request which is already finished or canceld.
+    Document* document = toDocument(executionContext());
+    ASSERT(document);
+    MIDIController* controller = MIDIController::from(document->frame());
+    if (controller)
+        controller->cancelSysexPermissionRequest(this);
+}
+
+ScriptPromise MIDIAccessInitializer::start()
+{
+    ScriptPromise promise = this->promise();
+    m_accessor = MIDIAccessor::create(this);
+
+    if (!m_options.sysex) {
+        m_accessor->startSession();
+        return promise;
+    }
+    Document* document = toDocument(executionContext());
+    ASSERT(document);
+    MIDIController* controller = MIDIController::from(document->frame());
+    if (controller) {
+        controller->requestSysexPermission(this);
+    } else {
+        reject(DOMError::create("SecurityError"));
+    }
+    return promise;
+}
+
+void MIDIAccessInitializer::didAddInputPort(const String& id, const String& manufacturer, const String& name, const String& version)
+{
+    ASSERT(m_accessor);
+    m_portDescriptors.append(PortDescriptor(id, manufacturer, name, MIDIPort::MIDIPortTypeInput, version));
+}
+
+void MIDIAccessInitializer::didAddOutputPort(const String& id, const String& manufacturer, const String& name, const String& version)
+{
+    ASSERT(m_accessor);
+    m_portDescriptors.append(PortDescriptor(id, manufacturer, name, MIDIPort::MIDIPortTypeOutput, version));
+}
+
+void MIDIAccessInitializer::didStartSession(bool success, const String& error, const String& message)
+{
+    ASSERT(m_accessor);
+    if (success) {
+        resolve(MIDIAccess::create(m_accessor.release(), m_sysexEnabled, m_portDescriptors, executionContext()));
+    } else {
+        reject(DOMError::create(error, message));
+    }
+}
+
+void MIDIAccessInitializer::setSysexEnabled(bool enable)
+{
+    m_sysexEnabled = enable;
+    if (enable)
+        m_accessor->startSession();
+    else
+        reject(DOMError::create("SecurityError"));
+}
+
+SecurityOrigin* MIDIAccessInitializer::securityOrigin() const
+{
+    return executionContext()->securityOrigin();
+}
+
+ExecutionContext* MIDIAccessInitializer::executionContext() const
+{
+    return scriptState()->executionContext();
+}
+
+} // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.h
new file mode 100644
index 00000000000..6f3f605228f
--- /dev/null
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.h
@@ -0,0 +1,76 @@
+// 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.
+
+#ifndef MIDIAccessInitializer_h
+#define MIDIAccessInitializer_h
+
+#include "bindings/v8/ScriptPromise.h"
+#include "bindings/v8/ScriptPromiseResolverWithContext.h"
+#include "modules/webmidi/MIDIAccessor.h"
+#include "modules/webmidi/MIDIAccessorClient.h"
+#include "modules/webmidi/MIDIOptions.h"
+#include "modules/webmidi/MIDIPort.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/RawPtr.h"
+#include "wtf/Vector.h"
+
+namespace WebCore {
+
+class MIDIAccess;
+class Navigator;
+class ScriptState;
+
+class MIDIAccessInitializer : public ScriptPromiseResolverWithContext, public MIDIAccessorClient {
+public:
+    struct PortDescriptor {
+        String id;
+        String manufacturer;
+        String name;
+        MIDIPort::MIDIPortTypeCode type;
+        String version;
+
+        PortDescriptor(const String& id, const String& manufacturer, const String& name, MIDIPort::MIDIPortTypeCode type, const String& version)
+            : id(id)
+            , manufacturer(manufacturer)
+            , name(name)
+            , type(type)
+            , version(version) { }
+    };
+
+    static ScriptPromise start(ScriptState* scriptState, const MIDIOptions& options)
+    {
+        RefPtr<MIDIAccessInitializer> p = adoptRef(new MIDIAccessInitializer(scriptState, options));
+        p->keepAliveWhilePending();
+        p->suspendIfNeeded();
+        return p->start();
+    }
+
+    virtual ~MIDIAccessInitializer();
+
+    // MIDIAccessorClient
+    virtual void didAddInputPort(const String& id, const String& manufacturer, const String& name, const String& version) OVERRIDE;
+    virtual void didAddOutputPort(const String& id, const String& manufacturer, const String& name, const String& version) OVERRIDE;
+    virtual void didStartSession(bool success, const String& error, const String& message) OVERRIDE;
+    virtual void didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp) OVERRIDE { }
+
+    void setSysexEnabled(bool value);
+    SecurityOrigin* securityOrigin() const;
+
+private:
+    ScriptPromise start();
+
+    MIDIAccessInitializer(ScriptState*, const MIDIOptions&);
+
+    ExecutionContext* executionContext() const;
+
+    OwnPtr<MIDIAccessor> m_accessor;
+    MIDIOptions m_options;
+    bool m_sysexEnabled;
+    Vector<PortDescriptor> m_portDescriptors;
+};
+
+} // namespace WebCore
+
+
+#endif // MIDIAccessInitializer_h
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.cpp
deleted file mode 100644
index 7ae06b3faae..00000000000
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "modules/webmidi/MIDIAccessPromise.h"
-
-#include "core/dom/DOMError.h"
-#include "modules/webmidi/MIDIAccess.h"
-#include "modules/webmidi/MIDIErrorCallback.h"
-#include "modules/webmidi/MIDISuccessCallback.h"
-
-namespace WebCore {
-
-PassRefPtr<MIDIAccessPromise> MIDIAccessPromise::create(ExecutionContext* context, const Dictionary& options)
-{
-    RefPtr<MIDIAccessPromise> midiAccessPromise(adoptRef(new MIDIAccessPromise(context, options)));
-    midiAccessPromise->suspendIfNeeded();
-    return midiAccessPromise.release();
-}
-
-MIDIAccessPromise::MIDIAccessPromise(ExecutionContext* context, const Dictionary& options)
-    : ActiveDOMObject(context)
-    , m_state(Pending)
-    , m_options(adoptPtr(new MIDIOptions(options)))
-{
-    ScriptWrappable::init(this);
-}
-
-MIDIAccessPromise::~MIDIAccessPromise()
-{
-    stop();
-}
-
-bool MIDIAccessPromise::hasPendingActivity() const
-{
-    return !!m_access && m_state != Accepted && m_state != Rejected;
-}
-
-void MIDIAccessPromise::stop()
-{
-    m_state = Invoked;
-    if (!!m_access)
-        m_access->stop();
-    clear();
-}
-
-void MIDIAccessPromise::fulfill()
-{
-    if (m_state == Pending) {
-        if (m_successCallback) {
-            m_state = Invoked;
-            ASSERT(m_access);
-            m_successCallback->handleEvent(m_access.get(), m_options->sysex);
-            clear();
-        } else {
-            m_state = Accepted;
-        }
-    }
-}
-
-void MIDIAccessPromise::reject(PassRefPtr<DOMError> error)
-{
-    if (m_state == Pending) {
-        if (m_errorCallback) {
-            m_state = Invoked;
-            m_errorCallback->handleEvent(error.get());
-            clear();
-        } else {
-            m_state = Rejected;
-            m_error = error;
-        }
-    }
-}
-
-void MIDIAccessPromise::then(PassOwnPtr<MIDISuccessCallback> successCallback, PassOwnPtr<MIDIErrorCallback> errorCallback)
-{
-    // Lazily request access.
-    if (!m_access)
-        m_access = MIDIAccess::create(executionContext(), this);
-
-    switch (m_state) {
-    case Accepted:
-        m_state = Invoked;
-        successCallback->handleEvent(m_access.get(), m_options->sysex);
-        clear();
-        break;
-    case Rejected:
-        m_state = Invoked;
-        errorCallback->handleEvent(m_error.get());
-        clear();
-        break;
-    case Pending:
-        m_successCallback = successCallback;
-        m_errorCallback = errorCallback;
-        break;
-    case Invoked:
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
-}
-
-void MIDIAccessPromise::clear()
-{
-    ASSERT(m_state == Invoked);
-    m_access.clear();
-    m_error.clear();
-    m_options.clear();
-    m_successCallback.clear();
-    m_errorCallback.clear();
-}
-
-} // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.h
deleted file mode 100644
index 074273c74cd..00000000000
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef MIDIAccessPromise_h
-#define MIDIAccessPromise_h
-
-#include "bindings/v8/ScriptWrappable.h"
-#include "core/dom/ActiveDOMObject.h"
-#include "modules/webmidi/MIDIOptions.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassRefPtr.h"
-#include "wtf/RefCounted.h"
-
-namespace WebCore {
-
-class DOMError;
-class MIDIAccess;
-class MIDIErrorCallback;
-class MIDISuccessCallback;
-class ExecutionContext;
-
-struct MIDIOptions;
-
-class MIDIAccessPromise : public RefCounted<MIDIAccessPromise>, public ScriptWrappable, public ActiveDOMObject {
-public:
-    static PassRefPtr<MIDIAccessPromise> create(ExecutionContext*, const Dictionary&);
-    virtual ~MIDIAccessPromise();
-
-    // ActiveDOMObject
-    virtual bool hasPendingActivity() const OVERRIDE;
-    virtual void stop() OVERRIDE;
-
-    MIDIOptions* options() { return m_options.get(); }
-
-    void fulfill();
-    void reject(PassRefPtr<DOMError>);
-
-    void then(PassOwnPtr<MIDISuccessCallback>, PassOwnPtr<MIDIErrorCallback>);
-
-private:
-    enum State {
-        Pending,
-        Accepted,
-        Rejected,
-        Invoked,
-    };
-
-    MIDIAccessPromise(ExecutionContext*, const Dictionary&);
-
-    void clear();
-
-    State m_state;
-    OwnPtr<MIDISuccessCallback> m_successCallback;
-    OwnPtr<MIDIErrorCallback> m_errorCallback;
-    OwnPtr<MIDIOptions> m_options;
-    RefPtr<DOMError> m_error;
-    RefPtr<MIDIAccess> m_access;
-};
-
-} // namespace WebCore
-
-#endif // MIDIAccessPromise_h
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.cpp
index 478c73cbde2..e9a94b0419c 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.cpp
@@ -75,9 +75,9 @@ void MIDIAccessor::didAddOutputPort(const WebString& id, const WebString& manufa
     m_client->didAddOutputPort(id, manufacturer, name, version);
 }
 
-void MIDIAccessor::didStartSession(bool success)
+void MIDIAccessor::didStartSession(bool success, const WebString& error, const WebString& message)
 {
-    m_client->didStartSession(success);
+    m_client->didStartSession(success, error, message);
 }
 
 void MIDIAccessor::didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp)
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.h
index 78290b6a88f..d45870e3a94 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessor.h
@@ -40,7 +40,7 @@ namespace WebCore {
 
 class MIDIAccessorClient;
 
-class MIDIAccessor : public blink::WebMIDIAccessorClient {
+class MIDIAccessor FINAL : public blink::WebMIDIAccessorClient {
 public:
     static PassOwnPtr<MIDIAccessor> create(MIDIAccessorClient*);
 
@@ -48,11 +48,15 @@ public:
 
     void startSession();
     void sendMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp);
+    // MIDIAccessInitializer and MIDIAccess are both MIDIAccessClient.
+    // MIDIAccessInitializer is the first client and MIDIAccess takes over it
+    // once the initialization successfully finishes.
+    void setClient(MIDIAccessorClient* client) { m_client = client; }
 
     // blink::WebMIDIAccessorClient
     virtual void didAddInputPort(const blink::WebString& id, const blink::WebString& manufacturer, const blink::WebString& name, const blink::WebString& version) OVERRIDE;
     virtual void didAddOutputPort(const blink::WebString& id, const blink::WebString& manufacturer, const blink::WebString& name, const blink::WebString& version) OVERRIDE;
-    virtual void didStartSession(bool success) OVERRIDE;
+    virtual void didStartSession(bool success, const blink::WebString& error, const blink::WebString& message) OVERRIDE;
     virtual void didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp) OVERRIDE;
 
 private:
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessorClient.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessorClient.h
index 450b8f60c0a..198374ffec0 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessorClient.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessorClient.h
@@ -40,7 +40,7 @@ public:
     virtual void didAddInputPort(const String& id, const String& manufacturer, const String& name, const String& version) = 0;
     virtual void didAddOutputPort(const String& id, const String& manufacturer, const String& name, const String& version) = 0;
 
-    virtual void didStartSession(bool success) = 0;
+    virtual void didStartSession(bool success, const String& error, const String& message) = 0;
     virtual void didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp) = 0;
 };
 
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClient.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClient.h
index 5c797c4fb22..32daafe833e 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClient.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClient.h
@@ -31,23 +31,22 @@
 #ifndef MIDIClient_h
 #define MIDIClient_h
 
-#include "wtf/PassRefPtr.h"
+#include "platform/heap/Handle.h"
 
 namespace WebCore {
 
-class MIDIAccess;
-class Page;
+class LocalFrame;
+class MIDIAccessInitializer;
 
 class MIDIClient {
 public:
-    virtual void requestSysExPermission(PassRefPtr<MIDIAccess>) = 0;
-    virtual void cancelSysExPermissionRequest(MIDIAccess*) = 0;
+    virtual void requestSysexPermission(MIDIAccessInitializer*) = 0;
+    virtual void cancelSysexPermissionRequest(MIDIAccessInitializer*) = 0;
 
-protected:
     virtual ~MIDIClient() { }
 };
 
-void provideMIDITo(Page*, MIDIClient*);
+void provideMIDITo(LocalFrame&, PassOwnPtr<MIDIClient>);
 
 } // namespace WebCore
 
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.cpp
index 800cf50fbb6..5b9f3976856 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.cpp
@@ -31,7 +31,7 @@
 #include "config.h"
 #include "modules/webmidi/MIDIClientMock.h"
 
-#include "modules/webmidi/MIDIAccess.h"
+#include "modules/webmidi/MIDIAccessInitializer.h"
 
 namespace WebCore {
 
@@ -44,7 +44,7 @@ MIDIClientMock::~MIDIClientMock()
 {
 }
 
-void MIDIClientMock::setSysExPermission(bool allowed)
+void MIDIClientMock::setSysexPermission(bool allowed)
 {
     m_allowed = allowed;
 }
@@ -54,12 +54,12 @@ void MIDIClientMock::resetMock()
     m_allowed = false;
 }
 
-void MIDIClientMock::requestSysExPermission(PassRefPtr<MIDIAccess> access)
+void MIDIClientMock::requestSysexPermission(MIDIAccessInitializer* initializer)
 {
-    access->setSysExEnabled(m_allowed);
+    initializer->setSysexEnabled(m_allowed);
 }
 
-void MIDIClientMock::cancelSysExPermissionRequest(MIDIAccess*)
+void MIDIClientMock::cancelSysexPermissionRequest(MIDIAccessInitializer*)
 {
 }
 
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.h
index 095b6b6e345..fedb2c280f8 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIClientMock.h
@@ -32,21 +32,22 @@
 #define MIDIClientMock_h
 
 #include "modules/webmidi/MIDIClient.h"
+#include "platform/heap/Handle.h"
 
 namespace WebCore {
 
 // FIXME: This belongs in Source/testing/runner, not compiled into shipping Blink!
-class MIDIClientMock : public MIDIClient {
+class MIDIClientMock FINAL : public MIDIClient {
 public:
     MIDIClientMock();
     virtual ~MIDIClientMock();
 
-    void setSysExPermission(bool);
+    void setSysexPermission(bool);
     void resetMock();
 
     // MIDIClient
-    virtual void requestSysExPermission(PassRefPtr<MIDIAccess>) OVERRIDE;
-    virtual void cancelSysExPermissionRequest(MIDIAccess*) OVERRIDE;
+    virtual void requestSysexPermission(MIDIAccessInitializer*) OVERRIDE;
+    virtual void cancelSysexPermissionRequest(MIDIAccessInitializer*) OVERRIDE;
 
 private:
     bool m_allowed;
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.idl b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.cpp
index 2a4b37a8195..cd4692a0d3e 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIAccessPromise.idl
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -28,12 +28,49 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// FIXME: Once Promise is implemented, remove this interface and use it.
-// See also, http://crbug.com/243345
-[
-    NoInterfaceObject,
-    ActiveDOMObject
-] interface MIDIAccessPromise {
-    // Supports only then() method tentatively. But it never returns Promise.
-    void then(MIDISuccessCallback successCallback, MIDIErrorCallback errorCallback);
-};
+#include "config.h"
+#include "modules/webmidi/MIDIConnectionEvent.h"
+
+namespace WebCore {
+
+MIDIConnectionEvent::MIDIConnectionEvent()
+{
+    ScriptWrappable::init(this);
+}
+
+MIDIConnectionEvent::MIDIConnectionEvent(const AtomicString& type, PassRefPtrWillBeRawPtr<MIDIPort> port)
+    : Event(type, false, false)
+    , m_port(port)
+{
+    ScriptWrappable::init(this);
+}
+
+MIDIConnectionEvent::MIDIConnectionEvent(const AtomicString& type, const MIDIConnectionEventInit& initializer)
+    : Event(type, initializer)
+    , m_port(initializer.port)
+{
+    ScriptWrappable::init(this);
+}
+
+PassRefPtrWillBeRawPtr<MIDIConnectionEvent> MIDIConnectionEvent::create()
+{
+    return adoptRefWillBeNoop(new MIDIConnectionEvent());
+}
+
+PassRefPtrWillBeRawPtr<MIDIConnectionEvent> MIDIConnectionEvent::create(const AtomicString& type, PassRefPtrWillBeRawPtr<MIDIPort> port)
+{
+    return adoptRefWillBeNoop(new MIDIConnectionEvent(type, port));
+}
+
+PassRefPtrWillBeRawPtr<MIDIConnectionEvent> MIDIConnectionEvent::create(const AtomicString& type, const MIDIConnectionEventInit& initializer)
+{
+    return adoptRefWillBeNoop(new MIDIConnectionEvent(type, initializer));
+}
+
+void MIDIConnectionEvent::trace(Visitor* visitor)
+{
+    visitor->trace(m_port);
+    Event::trace(visitor);
+}
+
+} // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.h
index 3579a70e57a..aad2888783e 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.h
@@ -31,62 +31,38 @@
 #ifndef MIDIConnectionEvent_h
 #define MIDIConnectionEvent_h
 
-#include "core/events/Event.h"
+#include "modules/EventModules.h"
 #include "modules/webmidi/MIDIPort.h"
 
 namespace WebCore {
 
 struct MIDIConnectionEventInit : public EventInit {
     MIDIConnectionEventInit()
-        : port(0)
+        : port(nullptr)
     {
-    };
+    }
 
-    RefPtr<MIDIPort> port;
+    RefPtrWillBeMember<MIDIPort> port;
 };
 
-class MIDIConnectionEvent : public Event {
+class MIDIConnectionEvent FINAL : public Event {
 public:
-    static PassRefPtr<MIDIConnectionEvent> create()
-    {
-        return adoptRef(new MIDIConnectionEvent());
-    }
-
-    static PassRefPtr<MIDIConnectionEvent> create(const AtomicString& type, PassRefPtr<MIDIPort> port)
-    {
-        return adoptRef(new MIDIConnectionEvent(type, port));
-    }
-
-    static PassRefPtr<MIDIConnectionEvent> create(const AtomicString& type, const MIDIConnectionEventInit& initializer)
-    {
-        return adoptRef(new MIDIConnectionEvent(type, initializer));
-    }
+    static PassRefPtrWillBeRawPtr<MIDIConnectionEvent> create();
+    static PassRefPtrWillBeRawPtr<MIDIConnectionEvent> create(const AtomicString&, PassRefPtrWillBeRawPtr<MIDIPort>);
+    static PassRefPtrWillBeRawPtr<MIDIConnectionEvent> create(const AtomicString&, const MIDIConnectionEventInit&);
 
-    RefPtr<MIDIPort> port() { return m_port; }
+    PassRefPtrWillBeRawPtr<MIDIPort> port() { return m_port; }
 
     virtual const AtomicString& interfaceName() const OVERRIDE { return EventNames::MIDIConnectionEvent; }
 
-private:
-    MIDIConnectionEvent()
-    {
-        ScriptWrappable::init(this);
-    }
+    virtual void trace(Visitor*) OVERRIDE;
 
-    MIDIConnectionEvent(const AtomicString& type, PassRefPtr<MIDIPort> port)
-        : Event(type, false, false)
-        , m_port(port)
-    {
-        ScriptWrappable::init(this);
-    }
-
-    MIDIConnectionEvent(const AtomicString& type, const MIDIConnectionEventInit& initializer)
-        : Event(type, initializer)
-        , m_port(initializer.port)
-    {
-        ScriptWrappable::init(this);
-    }
+private:
+    MIDIConnectionEvent();
+    MIDIConnectionEvent(const AtomicString&, PassRefPtrWillBeRawPtr<MIDIPort>);
+    MIDIConnectionEvent(const AtomicString&, const MIDIConnectionEventInit&);
 
-    RefPtr<MIDIPort> m_port;
+    RefPtrWillBeMember<MIDIPort> m_port;
 };
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.cpp
index ab0f6177446..45d44da5bf8 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.cpp
@@ -31,7 +31,7 @@
 #include "config.h"
 #include "modules/webmidi/MIDIController.h"
 
-#include "modules/webmidi/MIDIAccess.h"
+#include "modules/webmidi/MIDIAccessInitializer.h"
 #include "modules/webmidi/MIDIClient.h"
 
 namespace WebCore {
@@ -41,34 +41,34 @@ const char* MIDIController::supplementName()
     return "MIDIController";
 }
 
-MIDIController::MIDIController(MIDIClient* client)
+MIDIController::MIDIController(PassOwnPtr<MIDIClient> client)
     : m_client(client)
 {
-    ASSERT(client);
+    ASSERT(m_client);
 }
 
 MIDIController::~MIDIController()
 {
 }
 
-PassOwnPtr<MIDIController> MIDIController::create(MIDIClient* client)
+PassOwnPtrWillBeRawPtr<MIDIController> MIDIController::create(PassOwnPtr<MIDIClient> client)
 {
-    return adoptPtr(new MIDIController(client));
+    return adoptPtrWillBeNoop(new MIDIController(client));
 }
 
-void MIDIController::requestSysExPermission(PassRefPtr<MIDIAccess> access)
+void MIDIController::requestSysexPermission(MIDIAccessInitializer* initializer)
 {
-    m_client->requestSysExPermission(access);
+    m_client->requestSysexPermission(initializer);
 }
 
-void MIDIController::cancelSysExPermissionRequest(MIDIAccess* access)
+void MIDIController::cancelSysexPermissionRequest(MIDIAccessInitializer* initializer)
 {
-    m_client->cancelSysExPermissionRequest(access);
+    m_client->cancelSysexPermissionRequest(initializer);
 }
 
-void provideMIDITo(Page* page, MIDIClient* client)
+void provideMIDITo(LocalFrame& frame, PassOwnPtr<MIDIClient> client)
 {
-    MIDIController::provideTo(page, MIDIController::supplementName(), MIDIController::create(client));
+    MIDIController::provideTo(frame, MIDIController::supplementName(), MIDIController::create(client));
 }
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.h
index c947f18b1a5..2aff8a39254 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIController.h
@@ -31,30 +31,33 @@
 #ifndef MIDIController_h
 #define MIDIController_h
 
-#include "core/page/Page.h"
-#include "wtf/RefPtr.h"
+#include "core/frame/LocalFrame.h"
+#include "platform/heap/Handle.h"
 
 namespace WebCore {
 
-class MIDIAccess;
+class MIDIAccessInitializer;
 class MIDIClient;
 
-class MIDIController : public Supplement<Page> {
+class MIDIController FINAL : public NoBaseWillBeGarbageCollectedFinalized<MIDIController>, public WillBeHeapSupplement<LocalFrame> {
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MIDIController);
 public:
-    ~MIDIController();
+    virtual ~MIDIController();
 
-    void requestSysExPermission(PassRefPtr<MIDIAccess>);
-    void cancelSysExPermissionRequest(MIDIAccess*);
+    void requestSysexPermission(MIDIAccessInitializer*);
+    void cancelSysexPermissionRequest(MIDIAccessInitializer*);
 
-    static PassOwnPtr<MIDIController> create(MIDIClient*);
+    static PassOwnPtrWillBeRawPtr<MIDIController> create(PassOwnPtr<MIDIClient>);
     static const char* supplementName();
-    static MIDIController* from(Page* page) { return static_cast<MIDIController*>(Supplement<Page>::from(page, supplementName())); }
+    static MIDIController* from(LocalFrame* frame) { return static_cast<MIDIController*>(WillBeHeapSupplement<LocalFrame>::from(frame, supplementName())); }
+
+    virtual void trace(Visitor* visitor) OVERRIDE { WillBeHeapSupplement<LocalFrame>::trace(visitor); }
 
 protected:
-    explicit MIDIController(MIDIClient*);
+    explicit MIDIController(PassOwnPtr<MIDIClient>);
 
 private:
-    MIDIClient* m_client;
+    OwnPtr<MIDIClient> m_client;
 };
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.cpp
index 748b844e226..10ed596fd29 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.cpp
@@ -33,20 +33,19 @@
 
 #include "modules/webmidi/MIDIAccess.h"
 #include "modules/webmidi/MIDIMessageEvent.h"
+#include "platform/heap/Handle.h"
 
 namespace WebCore {
 
-PassRefPtr<MIDIInput> MIDIInput::create(MIDIAccess* access, ExecutionContext* context, const String& id, const String& manufacturer, const String& name, const String& version)
+PassRefPtrWillBeRawPtr<MIDIInput> MIDIInput::create(MIDIAccess* access, const String& id, const String& manufacturer, const String& name, const String& version)
 {
     ASSERT(access);
-    RefPtr<MIDIInput> input = adoptRef(new MIDIInput(access, context, id, manufacturer, name, version));
-    input->suspendIfNeeded();
+    RefPtrWillBeRawPtr<MIDIInput> input = adoptRefWillBeRefCountedGarbageCollected(new MIDIInput(access, id, manufacturer, name, version));
     return input.release();
 }
 
-MIDIInput::MIDIInput(MIDIAccess* access, ExecutionContext* context, const String& id, const String& manufacturer, const String& name, const String& version)
-    : MIDIPort(context, id, manufacturer, name, MIDIPortTypeInput, version)
-    , m_access(access)
+MIDIInput::MIDIInput(MIDIAccess* access, const String& id, const String& manufacturer, const String& name, const String& version)
+    : MIDIPort(access, id, manufacturer, name, MIDIPortTypeInput, version)
 {
     ScriptWrappable::init(this);
 }
@@ -58,13 +57,18 @@ void MIDIInput::didReceiveMIDIData(unsigned portIndex, const unsigned char* data
     if (!length)
         return;
 
-    // Drop SysEx message here when the client does not request it. Note that this is not a security check but an
-    // automatic filtering for clients that do not want SysEx message. Also note that SysEx message will never be sent
-    // unless the current process has an explicit permission to handle SysEx message.
-    if (data[0] == 0xf0 && !m_access->sysExEnabled())
+    // Drop sysex message here when the client does not request it. Note that this is not a security check but an
+    // automatic filtering for clients that do not want sysex message. Also note that sysex message will never be sent
+    // unless the current process has an explicit permission to handle sysex message.
+    if (data[0] == 0xf0 && !midiAccess()->sysexEnabled())
         return;
     RefPtr<Uint8Array> array = Uint8Array::create(data, length);
     dispatchEvent(MIDIMessageEvent::create(timeStamp, array));
 }
 
+void MIDIInput::trace(Visitor* visitor)
+{
+    MIDIPort::trace(visitor);
+}
+
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.h
index 39f7efdd9fc..7901214af23 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.h
@@ -31,17 +31,16 @@
 #ifndef MIDIInput_h
 #define MIDIInput_h
 
-#include "core/events/EventTarget.h"
+#include "modules/EventTargetModules.h"
 #include "modules/webmidi/MIDIPort.h"
 
 namespace WebCore {
 
 class MIDIAccess;
-class ExecutionContext;
 
-class MIDIInput : public MIDIPort {
+class MIDIInput FINAL : public MIDIPort {
 public:
-    static PassRefPtr<MIDIInput> create(MIDIAccess*, ExecutionContext*, const String& id, const String& manufacturer, const String& name, const String& version);
+    static PassRefPtrWillBeRawPtr<MIDIInput> create(MIDIAccess*, const String& id, const String& manufacturer, const String& name, const String& version);
     virtual ~MIDIInput() { }
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(midimessage);
@@ -52,15 +51,13 @@ public:
     // |timeStamp| is a DOMHighResTimeStamp in the time coordinate system of performance.now().
     void didReceiveMIDIData(unsigned portIndex, const unsigned char* data, size_t length, double timeStamp);
 
-    MIDIAccess* midiAccess() const { return m_access; }
+    virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    MIDIInput(MIDIAccess*, ExecutionContext*, const String& id, const String& manufacturer, const String& name, const String& version);
-
-    MIDIAccess* m_access;
+    MIDIInput(MIDIAccess*, const String& id, const String& manufacturer, const String& name, const String& version);
 };
 
-typedef Vector<RefPtr<MIDIInput> > MIDIInputVector;
+typedef WillBeHeapVector<RefPtrWillBeMember<MIDIInput> > MIDIInputVector;
 
 } // namespace WebCore
 
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.idl b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.idl
index 7f3db641fd8..4986c54630d 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.idl
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIInput.idl
@@ -29,9 +29,8 @@
  */
 
 [
-    ActiveDOMObject,
-    Custom=Wrap,
     NoInterfaceObject,
+    SetWrapperReferenceTo(MIDIAccess midiAccess),
 ] interface MIDIInput : MIDIPort {
     attribute EventHandler onmidimessage;
 };
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIMessageEvent.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIMessageEvent.h
index 8c173ce6707..b4517e0c39b 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIMessageEvent.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIMessageEvent.h
@@ -31,7 +31,7 @@
 #ifndef MIDIMessageEvent_h
 #define MIDIMessageEvent_h
 
-#include "core/events/Event.h"
+#include "modules/EventModules.h"
 #include "wtf/Uint8Array.h"
 
 namespace WebCore {
@@ -46,21 +46,21 @@ struct MIDIMessageEventInit : public EventInit {
     RefPtr<Uint8Array> data;
 };
 
-class MIDIMessageEvent : public Event {
+class MIDIMessageEvent FINAL : public Event {
 public:
-    static PassRefPtr<MIDIMessageEvent> create()
+    static PassRefPtrWillBeRawPtr<MIDIMessageEvent> create()
     {
-        return adoptRef(new MIDIMessageEvent());
+        return adoptRefWillBeNoop(new MIDIMessageEvent());
     }
 
-    static PassRefPtr<MIDIMessageEvent> create(double receivedTime, PassRefPtr<Uint8Array> data)
+    static PassRefPtrWillBeRawPtr<MIDIMessageEvent> create(double receivedTime, PassRefPtr<Uint8Array> data)
     {
-        return adoptRef(new MIDIMessageEvent(receivedTime, data));
+        return adoptRefWillBeNoop(new MIDIMessageEvent(receivedTime, data));
     }
 
-    static PassRefPtr<MIDIMessageEvent> create(const AtomicString& type, const MIDIMessageEventInit& initializer)
+    static PassRefPtrWillBeRawPtr<MIDIMessageEvent> create(const AtomicString& type, const MIDIMessageEventInit& initializer)
     {
-        return adoptRef(new MIDIMessageEvent(type, initializer));
+        return adoptRefWillBeNoop(new MIDIMessageEvent(type, initializer));
     }
 
     double receivedTime() { return m_receivedTime; }
@@ -68,6 +68,8 @@ public:
 
     virtual const AtomicString& interfaceName() const OVERRIDE { return EventNames::MIDIMessageEvent; }
 
+    virtual void trace(Visitor* visitor) OVERRIDE { Event::trace(visitor); }
+
 private:
     MIDIMessageEvent()
         : m_receivedTime(0)
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.cpp
index 44b3d77e780..268e9667a68 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.cpp
@@ -33,21 +33,154 @@
 
 #include "bindings/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/timing/Performance.h"
 #include "modules/webmidi/MIDIAccess.h"
 
 namespace WebCore {
 
-PassRefPtr<MIDIOutput> MIDIOutput::create(MIDIAccess* access, unsigned portIndex, ExecutionContext* context, const String& id, const String& manufacturer, const String& name, const String& version)
+namespace {
+
+double now(ExecutionContext* context)
+{
+    LocalDOMWindow* window = context ? context->executingWindow() : 0;
+    Performance* performance = window ? &window->performance() : 0;
+    return performance ? performance->now() : 0.0;
+}
+
+class MessageValidator {
+public:
+    static bool validate(Uint8Array* array, ExceptionState& exceptionState, bool sysexEnabled)
+    {
+        MessageValidator validator(array);
+        return validator.process(exceptionState, sysexEnabled);
+    }
+private:
+    MessageValidator(Uint8Array* array)
+        : m_data(array->data())
+        , m_length(array->length())
+        , m_offset(0) { }
+
+    bool process(ExceptionState& exceptionState, bool sysexEnabled)
+    {
+        while (!isEndOfData() && acceptRealTimeMessages()) {
+            if (!isStatusByte()) {
+                exceptionState.throwTypeError("Running status is not allowed " + getPositionString());
+                return false;
+            }
+            if (isEndOfSysex()) {
+                exceptionState.throwTypeError("Unexpected end of system exclusive message " + getPositionString());
+                return false;
+            }
+            if (isReservedStatusByte()) {
+                exceptionState.throwTypeError("Reserved status is not allowed " + getPositionString());
+                return false;
+            }
+            if (isSysex()) {
+                if (!sysexEnabled) {
+                    exceptionState.throwDOMException(InvalidAccessError, "System exclusive message is not allowed " + getPositionString());
+                    return false;
+                }
+                if (!acceptCurrentSysex()) {
+                    if (isEndOfData())
+                        exceptionState.throwTypeError("System exclusive message is not ended by end of system exclusive message.");
+                    else
+                        exceptionState.throwTypeError("System exclusive message contains a status byte " + getPositionString());
+                    return false;
+                }
+            } else {
+                if (!acceptCurrentMessage()) {
+                    if (isEndOfData())
+                        exceptionState.throwTypeError("Message is incomplete.");
+                    else
+                        exceptionState.throwTypeError("Unexpected status byte at index " + getPositionString());
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+private:
+    bool isEndOfData() { return m_offset >= m_length; }
+    bool isSysex() { return m_data[m_offset] == 0xf0; }
+    bool isSystemMessage() { return m_data[m_offset] >= 0xf0; }
+    bool isEndOfSysex() { return m_data[m_offset] == 0xf7; }
+    bool isRealTimeMessage() { return m_data[m_offset] >= 0xf8; }
+    bool isStatusByte() { return m_data[m_offset] & 0x80; }
+    bool isReservedStatusByte() { return m_data[m_offset] == 0xf4 || m_data[m_offset] == 0xf5 || m_data[m_offset] == 0xf9 || m_data[m_offset] == 0xfd; }
+
+    bool acceptRealTimeMessages()
+    {
+        for (; !isEndOfData(); m_offset++) {
+            if (isRealTimeMessage() && !isReservedStatusByte())
+                continue;
+            return true;
+        }
+        return false;
+    }
+
+    bool acceptCurrentSysex()
+    {
+        ASSERT(isSysex());
+        for (m_offset++; !isEndOfData(); m_offset++) {
+            if (isReservedStatusByte())
+                return false;
+            if (isRealTimeMessage())
+                continue;
+            if (isEndOfSysex()) {
+                m_offset++;
+                return true;
+            }
+            if (isStatusByte())
+                return false;
+        }
+        return false;
+    }
+
+    bool acceptCurrentMessage()
+    {
+        ASSERT(isStatusByte());
+        ASSERT(!isSysex());
+        ASSERT(!isReservedStatusByte());
+        ASSERT(!isRealTimeMessage());
+        static const int channelMessageLength[7] = { 3, 3, 3, 3, 2, 2, 3 }; // for 0x8*, 0x9*, ..., 0xe*
+        static const int systemMessageLength[7] = { 2, 3, 2, 0, 0, 1, 0 }; // for 0xf1, 0xf2, ..., 0xf7
+        size_t length = isSystemMessage() ? systemMessageLength[m_data[m_offset] - 0xf1] : channelMessageLength[(m_data[m_offset] >> 4) - 8];
+        size_t count = 1;
+        for (m_offset++; !isEndOfData(); m_offset++) {
+            if (isReservedStatusByte())
+                return false;
+            if (isRealTimeMessage())
+                continue;
+            if (isStatusByte())
+                return false;
+            if (++count == length) {
+                m_offset++;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    String getPositionString() { return "at index " + String::number(m_offset) + " (" + String::number(m_data[m_offset]) + ")."; }
+
+    const unsigned char* m_data;
+    const size_t m_length;
+    size_t m_offset;
+};
+
+} // namespace
+
+PassRefPtrWillBeRawPtr<MIDIOutput> MIDIOutput::create(MIDIAccess* access, unsigned portIndex, const String& id, const String& manufacturer, const String& name, const String& version)
 {
     ASSERT(access);
-    RefPtr<MIDIOutput> output = adoptRef(new MIDIOutput(access, portIndex, context, id, manufacturer, name, version));
-    output->suspendIfNeeded();
-    return output.release();
+    return adoptRefWillBeRefCountedGarbageCollected(new MIDIOutput(access, portIndex, id, manufacturer, name, version));
 }
 
-MIDIOutput::MIDIOutput(MIDIAccess* access, unsigned portIndex, ExecutionContext* context, const String& id, const String& manufacturer, const String& name, const String& version)
-    : MIDIPort(context, id, manufacturer, name, MIDIPortTypeOutput, version)
-    , m_access(access)
+MIDIOutput::MIDIOutput(MIDIAccess* access, unsigned portIndex, const String& id, const String& manufacturer, const String& name, const String& version)
+    : MIDIPort(access, id, manufacturer, name, MIDIPortTypeOutput, version)
     , m_portIndex(portIndex)
 {
     ScriptWrappable::init(this);
@@ -59,29 +192,26 @@ MIDIOutput::~MIDIOutput()
 
 void MIDIOutput::send(Uint8Array* array, double timestamp, ExceptionState& exceptionState)
 {
-    if (!array)
-        return;
+    if (timestamp == 0.0)
+        timestamp = now(executionContext());
 
-    const unsigned char* data = array->data();
-    size_t length = array->length();
-
-    // Filter out System Exclusive messages if we're not allowed.
-    // FIXME: implement more extensive filtering.
-    if (length > 0 && data[0] >= 0xf0 && !m_access->sysExEnabled()) {
-        exceptionState.throwSecurityError("permission to send system exclusive messages is denied.");
+    if (!array)
         return;
-    }
 
-    m_access->sendMIDIData(m_portIndex, data, length, timestamp);
+    if (MessageValidator::validate(array, exceptionState, midiAccess()->sysexEnabled()))
+        midiAccess()->sendMIDIData(m_portIndex, array->data(), array->length(), timestamp);
 }
 
 void MIDIOutput::send(Vector<unsigned> unsignedData, double timestamp, ExceptionState& exceptionState)
 {
+    if (timestamp == 0.0)
+        timestamp = now(executionContext());
+
     RefPtr<Uint8Array> array = Uint8Array::create(unsignedData.size());
 
     for (size_t i = 0; i < unsignedData.size(); ++i) {
         if (unsignedData[i] > 0xff) {
-            exceptionState.throwUninformativeAndGenericDOMException(InvalidStateError);
+            exceptionState.throwTypeError("The value at index " + String::number(i) + " (" + String::number(unsignedData[i]) + ") is greater than 0xFF.");
             return;
         }
         unsigned char value = unsignedData[i] & 0xff;
@@ -93,12 +223,17 @@ void MIDIOutput::send(Vector<unsigned> unsignedData, double timestamp, Exception
 
 void MIDIOutput::send(Uint8Array* data, ExceptionState& exceptionState)
 {
-    send(data, 0, exceptionState);
+    send(data, 0.0, exceptionState);
 }
 
 void MIDIOutput::send(Vector<unsigned> unsignedData, ExceptionState& exceptionState)
 {
-    send(unsignedData, 0, exceptionState);
+    send(unsignedData, 0.0, exceptionState);
+}
+
+void MIDIOutput::trace(Visitor* visitor)
+{
+    MIDIPort::trace(visitor);
 }
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.h
index 9f23c88adfb..4d1d996613f 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.h
@@ -39,11 +39,10 @@ namespace WebCore {
 
 class ExceptionState;
 class MIDIAccess;
-class ExecutionContext;
 
-class MIDIOutput : public MIDIPort {
+class MIDIOutput FINAL : public MIDIPort {
 public:
-    static PassRefPtr<MIDIOutput> create(MIDIAccess*, unsigned portIndex, ExecutionContext*, const String& id, const String& manufacturer, const String& name, const String& version);
+    static PassRefPtrWillBeRawPtr<MIDIOutput> create(MIDIAccess*, unsigned portIndex, const String& id, const String& manufacturer, const String& name, const String& version);
     virtual ~MIDIOutput();
 
     void send(Uint8Array*, double timestamp, ExceptionState&);
@@ -53,16 +52,15 @@ public:
     void send(Uint8Array*, ExceptionState&);
     void send(Vector<unsigned>, ExceptionState&);
 
-    MIDIAccess* midiAccess() const { return m_access; }
+    virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    MIDIOutput(MIDIAccess*, unsigned portIndex, ExecutionContext*, const String& id, const String& manufacturer, const String& name, const String& version);
+    MIDIOutput(MIDIAccess*, unsigned portIndex, const String& id, const String& manufacturer, const String& name, const String& version);
 
-    MIDIAccess* m_access;
     unsigned m_portIndex;
 };
 
-typedef Vector<RefPtr<MIDIOutput> > MIDIOutputVector;
+typedef WillBeHeapVector<RefPtrWillBeMember<MIDIOutput> > MIDIOutputVector;
 
 } // namespace WebCore
 
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.idl b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.idl
index 726ed6465da..a41bcfb390c 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.idl
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIOutput.idl
@@ -28,10 +28,12 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+// http://www.w3.org/TR/webmidi/#idl-def-MIDIOutput
+// http://cwilso.github.io/web-midi-api/#idl-def-MIDIOutput
+
 [
-    ActiveDOMObject,
-    Custom=Wrap,
     NoInterfaceObject,
+    SetWrapperReferenceTo(MIDIAccess midiAccess),
 ] interface MIDIOutput : MIDIPort {
     [RaisesException] void send(Uint8Array data, optional double timestamp);
     [RaisesException] void send(sequence<unsigned long> data, optional double timestamp);
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.cpp
index 0e550401672..9525d24e839 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.cpp
@@ -31,25 +31,23 @@
 #include "config.h"
 #include "modules/webmidi/MIDIPort.h"
 
+#include "modules/webmidi/MIDIAccess.h"
+
 namespace WebCore {
 
-MIDIPort::MIDIPort(ExecutionContext* context, const String& id, const String& manufacturer, const String& name, MIDIPortTypeCode type, const String& version)
-    : ActiveDOMObject(context)
-    , m_id(id)
+MIDIPort::MIDIPort(MIDIAccess* access, const String& id, const String& manufacturer, const String& name, MIDIPortTypeCode type, const String& version)
+    : m_id(id)
     , m_manufacturer(manufacturer)
     , m_name(name)
     , m_type(type)
     , m_version(version)
+    , m_access(access)
 {
+    ASSERT(access);
     ASSERT(type == MIDIPortTypeInput || type == MIDIPortTypeOutput);
     ScriptWrappable::init(this);
 }
 
-MIDIPort::~MIDIPort()
-{
-    stop();
-}
-
 String MIDIPort::type() const
 {
     switch (m_type) {
@@ -63,4 +61,15 @@ String MIDIPort::type() const
     return emptyString();
 }
 
+ExecutionContext* MIDIPort::executionContext() const
+{
+    return m_access->executionContext();
+}
+
+void MIDIPort::trace(Visitor* visitor)
+{
+    visitor->trace(m_access);
+    EventTargetWithInlineData::trace(visitor);
+}
+
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.h b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.h
index e5f83abaf69..96d3085e5ec 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.h
@@ -32,23 +32,26 @@
 #define MIDIPort_h
 
 #include "bindings/v8/ScriptWrappable.h"
-#include "core/dom/ActiveDOMObject.h"
-#include "core/events/EventTarget.h"
+#include "modules/EventTargetModules.h"
+#include "platform/heap/Handle.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
-class MIDIPort : public RefCounted<MIDIPort>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData {
+class MIDIAccess;
+
+class MIDIPort : public RefCountedWillBeRefCountedGarbageCollected<MIDIPort>, public ScriptWrappable, public EventTargetWithInlineData {
     REFCOUNTED_EVENT_TARGET(MIDIPort);
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(MIDIPort);
 public:
     enum MIDIPortTypeCode {
         MIDIPortTypeInput,
         MIDIPortTypeOutput
     };
 
-    virtual ~MIDIPort();
+    virtual ~MIDIPort() { }
 
     String id() const { return m_id; }
     String manufacturer() const { return m_manufacturer; }
@@ -56,14 +59,18 @@ public:
     String type() const;
     String version() const { return m_version; }
 
+    MIDIAccess* midiAccess() const { return m_access; }
+
+    virtual void trace(Visitor*) OVERRIDE;
+
     DEFINE_ATTRIBUTE_EVENT_LISTENER(disconnect);
 
     // EventTarget
     virtual const AtomicString& interfaceName() const OVERRIDE { return EventTargetNames::MIDIPort; }
-    virtual ExecutionContext* executionContext() const OVERRIDE { return ActiveDOMObject::executionContext(); }
+    virtual ExecutionContext* executionContext() const OVERRIDE FINAL;
 
 protected:
-    MIDIPort(ExecutionContext*, const String& id, const String& manufacturer, const String& name, MIDIPortTypeCode, const String& version);
+    MIDIPort(MIDIAccess*, const String& id, const String& manufacturer, const String& name, MIDIPortTypeCode, const String& version);
 
 private:
     String m_id;
@@ -71,10 +78,9 @@ private:
     String m_name;
     MIDIPortTypeCode m_type;
     String m_version;
+    RawPtrWillBeMember<MIDIAccess> m_access;
 };
 
-typedef Vector<RefPtr<MIDIPort> > MIDIPortVector;
-
 } // namespace WebCore
 
 #endif // MIDIPort_h
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.idl b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.idl
index 944cacb6834..3ca858a76e0 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.idl
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/MIDIPort.idl
@@ -35,7 +35,6 @@ enum MIDIPortType {
 
 [
     NoInterfaceObject,
-    ActiveDOMObject
 ] interface MIDIPort : EventTarget {
     readonly attribute DOMString id;
     readonly attribute DOMString manufacturer;
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.cpp b/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.cpp
index 87f7b25d31e..b668dcc6d45 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.cpp
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.cpp
@@ -31,15 +31,18 @@
 #include "config.h"
 #include "modules/webmidi/NavigatorWebMIDI.h"
 
+#include "bindings/v8/ScriptPromise.h"
+#include "bindings/v8/ScriptPromiseResolver.h"
+#include "core/dom/DOMError.h"
 #include "core/dom/Document.h"
-#include "core/dom/ExecutionContext.h"
-#include "core/frame/Frame.h"
+#include "core/frame/LocalFrame.h"
 #include "core/frame/Navigator.h"
-#include "modules/webmidi/MIDIAccessPromise.h"
+#include "modules/webmidi/MIDIAccessInitializer.h"
+#include "modules/webmidi/MIDIOptions.h"
 
 namespace WebCore {
 
-NavigatorWebMIDI::NavigatorWebMIDI(Frame* frame)
+NavigatorWebMIDI::NavigatorWebMIDI(LocalFrame* frame)
     : DOMWindowProperty(frame)
 {
 }
@@ -53,30 +56,32 @@ const char* NavigatorWebMIDI::supplementName()
     return "NavigatorWebMIDI";
 }
 
-NavigatorWebMIDI* NavigatorWebMIDI::from(Navigator* navigator)
+NavigatorWebMIDI& NavigatorWebMIDI::from(Navigator& navigator)
 {
-    NavigatorWebMIDI* supplement = static_cast<NavigatorWebMIDI*>(Supplement<Navigator>::from(navigator, supplementName()));
+    NavigatorWebMIDI* supplement = static_cast<NavigatorWebMIDI*>(WillBeHeapSupplement<Navigator>::from(navigator, supplementName()));
     if (!supplement) {
-        supplement = new NavigatorWebMIDI(navigator->frame());
-        provideTo(navigator, supplementName(), adoptPtr(supplement));
+        supplement = new NavigatorWebMIDI(navigator.frame());
+        provideTo(navigator, supplementName(), adoptPtrWillBeNoop(supplement));
     }
-    return supplement;
+    return *supplement;
 }
 
-PassRefPtr<MIDIAccessPromise> NavigatorWebMIDI::requestMIDIAccess(Navigator* navigator, const Dictionary& options)
+ScriptPromise NavigatorWebMIDI::requestMIDIAccess(ScriptState* scriptState, Navigator& navigator, const Dictionary& options)
 {
-    return NavigatorWebMIDI::from(navigator)->requestMIDIAccess(options);
+    return NavigatorWebMIDI::from(navigator).requestMIDIAccess(scriptState, options);
 }
 
-PassRefPtr<MIDIAccessPromise> NavigatorWebMIDI::requestMIDIAccess(const Dictionary& options)
+ScriptPromise NavigatorWebMIDI::requestMIDIAccess(ScriptState* scriptState, const Dictionary& options)
 {
-    if (!frame())
-        return 0;
-
-    ExecutionContext* context = frame()->document();
-    ASSERT(context);
+    if (!frame() || frame()->document()->activeDOMObjectsAreStopped()) {
+        RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+        ScriptPromise promise = resolver->promise();
+        // FIXME: Currently this rejection does not work because the context is stopped.
+        resolver->reject(DOMError::create("AbortError"));
+        return promise;
+    }
 
-    return MIDIAccessPromise::create(context, options);
+    return MIDIAccessInitializer::start(scriptState, MIDIOptions(options));
 }
 
 } // namespace WebCore
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.h b/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.h
index 1b6e73bc191..4e21441851a 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.h
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.h
@@ -31,25 +31,29 @@
 #ifndef NavigatorWebMIDI_h
 #define NavigatorWebMIDI_h
 
+#include "bindings/v8/ScriptPromise.h"
 #include "core/frame/DOMWindowProperty.h"
 #include "modules/webmidi/MIDIOptions.h"
 #include "platform/Supplementable.h"
+#include "platform/heap/Handle.h"
 
 namespace WebCore {
 
-class MIDIAccessPromise;
 class Navigator;
 
-class NavigatorWebMIDI : public Supplement<Navigator>, public DOMWindowProperty {
+class NavigatorWebMIDI FINAL : public NoBaseWillBeGarbageCollectedFinalized<NavigatorWebMIDI>, public WillBeHeapSupplement<Navigator>, public DOMWindowProperty {
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(NavigatorWebMIDI);
 public:
     virtual ~NavigatorWebMIDI();
-    static NavigatorWebMIDI* from(Navigator*);
+    static NavigatorWebMIDI& from(Navigator&);
 
-    static PassRefPtr<MIDIAccessPromise> requestMIDIAccess(Navigator*, const Dictionary&);
-    PassRefPtr<MIDIAccessPromise> requestMIDIAccess(const Dictionary&);
+    static ScriptPromise requestMIDIAccess(ScriptState*, Navigator&, const Dictionary&);
+    ScriptPromise requestMIDIAccess(ScriptState*, const Dictionary&);
+
+    virtual void trace(Visitor* visitor) OVERRIDE { WillBeHeapSupplement<Navigator>::trace(visitor); }
 
 private:
-    NavigatorWebMIDI(Frame*);
+    NavigatorWebMIDI(LocalFrame*);
     static const char* supplementName();
 };
 
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.idl b/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.idl
index e8ad27d70b0..6a275d5b26f 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.idl
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/NavigatorWebMIDI.idl
@@ -28,6 +28,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-partial interface Navigator {
-    [RuntimeEnabled=WebMIDI] MIDIAccessPromise requestMIDIAccess(optional Dictionary options);
+[
+    RuntimeEnabled=WebMIDI,
+] partial interface Navigator {
+    [CallWith=ScriptState] Promise requestMIDIAccess(optional Dictionary options);
 };
diff --git a/chromium/third_party/WebKit/Source/modules/webmidi/OWNERS b/chromium/third_party/WebKit/Source/modules/webmidi/OWNERS
index 88c0a7fa556..eed18af1fc9 100644
--- a/chromium/third_party/WebKit/Source/modules/webmidi/OWNERS
+++ b/chromium/third_party/WebKit/Source/modules/webmidi/OWNERS
@@ -1,2 +1,3 @@
 kouhei@chromium.org
 toyoshim@chromium.org
+yhirano@chromium.org