Make WebMIDI use blink Promise.

Source/modules/webmidi/MIDIAccess.h

 /*
  * 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
@@ skipping 13 matching lines @@
  * 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 MIDIAccess_h
 #define MIDIAccess_h
 
+#include "bindings/v8/MIDIAccessResolver.h"
+#include "bindings/v8/ScriptPromise.h"
 #include "bindings/v8/ScriptWrappable.h"
 #include "core/dom/ActiveDOMObject.h"
 #include "core/events/EventTarget.h"
 #include "heap/Handle.h"
 #include "modules/webmidi/MIDIAccessor.h"
 #include "modules/webmidi/MIDIAccessorClient.h"
 #include "modules/webmidi/MIDIInput.h"
+#include "modules/webmidi/MIDIOptions.h"
 #include "modules/webmidi/MIDIOutput.h"
+#include "platform/Timer.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class ExecutionContext;
-class MIDIAccessPromise;
 
 class MIDIAccess FINAL : public RefCountedWillBeRefCountedGarbageCollected<MIDIAccess>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MIDIAccessorClient {
     DEFINE_EVENT_TARGET_REFCOUNTING(RefCountedWillBeRefCountedGarbageCollected<MIDIAccess>);
 public:
     virtual ~MIDIAccess();
-    static PassRefPtrWillBeRawPtr<MIDIAccess> create(ExecutionContext*, MIDIAccessPromise*);
+    static PassRefPtrWillBeRawPtr<MIDIAccess> create(const MIDIOptions&, ExecutionContext*);
 
     MIDIInputVector inputs() const { return m_inputs; }
     MIDIOutputVector outputs() const { return m_outputs; }
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(connect);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(disconnect);
 
     void setSysExEnabled(bool);
     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 suspend() OVERRIDE;
+    virtual void resume() OVERRIDE;
     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 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);
 
     void trace(Visitor*);
+    ScriptPromise startRequest();
 
 private:
-    MIDIAccess(ExecutionContext*, MIDIAccessPromise*);
+    enum ActiveDOMObjectState {
+        Active,
+        Suspended,
+        Stopped,
+    };
+    enum PromiseState {
+        Pending,
+        Resolving,
+        Rejecting,
+        ResolvedOrRejected,
+    };

[haraken, 2014/02/26 11:30:39]

This kind of state management looks too complicated and fragile.

The fact that you're implementing the state management in MIDIAccess implis that
we have to implement the state management in each feature (e.g., MIDIAccess)
that want to use Promise. This will definitely not scale.

Unfortunately we'll need a fundamental redesign about this CL.

 
-    void startRequest();
+    MIDIAccess(const MIDIOptions&, ExecutionContext*);
+
     void permissionDenied();
 
+    void setRequesting(bool);
+
+    void resolve();
+    void reject(PassRefPtr<DOMError>);
+    void resolveNow();
+    void rejectNow(PassRefPtr<DOMError>);
+
+    void resumeTimerFired(Timer<MIDIAccess>*);
+
+    ActiveDOMObjectState m_activeDOMObjectState;
+    PromiseState m_promiseState;
     MIDIInputVector m_inputs;
     MIDIOutputVector m_outputs;
-    RawPtrWillBeMember<MIDIAccessPromise> m_promise;
 
     OwnPtr<MIDIAccessor> m_accessor;
+    OwnPtr<MIDIAccessResolver> m_resolver;
+    MIDIOptions m_options;
     bool m_hasAccess;
     bool m_sysExEnabled;
     bool m_requesting;
+    Timer<MIDIAccess> m_resumeTimer;
+    RefPtr<DOMError> m_error;
 };
 
 } // namespace WebCore
 
 #endif // MIDIAccess_h