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/Dictionary.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/WorkerOrWorkletScriptController.h"
+#include "bindings/modules/v8/V8AudioParamDescriptor.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/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 29 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()->GetScriptState()->GetContext();
+  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 =
-      class_definition.V8Value().As<v8::Function>();
+      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 =
       prototype_value_local.As<v8::Object>();
 
+  // 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 23 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(processor);
 
   return processor;
 }
 
 bool AudioWorkletGlobalScope::Process(AudioWorkletProcessor* processor,
                                       AudioBuffer* input_buffer,
                                       AudioBuffer* output_buffer) {
   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);
 
   v8::Local<v8::Value> argv[] = {
       ToV8(input_buffer, script_state->GetContext()->Global(), isolate),
       ToV8(output_buffer, script_state->GetContext()->Global(), isolate)};
 
   // TODO(hongchan): Catch exceptions thrown in the process method. The verbose
   // options forces the TryCatch object to save the exception location. The
@@ skipping 16 matching lines @@
   return processor_definition_map_.at(name);
 }
 
 DEFINE_TRACE(AudioWorkletGlobalScope) {
   visitor->Trace(processor_definition_map_);
   visitor->Trace(processor_instances_);
   ThreadedWorkletGlobalScope::Trace(visitor);
 }
 
 }  // namespace blink