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(
+    const String& name,
+    const ScriptValue& ctor,
+    ExceptionState& exceptionState) {

[nhiroki, 2017/03/06 10:08:44]

I'd recommend that threaded objects have thread checks (e.g.,
DCHECK(isContextThread()) as much as possible because sometimes sourcecode
readers (including authors) lose the thread they're on.

[hongchan, 2017/03/06 20:06:11]

Good point. I do not have the thread for this code yet, but it would be
AudioWorkletThread. Is DCHECK(isContextThread()) the right way to check it?

+  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 = scriptController()->getScriptState()->isolate();
+  v8::Local<v8::Context> context = scriptController()->context();

[haraken, 2017/03/06 11:51:11]

If you pass in [ScriptState] to registerProcessor from the idl, you can just use
it in this method.

[hongchan, 2017/03/06 20:06:11]

Done.

+
+  DCHECK(ctor.v8Value()->IsFunction());
+
+  v8::Local<v8::Function> constructor =
+      v8::Local<v8::Function>::Cast(ctor.v8Value());
+
+  v8::Local<v8::Value> prototypeValue;
+  if (!v8Call(constructor->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")),
+              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> process = v8::Local<v8::Function>::Cast(processValue);
+
+  AudioWorkletProcessorDefinition* definition =
+      AudioWorkletProcessorDefinition::create(
+          scriptController()->getScriptState(), constructor, process);
+
+  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