Implement AudioWorkletProcessor interface

third_party/WebKit/Source/modules/webaudio/AudioWorkletGlobalScope.cpp

 // Copyright 2016 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/webaudio/AudioWorkletGlobalScope.h"
 
+#include "bindings/core/v8/ToV8.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/V8BindingMacros.h"
+#include "bindings/core/v8/V8ObjectConstructor.h"
+#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
+#include "core/dom/ExceptionCode.h"
+#include "modules/webaudio/AudioBuffer.h"
+#include "modules/webaudio/AudioWorkletProcessor.h"
+#include "modules/webaudio/AudioWorkletProcessorDefinition.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
 AudioWorkletGlobalScope* AudioWorkletGlobalScope::create(
     const KURL& url,
     const String& userAgent,
     PassRefPtr<SecurityOrigin> securityOrigin,
     v8::Isolate* isolate,
     WorkerThread* thread) {
   return new AudioWorkletGlobalScope(url, userAgent, std::move(securityOrigin),
                                      isolate, thread);
 }
 
 AudioWorkletGlobalScope::AudioWorkletGlobalScope(
     const KURL& url,
     const String& userAgent,
     PassRefPtr<SecurityOrigin> securityOrigin,
     v8::Isolate* isolate,
     WorkerThread* thread)
     : ThreadedWorkletGlobalScope(url,
                                  userAgent,
                                  std::move(securityOrigin),
                                  isolate,
                                  thread) {}
 
 AudioWorkletGlobalScope::~AudioWorkletGlobalScope() {}
 
+void AudioWorkletGlobalScope::dispose() {
+  DCHECK(isContextThread());
+  m_processorDefinitionMap.clear();
+  m_processorInstances.clear();
+  ThreadedWorkletGlobalScope::dispose();
+}
+
+void AudioWorkletGlobalScope::registerProcessor(
+    const String& name,
+    const ScriptValue& classDefinition,
+    ExceptionState& exceptionState) {
+  DCHECK(isContextThread());
+
+  if (m_processorDefinitionMap.contains(name)) {
+    exceptionState.throwDOMException(
+        NotSupportedError,
+        "A class with name:'" + name + "' is already registered.");
+    return;
+  }
+
+  if (name.isEmpty()) {
+    exceptionState.throwTypeError("The empty string is not a valid name.");

[nhiroki, 2017/03/16 00:21:35]

This rejects not only a null 'name' but also an empty 'name'. Is this spec'ed?

(I'm now looking at "registerProcessor" algorithm:
https://webaudio.github.io/web-audio-api/#methods-8)

[hongchan, 2017/03/16 22:11:28]

Do you mean an empty string like ''?

JS object supports an empty string being a valid key, but I don't think we
should allow that. I will hold this change here, but will consult WG for
confirmation.

+    return;
+  }
+
+  v8::Isolate* isolate = scriptController()->getScriptState()->isolate();
+  v8::Local<v8::Context> context =
+      scriptController()->getScriptState()->context();
+
+  DCHECK(classDefinition.v8Value()->IsFunction());
+
+  v8::Local<v8::Function> constructorLocal =
+      v8::Local<v8::Function>::Cast(classDefinition.v8Value());
+
+  v8::Local<v8::Value> prototypeValue;
+  if (!v8Call(constructorLocal->Get(context, v8String(isolate, "prototype")),
+              prototypeValue))

[nhiroki, 2017/03/16 00:21:35]

Just curious: Why don't we throw an exception in this case? Is this common
pattern?

According to comments in V8BindingMacros.h, v8Call() is deprecated. Can we use
the alternatives? (please ignore this comment if this will be replaced with
GetPrototype() haraken@ suggested).
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/bindings/core/...

[haraken, 2017/03/16 12:07:15]

Yeah, we need to throw some exception when Get fails.

Also use Get().ToLocal() instead of v8Call.

[hongchan, 2017/03/16 22:11:28]

This parsing pattern is largely based on what PaintWorkletGlobalScope does. I
will revise them as you all suggested.

The exception is happening at l.83.

+    return;
+
+  if (isUndefinedOrNull(prototypeValue)) {
+    exceptionState.throwTypeError(
+        "The 'prototype' object on the class does not exist.");
+    return;
+  }
+
+  if (!prototypeValue->IsObject()) {
+    exceptionState.throwTypeError(
+        "The 'prototype' property on the class is not an object.");
+    return;
+  }
+
+  v8::Local<v8::Object> prototype = v8::Local<v8::Object>::Cast(prototypeValue);
+
+  v8::Local<v8::Value> processValue;
+  if (!v8Call(prototype->Get(context, v8String(isolate, "process")),
+              processValue))

[nhiroki, 2017/03/16 00:21:35]

ditto.

+    return;
+
+  if (isUndefinedOrNull(processValue)) {
+    exceptionState.throwTypeError(
+        "The 'process' function on the prototype does not exist.");
+    return;
+  }
+
+  if (!processValue->IsFunction()) {
+    exceptionState.throwTypeError(
+        "The 'process' property on the prototype is not a function.");
+    return;
+  }
+
+  v8::Local<v8::Function> processLocal =
+      v8::Local<v8::Function>::Cast(processValue);
+
+  AudioWorkletProcessorDefinition* definition =
+      AudioWorkletProcessorDefinition::create(isolate, name, constructorLocal,
+                                              processLocal);
+
+  m_processorDefinitionMap.set(name, definition);

[haraken, 2017/03/16 12:07:15]

Nit: This will be an extremely corner case but you'll need to check
if(m_processorDefinitionMap.contains(name)) again here, because the above Get()
etc can invoke any arbitrary JavaScript, which may re-enter registerProcessor(),
which may set a new definition on m_processorDefinitionMap.

+}
+
+AudioWorkletProcessor* AudioWorkletGlobalScope::createInstance(
+    const String& name) {
+  DCHECK(isContextThread());
+
+  AudioWorkletProcessorDefinition* definition = findDefinition(name);
+  if (!definition)
+    return nullptr;
+
+  // V8 object instance construction: this construction process is here to make
+  // the AudioWorkletProcessor class a thin wrapper of V8::Object instance.
+  v8::Isolate* isolate = scriptController()->getScriptState()->isolate();
+  v8::Local<v8::Object> instanceLocal;
+  if (!V8ObjectConstructor::newInstance(isolate,
+                                        definition->constructorLocal(isolate))
+           .ToLocal(&instanceLocal)) {
+    return nullptr;
+  }
+
+  AudioWorkletProcessor* processor = AudioWorkletProcessor::create(this, name);
+  processor->setInstance(isolate, instanceLocal);
+  m_processorInstances.push_back(processor);
+
+  return processor;
+}
+
+bool AudioWorkletGlobalScope::process(AudioWorkletProcessor* processor,
+                                      AudioBuffer* inputBuffer,
+                                      AudioBuffer* outputBuffer) {
+  ScriptState* scriptState = scriptController()->getScriptState();
+  ScriptState::Scope scope(scriptState);
+
+  v8::Isolate* isolate = scriptState->isolate();
+  AudioWorkletProcessorDefinition* definition =
+      findDefinition(processor->name());
+  DCHECK(definition);
+
+  v8::Local<v8::Value> argv[] = {
+      ToV8(inputBuffer, scriptState->context()->Global(), isolate),
+      ToV8(outputBuffer, scriptState->context()->Global(), isolate)};
+
+  v8::TryCatch block(isolate);
+  block.SetVerbose(true);
+
+  // Perform JS function process() in AudioWorkletProcessor instance. The actual
+  // V8 operation happens here to make the AudioWorkletProcessor class a thin
+  // wrapper of v8::Object instance.
+  V8ScriptRunner::callFunction(
+      definition->processLocal(isolate), scriptState->getExecutionContext(),
+      processor->instanceLocal(isolate), WTF_ARRAY_LENGTH(argv), argv, isolate);
+
+  if (block.HasCaught()) {
+    return false;

[haraken, 2017/03/16 12:07:15]

It's okay to ignore the exception, right?

+  }
+
+  return true;
+}
+
+AudioWorkletProcessorDefinition* AudioWorkletGlobalScope::findDefinition(
+    const String& name) {
+  return m_processorDefinitionMap.at(name);
+}
+
+DEFINE_TRACE(AudioWorkletGlobalScope) {
+  visitor->trace(m_processorDefinitionMap);
+  visitor->trace(m_processorInstances);
+  ThreadedWorkletGlobalScope::trace(visitor);
+}
+
 }  // namespace blink