WebMIDI: Add MIDIOptions dictionary

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 "config.h"
 #include "modules/webmidi/MIDIAccessInitializer.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.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 blink {
 
-MIDIAccessInitializer::MIDIAccessInitializer(ScriptState* scriptState, const MIDIOptions& options)
+MIDIAccessInitializer::MIDIAccessInitializer(ScriptState* scriptState, const MIDIOptions* options)

[tkent, 2014/09/10 23:44:05]

It seems we still assume |options| is non-null.  Can we avoid to change |const
MIDIOptions&| to |const MIDIOptions*|?

[bashi, 2014/09/12 00:19:13]

IDL dictionaries are garbage collected. We need to change IDL compiler if we
want to change |const MIDIOptions*| to |const MIDIOptions&|, which also changes
all signatures of other constructors and method which use IDL dictionaries.
Other customers may want to hold an IDL dictionary instance in its class. Is it
safe to hold a reference of a GarbageCollected instance?

I'm willing to change the argument type from pointers to references if it's
fine, but I'd like to do it in a follow-up CL because it will make this CL
contain two logically independent changes.

[tkent, 2014/09/12 00:20:53]

It should be safe.
It's reasonable.  lgtm.

     : ScriptPromiseResolver(scriptState)
-    , m_options(options)
-    , m_sysexEnabled(false)
+    , m_requestSysex(false)
 {
+    if (options->hasSysex())
+        m_requestSysex = options->sysex();
 }
 
 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) {
+    if (!m_requestSysex) {
         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"));
@@ skipping 10 matching lines @@
 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()));
+        resolve(MIDIAccess::create(m_accessor.release(), m_requestSysex, m_portDescriptors, executionContext()));
     } else {
         reject(DOMError::create(error, message));
     }
 }
 
-void MIDIAccessInitializer::setSysexEnabled(bool enable)
+void MIDIAccessInitializer::resolveSysexPermission(bool allowed)
 {
-    m_sysexEnabled = enable;
-    if (enable)
+    if (allowed)
         m_accessor->startSession();
     else
         reject(DOMError::create("SecurityError"));
 }
 
 SecurityOrigin* MIDIAccessInitializer::securityOrigin() const
 {
     return executionContext()->securityOrigin();
 }
 
 ExecutionContext* MIDIAccessInitializer::executionContext() const
 {
     return scriptState()->executionContext();
 }
 
 } // namespace blink