AudioWorklet prototype

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/IDLTypes.h"
 #include "bindings/core/v8/NativeValueTraitsImpl.h"
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8BindingForCore.h"
+#include "bindings/core/v8/V8ObjectBuilder.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "bindings/modules/v8/V8AudioParamDescriptor.h"
+#include "core/dom/DOMTypedArray.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/webaudio/AudioBuffer.h"
 #include "modules/webaudio/AudioParamDescriptor.h"
 #include "modules/webaudio/AudioWorkletProcessor.h"
 #include "modules/webaudio/AudioWorkletProcessorDefinition.h"
+#include "platform/audio/AudioUtilities.h"
 #include "platform/bindings/V8BindingMacros.h"
 #include "platform/bindings/V8ObjectConstructor.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
 AudioWorkletGlobalScope* AudioWorkletGlobalScope::Create(
     const KURL& url,
     const String& user_agent,
     PassRefPtr<SecurityOrigin> security_origin,
     v8::Isolate* isolate,
     WorkerThread* thread,
     WorkerClients* worker_clients) {
+  LOG(INFO) << "AudioWorkletGlobalScope::RegisterProcessor thread = "
+            << thread;
   return new AudioWorkletGlobalScope(url, user_agent,
                                      std::move(security_origin), isolate,
                                      thread, worker_clients);
 }
 
 AudioWorkletGlobalScope::AudioWorkletGlobalScope(
     const KURL& url,
     const String& user_agent,
     PassRefPtr<SecurityOrigin> security_origin,
     v8::Isolate* isolate,
@@ skipping 24 matching lines @@
   // TODO(hongchan): this is not stated in the spec, but seems necessary.
   // https://github.com/WebAudio/web-audio-api/issues/1172
   if (name.IsEmpty()) {
     exception_state.ThrowTypeError("The empty string is not a valid name.");
     return;
   }
 
   v8::Isolate* isolate = ScriptController()->GetScriptState()->GetIsolate();
   v8::Local<v8::Context> context = ScriptController()->GetContext();
 
+  // Get a handle for the class definition (i.e. constructor)
   if (!class_definition.V8Value()->IsFunction()) {
     exception_state.ThrowTypeError(
         "The processor definition is neither 'class' nor 'function'.");
     return;
   }
 
   v8::Local<v8::Function> class_definition_local =
       v8::Local<v8::Function>::Cast(class_definition.V8Value());
 
+  // Get a handle for |prototype| object out of class definition.
   v8::Local<v8::Value> prototype_value_local;
   bool prototype_extracted =
       class_definition_local->Get(context, V8String(isolate, "prototype"))
           .ToLocal(&prototype_value_local);
   DCHECK(prototype_extracted);
 
   v8::Local<v8::Object> prototype_object_local =
       v8::Local<v8::Object>::Cast(prototype_value_local);
 
+  // Extract |process| function.
   v8::Local<v8::Value> process_value_local;
   bool process_extracted =
       prototype_object_local->Get(context, V8String(isolate, "process"))
           .ToLocal(&process_value_local);
   DCHECK(process_extracted);
 
   if (process_value_local->IsNullOrUndefined()) {
     exception_state.ThrowTypeError(
         "The 'process' function does not exist in the prototype.");
     return;
@@ skipping 48 matching lines @@
   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()->GetIsolate();
   v8::Local<v8::Object> instance_local;
   if (!V8ObjectConstructor::NewInstance(isolate,
                                         definition->ConstructorLocal(isolate))
-           .ToLocal(&instance_local)) {
+          .ToLocal(&instance_local)) {
     return nullptr;
   }
 
-  AudioWorkletProcessor* processor = AudioWorkletProcessor::Create(this, name);
+  AudioWorkletProcessor* processor =
+      AudioWorkletProcessor::Create(this, definition);
   DCHECK(processor);
 
   processor->SetInstance(isolate, instance_local);
   processor_instances_.push_back(
       TraceWrapperMember<AudioWorkletProcessor>(this, processor));
 
   return processor;
 }
 
-bool AudioWorkletGlobalScope::Process(AudioWorkletProcessor* processor,
-                                      AudioBuffer* input_buffer,
-                                      AudioBuffer* output_buffer) {
+bool AudioWorkletGlobalScope::Process(
+    AudioWorkletProcessor* processor,
+    AudioBuffer* input_buffer,
+    AudioBuffer* output_buffer,
+    HashMap<String, AudioFloatArray*> audio_param_data_map) {
   CHECK(input_buffer);
   CHECK(output_buffer);
 
   ScriptState* script_state = ScriptController()->GetScriptState();
+  v8::Isolate* isolate = script_state->GetIsolate();
+
   ScriptState::Scope scope(script_state);
 
-  v8::Isolate* isolate = script_state->GetIsolate();
   AudioWorkletProcessorDefinition* definition =
       FindDefinition(processor->GetName());
   DCHECK(definition);
 
+  V8ObjectBuilder parameters_object(script_state);
+
+  for (const auto& param_name : audio_param_data_map.Keys()) {
+    DOMFloat32Array* param_data_array =
+        DOMFloat32Array::CreateOrNull(AudioUtilities::kRenderQuantumFrames);
+    const float* source = audio_param_data_map.at(param_name)->Data();
+    float* destination = param_data_array->Data();
+    
+    memcpy(destination, source,
+           AudioUtilities::kRenderQuantumFrames * sizeof(float));
+    
+    parameters_object.Add(
+        StringView(param_name),
+        ToV8(param_data_array, script_state->GetContext()->Global(), isolate));
+  }
+
   v8::Local<v8::Value> argv[] = {
       ToV8(input_buffer, script_state->GetContext()->Global(), isolate),
-      ToV8(output_buffer, script_state->GetContext()->Global(), isolate)};
+      ToV8(output_buffer, script_state->GetContext()->Global(), isolate),
+      parameters_object.V8Value()};
 
   // TODO(hongchan): Catch exceptions thrown in the process method. The verbose
   // options forces the TryCatch object to save the exception location. The
   // pending exception should be handled later.
   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.
@@ skipping 19 matching lines @@
   for (auto definition : processor_definition_map_)
     visitor->TraceWrappers(definition.value);
 
   for (auto processor : processor_instances_)
     visitor->TraceWrappers(processor);
 
   ThreadedWorkletGlobalScope::TraceWrappers(visitor);
 }
 
 }  // namespace blink