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/V8BindingMacros.h"
+#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
+#include "core/dom/ExceptionCode.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() {
+  m_processorDefinitionMap.clear();
+  ThreadedWorkletGlobalScope::dispose();
+}
+
+void AudioWorkletGlobalScope::registerProcessor(
+    ScriptState* scriptState,
+    const String& name,
+    const ScriptValue& constructor,
+    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.");
+    return;
+  }
+
+  v8::Isolate* isolate = scriptState->isolate();
+  v8::Local<v8::Context> context = scriptState->context();
+
+  DCHECK(constructor.v8Value()->IsFunction());
+
+  v8::Local<v8::Function> constructorLocal =
+      v8::Local<v8::Function>::Cast(constructor.v8Value());
+
+  v8::Local<v8::Value> prototypeValue;
+  if (!v8Call(constructorLocal->Get(context, v8String(isolate, "prototype")),
+              prototypeValue))
+    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")),

[haraken, 2017/03/08 09:57:19]

It looks a bit nasty to look up a prototype object, a function with a name
"process" etc, but this is a speced behavior of the audio worklet, right?

[hongchan, 2017/03/08 19:38:46]

Yes, this is how it is specced.

+              processValue))
+    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(scriptState, constructorLocal,
+                                              processLocal);
+
+  m_processorDefinitionMap.set(name, definition);
+}
+
+AudioWorkletProcessorDefinition* AudioWorkletGlobalScope::findDefinition(
+    const String& name) {
+  return m_processorDefinitionMap.at(name);
+}
+
+DEFINE_TRACE(AudioWorkletGlobalScope) {
+  visitor->trace(m_processorDefinitionMap);
+  ThreadedWorkletGlobalScope::trace(visitor);
+}
+
 }  // namespace blink