AudioWorklet prototype

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

 // Copyright 2017 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/AudioWorkletProcessor.h"
 
 #include "modules/webaudio/AudioWorkletGlobalScope.h"
+#include "modules/webaudio/AudioWorkletProcessorDefinition.h"
 
 namespace blink {
 
 // This static factory should be called after an instance of |AudioWorkletNode|
 // gets created by user-supplied JS code in the main thread. This factory must
 // not be called by user in |AudioWorkletGlobalScope|.
 AudioWorkletProcessor* AudioWorkletProcessor::Create(
     AudioWorkletGlobalScope* global_scope,
-    const String& name) {
+    AudioWorkletProcessorDefinition* definition) {
   DCHECK(!IsMainThread());
   DCHECK(global_scope);
-  return new AudioWorkletProcessor(global_scope, name);
+  return new AudioWorkletProcessor(global_scope, definition);
 }
 
 AudioWorkletProcessor::AudioWorkletProcessor(
     AudioWorkletGlobalScope* global_scope,
-    const String& name)
-    : global_scope_(global_scope), name_(name), instance_(this) {}
+    AudioWorkletProcessorDefinition* definition)
+    : global_scope_(global_scope), definition_(definition), instance_(this) {}
 
 AudioWorkletProcessor::~AudioWorkletProcessor() {}
 
 void AudioWorkletProcessor::SetInstance(v8::Isolate* isolate,
                                         v8::Local<v8::Object> instance) {
   DCHECK(global_scope_->IsContextThread());
   instance_.Set(isolate, instance);
 }
 
 v8::Local<v8::Object> AudioWorkletProcessor::InstanceLocal(
     v8::Isolate* isolate) {
   DCHECK(global_scope_->IsContextThread());
   return instance_.NewLocal(isolate);
 }
 
-void AudioWorkletProcessor::Process(AudioBuffer* input_buffer,
-                                    AudioBuffer* output_buffer) {
+void AudioWorkletProcessor::Process(
+    AudioBuffer* input_buffer,
+    AudioBuffer* output_buffer,
+    HashMap<String, AudioFloatArray*> audio_param_data_map) {
   DCHECK(global_scope_->IsContextThread());
-  global_scope_->Process(this, input_buffer, output_buffer);
+  if (!input_buffer || !output_buffer)
+    return;
+
+  global_scope_->Process(this,
+                         input_buffer, output_buffer, audio_param_data_map);
+}
+
+const String& AudioWorkletProcessor::GetName() const {
+  return definition_->GetName();
+}
+
+const AudioWorkletProcessorDefinition*
+    AudioWorkletProcessor::GetDefinition() const {
+  return definition_;
+}
+
+void AudioWorkletProcessor::Dispose() {
+  is_disposed_ = true;
 }
 
 DEFINE_TRACE(AudioWorkletProcessor) {
   visitor->Trace(global_scope_);
+  visitor->Trace(definition_);
 }
 
 DEFINE_TRACE_WRAPPERS(AudioWorkletProcessor) {
   visitor->TraceWrappers(instance_.Cast<v8::Value>());
 }
 
 }  // namespace blink