chromium/src/third_party/blink/renderer/modules/webaudio/audio_worklet_processor.cc - manifest_repos/chromium_src - Git at Google

 // 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 "third_party/blink/renderer/modules/webaudio/audio_worklet_processor.h"

 #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_blink_audio_worklet_process_callback.h"
 #include "third_party/blink/renderer/core/messaging/message_port.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_buffer.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_worklet_global_scope.h"
 #include "third_party/blink/renderer/modules/webaudio/audio_worklet_processor_definition.h"
 #include "third_party/blink/renderer/platform/audio/audio_bus.h"
 #include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"

 namespace blink {

 AudioWorkletProcessor* AudioWorkletProcessor::Create(
     ExecutionContext* context) {
   AudioWorkletGlobalScope* global_scope = To<AudioWorkletGlobalScope>(context);
   DCHECK(global_scope);
   DCHECK(global_scope->IsContextThread());

   // Get the stored initialization parameter from the global scope.
   ProcessorCreationParams* params = global_scope->GetProcessorCreationParams();
   DCHECK(params);

   auto* port = MakeGarbageCollected<MessagePort>(*global_scope);
   port->Entangle(std::move(params->PortChannel()));
   return MakeGarbageCollected<AudioWorkletProcessor>(global_scope,
                                                      params->Name(), port);
 }

 AudioWorkletProcessor::AudioWorkletProcessor(
     AudioWorkletGlobalScope* global_scope,
     const String& name,
     MessagePort* port)
     : global_scope_(global_scope), processor_port_(port), name_(name) {}

 bool AudioWorkletProcessor::Process(
     const Vector<scoped_refptr<AudioBus>>& inputs,
     Vector<scoped_refptr<AudioBus>>& outputs,
     const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
                "AudioWorkletProcessor::Process");

   DCHECK(global_scope_->IsContextThread());
   DCHECK(!hasErrorOccurred());

   ScriptState* script_state =
       global_scope_->ScriptController()->GetScriptState();
   ScriptState::Scope scope(script_state);
   v8::Isolate* isolate = script_state->GetIsolate();
   v8::Local<v8::Context> context = script_state->GetContext();
   AudioWorkletProcessorDefinition* definition =
       global_scope_->FindDefinition(Name());

   // 1st JS arg |inputs_|. Compare |inputs| and |inputs_|. Then allocates the
   // data container if necessary.
   if (!PortTopologyMatches(isolate, context, inputs, inputs_)) {
     bool inputs_cloned_successfully =
         ClonePortTopology(isolate, context, inputs, inputs_,
                           input_array_buffers_);
     DCHECK(inputs_cloned_successfully);
     if (!inputs_cloned_successfully)
       return false;
   }
   DCHECK(!inputs_.IsEmpty());
   DCHECK(inputs_.NewLocal(isolate)->IsArray());
   DCHECK_EQ(inputs_.NewLocal(isolate)->Length(), inputs.size());
   DCHECK_EQ(input_array_buffers_.size(), inputs.size());

   // Copies |inputs| to the internal |input_array_buffers|.
   CopyPortToArrayBuffers(isolate, inputs, input_array_buffers_);

   // 2nd JS arg |outputs_|. Compare |outputs| and |outputs_|. Then allocates the
   // data container if necessary.
   if (!PortTopologyMatches(isolate, context, outputs, outputs_)) {
     bool outputs_cloned_successfully =
         ClonePortTopology(isolate, context, outputs, outputs_,
                           output_array_buffers_);
     DCHECK(outputs_cloned_successfully);
     if (!outputs_cloned_successfully)
       return false;
   } else {
     // The reallocation was not needed, so the arrays need to be zeroed before
     // passing them to the author script.
     ZeroArrayBuffers(isolate, output_array_buffers_);
   }
   DCHECK(!outputs_.IsEmpty());
   DCHECK(outputs_.NewLocal(isolate)->IsArray());
   DCHECK_EQ(outputs_.NewLocal(isolate)->Length(), outputs.size());
   DCHECK_EQ(output_array_buffers_.size(), outputs.size());

   // 3rd JS arg |params_|. Compare |param_value_map| and |params_|. Then
   // allocates the data container if necessary.
   if (!ParamValueMapMatchesToParamsObject(isolate, context, param_value_map,
                                           params_)) {
     bool params_cloned_successfully =
         CloneParamValueMapToObject(isolate, context, param_value_map, params_);
     DCHECK(params_cloned_successfully);
     if (!params_cloned_successfully)
       return false;
   }
   DCHECK(!params_.IsEmpty());
   DCHECK(params_.NewLocal(isolate)->IsObject());

   // Copies |param_value_map| to the internal |params_| object. This operation
   // could fail if the getter of parameterDescriptors is overridden by user code
   // and returns incompatible data. (crbug.com/1151069)
   if (!CopyParamValueMapToObject(isolate, context, param_value_map, params_)) {
     SetErrorState(AudioWorkletProcessorErrorState::kProcessError);
     return false;
   }

   // Performs the user-defined AudioWorkletProcessor.process() function.
   v8::TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
   ScriptValue result;
   {
     TRACE_EVENT0(
         TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
         "AudioWorkletProcessor::Process (author script execution)");
     if (!definition->ProcessFunction()
                    ->Invoke(this,
                             ScriptValue(isolate, inputs_.NewLocal(isolate)),
                             ScriptValue(isolate, outputs_.NewLocal(isolate)),
                             ScriptValue(isolate, params_.NewLocal(isolate)))
                    .To(&result)) {
       SetErrorState(AudioWorkletProcessorErrorState::kProcessError);
       return false;
     }
   }
   DCHECK(!try_catch.HasCaught());

   // Copies the resulting output from author script to |outputs|.
   CopyArrayBuffersToPort(isolate, output_array_buffers_, outputs);

   // Return the value from the user-supplied |process()| function. It is
   // used to maintain the lifetime of the node and the processor.
   return result.V8Value()->IsTrue();
 }

 void AudioWorkletProcessor::SetErrorState(
     AudioWorkletProcessorErrorState error_state) {
   error_state_ = error_state;
 }

 AudioWorkletProcessorErrorState AudioWorkletProcessor::GetErrorState() const {
   return error_state_;
 }

 bool AudioWorkletProcessor::hasErrorOccurred() const {
   return error_state_ != AudioWorkletProcessorErrorState::kNoError;
 }

 MessagePort* AudioWorkletProcessor::port() const {
   return processor_port_.Get();
 }

 void AudioWorkletProcessor::Trace(Visitor* visitor) const {
   visitor->Trace(global_scope_);
   visitor->Trace(processor_port_);
   visitor->Trace(inputs_);
   visitor->Trace(outputs_);
   visitor->Trace(params_);
   visitor->Trace(input_array_buffers_);
   visitor->Trace(output_array_buffers_);
   ScriptWrappable::Trace(visitor);
 }

 bool AudioWorkletProcessor::PortTopologyMatches(
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     const Vector<scoped_refptr<AudioBus>>& audio_port_1,
     const TraceWrapperV8Reference<v8::Array>& audio_port_2) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
                "AudioWorkletProcessor::Process (compare topology)");
   if (audio_port_2.IsEmpty())
     return false;

   // Two AudioPorts are supposed to have the same length because the number of
   // inputs and outputs of AudioNode cannot change after construction.
   v8::Local<v8::Array> port_2_local = audio_port_2.NewLocal(isolate);
   DCHECK(port_2_local->IsArray());
   DCHECK_EQ(audio_port_1.size(), port_2_local->Length());

   v8::TryCatch try_catch(isolate);

   v8::Local<v8::Value> value;
   uint32_t bus_index_counter = 0;
   for (const auto& audio_bus_1 : audio_port_1) {
     if (!port_2_local->Get(context, bus_index_counter).ToLocal(&value) ||
         !value->IsArray())
       return false;

     // Compare the length of AudioBus1[i] from AudioPort1 and AudioBus2[i] from
     // AudioPort2.
     unsigned number_of_channels =
         audio_bus_1 ? audio_bus_1->NumberOfChannels() : 0;
     v8::Local<v8::Array> audio_bus_2 = value.As<v8::Array>();
     if (number_of_channels != audio_bus_2->Length())
       return false;

     // If the channel count of AudioBus1[i] and AudioBus2[i] matches, then
     // iterate all the channels in AudioBus1[i] and see if any AudioChannel
     // is detached. (i.e. transferred to a different thread)
     for (uint32_t channel_index = 0; channel_index < audio_bus_2->Length();
          ++channel_index) {
       if (!audio_bus_2->Get(context, channel_index).ToLocal(&value) ||
           !value->IsFloat32Array())
         return false;
       v8::Local<v8::Float32Array> float32_array = value.As<v8::Float32Array>();

       // If any array is transferred, we need to rebuild them.
       if (float32_array->ByteLength() == 0)
         return false;
     }

     bus_index_counter++;
   }

   return true;
 }

 bool AudioWorkletProcessor::FreezeAudioPort(
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     v8::Local<v8::Array>& audio_port_array) {
   v8::TryCatch try_catch(isolate);

   bool port_frozen;
   if (!audio_port_array
            ->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen)
            .To(&port_frozen))
     return false;

   v8::Local<v8::Value> bus_value;
   for (uint32_t bus_index = 0; bus_index < audio_port_array->Length();
        ++bus_index) {
     if (!audio_port_array->Get(context, bus_index).ToLocal(&bus_value) ||
         !bus_value->IsObject())
       return false;
     bool bus_frozen;
     if (!bus_value.As<v8::Object>()
              ->SetIntegrityLevel(context,v8::IntegrityLevel::kFrozen)
              .To(&bus_frozen))
       return false;
   }

   return true;
 }

 bool AudioWorkletProcessor::ClonePortTopology(
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     const Vector<scoped_refptr<AudioBus>>& audio_port_1,
     TraceWrapperV8Reference<v8::Array>& audio_port_2,
     BackingArrayBuffers& array_buffers) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
                "AudioWorkletProcessor::Process (clone topology)");

   v8::Local<v8::Array> new_port_array =
       v8::Array::New(isolate, audio_port_1.size());
   BackingArrayBuffers new_array_buffers;
   new_array_buffers.ReserveInitialCapacity(audio_port_1.size());

   v8::TryCatch try_catch(isolate);

   uint32_t bus_index = 0;
   for (const auto& audio_bus : audio_port_1) {
     unsigned number_of_channels =
         audio_bus ? audio_bus->NumberOfChannels() : 0;
     size_t bus_length = audio_bus ? audio_bus->length() : 0;
     v8::Local<v8::Array> new_audio_bus =
         v8::Array::New(isolate, number_of_channels);
     bool new_bus_added;
     if (!new_port_array
              ->CreateDataProperty(context, bus_index, new_audio_bus)
              .To(&new_bus_added)) {
       return false;
     }
     new_array_buffers.UncheckedAppend(
         HeapVector<TraceWrapperV8Reference<v8::ArrayBuffer>>());
     new_array_buffers.back().ReserveInitialCapacity(number_of_channels);

     for (uint32_t channel_index = 0; channel_index < number_of_channels;
          ++channel_index) {
       v8::Local<v8::ArrayBuffer> array_buffer =
           v8::ArrayBuffer::New(isolate, bus_length * sizeof(float));
       v8::Local<v8::Float32Array> float32_array =
           v8::Float32Array::New(array_buffer, 0, bus_length);
       bool new_channel_added;
       if (!new_audio_bus->CreateDataProperty(context, channel_index,
                                              float32_array)
                         .To(&new_channel_added))
         return false;
       new_array_buffers.back().UncheckedAppend(
           TraceWrapperV8Reference<v8::ArrayBuffer>(isolate, array_buffer));
     }

     bus_index++;
   }

   if (!FreezeAudioPort(isolate, context, new_port_array))
     return false;

   audio_port_2.Set(isolate, new_port_array);
   array_buffers.swap(new_array_buffers);
   return true;
 }

 void AudioWorkletProcessor::CopyPortToArrayBuffers(
       v8::Isolate* isolate,
       const Vector<scoped_refptr<AudioBus>>& audio_port,
       BackingArrayBuffers& array_buffers) {
   DCHECK_EQ(audio_port.size(), array_buffers.size());

   for (uint32_t bus_index = 0; bus_index < audio_port.size(); ++bus_index) {
     const scoped_refptr<AudioBus>& audio_bus = audio_port[bus_index];
     size_t bus_length = audio_bus ? audio_bus->length() : 0;
     unsigned number_of_channels = audio_bus ? audio_bus->NumberOfChannels() : 0;
     for (uint32_t channel_index = 0; channel_index < number_of_channels;
          ++channel_index) {
       const v8::ArrayBuffer::Contents& contents =
           array_buffers[bus_index][channel_index].NewLocal(isolate)
               ->GetContents();
       memcpy(contents.Data(), audio_bus->Channel(channel_index)->Data(),
              bus_length * sizeof(float));
     }
   }
 }

 void AudioWorkletProcessor::CopyArrayBuffersToPort(
     v8::Isolate* isolate,
     const BackingArrayBuffers& array_buffers,
     Vector<scoped_refptr<AudioBus>>& audio_port) {
   DCHECK_EQ(array_buffers.size(), audio_port.size());

   for (uint32_t bus_index = 0; bus_index < audio_port.size(); ++bus_index) {
     const scoped_refptr<AudioBus>& audio_bus = audio_port[bus_index];
     for (uint32_t channel_index = 0;
          channel_index < audio_bus->NumberOfChannels(); ++channel_index) {
       const v8::ArrayBuffer::Contents& contents =
           array_buffers[bus_index][channel_index].NewLocal(isolate)
               ->GetContents();
       const size_t bus_length = audio_bus->length() * sizeof(float);

       // An ArrayBuffer might be transferred. So we need to check the byte
       // length and silence the output buffer if needed.
       if (contents.ByteLength() == bus_length) {
         memcpy(audio_bus->Channel(channel_index)->MutableData(),
                contents.Data(), bus_length);
       } else {
         memset(audio_bus->Channel(channel_index)->MutableData(), 0, bus_length);
       }
     }
   }
 }

 void AudioWorkletProcessor::ZeroArrayBuffers(
     v8::Isolate* isolate,
     const BackingArrayBuffers& array_buffers) {
   for (uint32_t bus_index = 0; bus_index < array_buffers.size(); ++bus_index) {
     for (uint32_t channel_index = 0;
          channel_index < array_buffers[bus_index].size(); ++channel_index) {
       const v8::ArrayBuffer::Contents& contents =
           array_buffers[bus_index][channel_index].NewLocal(isolate)
               ->GetContents();
       memset(contents.Data(), 0, contents.ByteLength());
     }
   }
 }

 bool AudioWorkletProcessor::ParamValueMapMatchesToParamsObject(
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map,
     const TraceWrapperV8Reference<v8::Object>& params) {
   v8::TryCatch try_catch(isolate);

   if (params.IsEmpty())
     return false;

   v8::Local<v8::Object> params_object = params.NewLocal(isolate);

   for (const auto& entry : param_value_map) {
     const String param_name = entry.key.IsolatedCopy();
     const auto* param_float_array = entry.value.get();
     v8::Local<v8::String> v8_param_name = V8String(isolate, param_name);

     // TODO(crbug.com/1095113): Remove this check and move the logic to
     // AudioWorkletHandler. |param_float_array| is always 128 frames, and this
     // could be optimized as well.
     unsigned array_size = 1;
     for (unsigned k = 1; k < param_float_array->size(); ++k) {
       if (param_float_array->Data()[k] != param_float_array->Data()[0]) {
         array_size = param_float_array->size();
         break;
       }
     }

     // The |param_name| should exist in the |param| object.
     v8::Local<v8::Value> param_array_value;
     if (!params_object->Get(context, v8_param_name)
                       .ToLocal(&param_array_value) ||
         !param_array_value->IsFloat32Array())
       return false;

     // If the detected array length doesn't match or any underlying array
     // buffer is transferred, we have to reallocate.
     v8::Local<v8::Float32Array> float32_array =
         param_array_value.As<v8::Float32Array>();
     if (float32_array->Length() != array_size ||
         float32_array->Buffer()->ByteLength() == 0)
       return false;
   }

   return true;
 }

 bool AudioWorkletProcessor::CloneParamValueMapToObject(
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map,
     TraceWrapperV8Reference<v8::Object>& params) {
   TRACE_EVENT0(
       TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
       "AudioWorkletProcessor::Process (AudioParam memory allocation)");

   v8::TryCatch try_catch(isolate);

   v8::Local<v8::Object> new_params_object = v8::Object::New(isolate);

   for (const auto& entry : param_value_map) {
     const String param_name = entry.key.IsolatedCopy();
     const auto* param_float_array = entry.value.get();
     v8::Local<v8::String> v8_param_name = V8String(isolate, param_name);

     // TODO(crbug.com/1095113): Remove this check and move the logic to
     // AudioWorkletHandler. |param_float_array| is always 128 frames, and this
     // could be optimized as well.
     unsigned array_size = 1;
     for (unsigned k = 1; k < param_float_array->size(); ++k) {
       if (param_float_array->Data()[k] != param_float_array->Data()[0]) {
         array_size = param_float_array->size();
         break;
       }
     }
     DCHECK(array_size == 1 || array_size == param_float_array->size());

     v8::Local<v8::ArrayBuffer> array_buffer =
         v8::ArrayBuffer::New(isolate, array_size * sizeof(float));
     v8::Local<v8::Float32Array> float32_array =
         v8::Float32Array::New(array_buffer, 0, array_size);
     bool new_param_array_created;
     if (!new_params_object
              ->CreateDataProperty(context, v8_param_name, float32_array)
              .To(&new_param_array_created)) {
       return false;
     }
   }

   bool object_frozen;
   if (!new_params_object
           ->SetIntegrityLevel(context,v8::IntegrityLevel::kFrozen)
           .To(&object_frozen))
     return false;

   params.Set(isolate, new_params_object);
   return true;
 }

 bool AudioWorkletProcessor::CopyParamValueMapToObject(
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map,
     TraceWrapperV8Reference<v8::Object>& params) {
   v8::TryCatch try_catch(isolate);

   v8::Local<v8::Object> params_object = params.NewLocal(isolate);

   for (const auto& entry : param_value_map) {
     const String param_name = entry.key.IsolatedCopy();
     const AudioFloatArray* param_array = entry.value.get();

     v8::Local<v8::Value> param_array_value;
     if (!params_object->Get(context, V8String(isolate, param_name))
                       .ToLocal(&param_array_value) ||
         !param_array_value->IsFloat32Array()) {
       return false;
     }

     v8::Local<v8::Float32Array> float32_array =
         param_array_value.As<v8::Float32Array>();
     size_t array_length = float32_array->Length();

     // The |float32_array| is neither 1 nor 128 frames, or the array buffer is
     // trasnferred/detached, do not proceed.
     if ((array_length != 1 && array_length != param_array->size()) ||
         float32_array->Buffer()->ByteLength() == 0)
       return false;

     memcpy(float32_array->Buffer()->GetContents().Data(), param_array->Data(),
            array_length * sizeof(float));
   }

   return true;
 }

 }  // namespace blink
	// 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 "third_party/blink/renderer/modules/webaudio/audio_worklet_processor.h"

	#include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
	#include "third_party/blink/renderer/bindings/modules/v8/v8_blink_audio_worklet_process_callback.h"
	#include "third_party/blink/renderer/core/messaging/message_port.h"
	#include "third_party/blink/renderer/core/workers/worker_global_scope.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_buffer.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_worklet_global_scope.h"
	#include "third_party/blink/renderer/modules/webaudio/audio_worklet_processor_definition.h"
	#include "third_party/blink/renderer/platform/audio/audio_bus.h"
	#include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"

	namespace blink {

	AudioWorkletProcessor* AudioWorkletProcessor::Create(
	ExecutionContext* context) {
	AudioWorkletGlobalScope* global_scope = To<AudioWorkletGlobalScope>(context);
	DCHECK(global_scope);
	DCHECK(global_scope->IsContextThread());

	// Get the stored initialization parameter from the global scope.
	ProcessorCreationParams* params = global_scope->GetProcessorCreationParams();
	DCHECK(params);

	auto* port = MakeGarbageCollected<MessagePort>(*global_scope);
	port->Entangle(std::move(params->PortChannel()));
	return MakeGarbageCollected<AudioWorkletProcessor>(global_scope,
	params->Name(), port);
	}

	AudioWorkletProcessor::AudioWorkletProcessor(
	AudioWorkletGlobalScope* global_scope,
	const String& name,
	MessagePort* port)
	: global_scope_(global_scope), processor_port_(port), name_(name) {}

	bool AudioWorkletProcessor::Process(
	const Vector<scoped_refptr<AudioBus>>& inputs,
	Vector<scoped_refptr<AudioBus>>& outputs,
	const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map) {
	TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
	"AudioWorkletProcessor::Process");

	DCHECK(global_scope_->IsContextThread());
	DCHECK(!hasErrorOccurred());

	ScriptState* script_state =
	global_scope_->ScriptController()->GetScriptState();
	ScriptState::Scope scope(script_state);
	v8::Isolate* isolate = script_state->GetIsolate();
	v8::Local<v8::Context> context = script_state->GetContext();
	AudioWorkletProcessorDefinition* definition =
	global_scope_->FindDefinition(Name());

	// 1st JS arg \|inputs_\|. Compare \|inputs\| and \|inputs_\|. Then allocates the
	// data container if necessary.
	if (!PortTopologyMatches(isolate, context, inputs, inputs_)) {
	bool inputs_cloned_successfully =
	ClonePortTopology(isolate, context, inputs, inputs_,
	input_array_buffers_);
	DCHECK(inputs_cloned_successfully);
	if (!inputs_cloned_successfully)
	return false;
	}
	DCHECK(!inputs_.IsEmpty());
	DCHECK(inputs_.NewLocal(isolate)->IsArray());
	DCHECK_EQ(inputs_.NewLocal(isolate)->Length(), inputs.size());
	DCHECK_EQ(input_array_buffers_.size(), inputs.size());

	// Copies \|inputs\| to the internal \|input_array_buffers\|.
	CopyPortToArrayBuffers(isolate, inputs, input_array_buffers_);

	// 2nd JS arg \|outputs_\|. Compare \|outputs\| and \|outputs_\|. Then allocates the
	// data container if necessary.
	if (!PortTopologyMatches(isolate, context, outputs, outputs_)) {
	bool outputs_cloned_successfully =
	ClonePortTopology(isolate, context, outputs, outputs_,
	output_array_buffers_);
	DCHECK(outputs_cloned_successfully);
	if (!outputs_cloned_successfully)
	return false;
	} else {
	// The reallocation was not needed, so the arrays need to be zeroed before
	// passing them to the author script.
	ZeroArrayBuffers(isolate, output_array_buffers_);
	}
	DCHECK(!outputs_.IsEmpty());
	DCHECK(outputs_.NewLocal(isolate)->IsArray());
	DCHECK_EQ(outputs_.NewLocal(isolate)->Length(), outputs.size());
	DCHECK_EQ(output_array_buffers_.size(), outputs.size());

	// 3rd JS arg \|params_\|. Compare \|param_value_map\| and \|params_\|. Then
	// allocates the data container if necessary.
	if (!ParamValueMapMatchesToParamsObject(isolate, context, param_value_map,
	params_)) {
	bool params_cloned_successfully =
	CloneParamValueMapToObject(isolate, context, param_value_map, params_);
	DCHECK(params_cloned_successfully);
	if (!params_cloned_successfully)
	return false;
	}
	DCHECK(!params_.IsEmpty());
	DCHECK(params_.NewLocal(isolate)->IsObject());

	// Copies \|param_value_map\| to the internal \|params_\| object. This operation
	// could fail if the getter of parameterDescriptors is overridden by user code
	// and returns incompatible data. (crbug.com/1151069)
	if (!CopyParamValueMapToObject(isolate, context, param_value_map, params_)) {
	SetErrorState(AudioWorkletProcessorErrorState::kProcessError);
	return false;
	}

	// Performs the user-defined AudioWorkletProcessor.process() function.
	v8::TryCatch try_catch(isolate);
	try_catch.SetVerbose(true);
	ScriptValue result;
	{
	TRACE_EVENT0(
	TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
	"AudioWorkletProcessor::Process (author script execution)");
	if (!definition->ProcessFunction()
	->Invoke(this,
	ScriptValue(isolate, inputs_.NewLocal(isolate)),
	ScriptValue(isolate, outputs_.NewLocal(isolate)),
	ScriptValue(isolate, params_.NewLocal(isolate)))
	.To(&result)) {
	SetErrorState(AudioWorkletProcessorErrorState::kProcessError);
	return false;
	}
	}
	DCHECK(!try_catch.HasCaught());

	// Copies the resulting output from author script to \|outputs\|.
	CopyArrayBuffersToPort(isolate, output_array_buffers_, outputs);

	// Return the value from the user-supplied \|process()\| function. It is
	// used to maintain the lifetime of the node and the processor.
	return result.V8Value()->IsTrue();
	}

	void AudioWorkletProcessor::SetErrorState(
	AudioWorkletProcessorErrorState error_state) {
	error_state_ = error_state;
	}

	AudioWorkletProcessorErrorState AudioWorkletProcessor::GetErrorState() const {
	return error_state_;
	}

	bool AudioWorkletProcessor::hasErrorOccurred() const {
	return error_state_ != AudioWorkletProcessorErrorState::kNoError;
	}

	MessagePort* AudioWorkletProcessor::port() const {
	return processor_port_.Get();
	}

	void AudioWorkletProcessor::Trace(Visitor* visitor) const {
	visitor->Trace(global_scope_);
	visitor->Trace(processor_port_);
	visitor->Trace(inputs_);
	visitor->Trace(outputs_);
	visitor->Trace(params_);
	visitor->Trace(input_array_buffers_);
	visitor->Trace(output_array_buffers_);
	ScriptWrappable::Trace(visitor);
	}

	bool AudioWorkletProcessor::PortTopologyMatches(
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	const Vector<scoped_refptr<AudioBus>>& audio_port_1,
	const TraceWrapperV8Reference<v8::Array>& audio_port_2) {
	TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
	"AudioWorkletProcessor::Process (compare topology)");
	if (audio_port_2.IsEmpty())
	return false;

	// Two AudioPorts are supposed to have the same length because the number of
	// inputs and outputs of AudioNode cannot change after construction.
	v8::Local<v8::Array> port_2_local = audio_port_2.NewLocal(isolate);
	DCHECK(port_2_local->IsArray());
	DCHECK_EQ(audio_port_1.size(), port_2_local->Length());

	v8::TryCatch try_catch(isolate);

	v8::Local<v8::Value> value;
	uint32_t bus_index_counter = 0;
	for (const auto& audio_bus_1 : audio_port_1) {
	if (!port_2_local->Get(context, bus_index_counter).ToLocal(&value) \|\|
	!value->IsArray())
	return false;

	// Compare the length of AudioBus1[i] from AudioPort1 and AudioBus2[i] from
	// AudioPort2.
	unsigned number_of_channels =
	audio_bus_1 ? audio_bus_1->NumberOfChannels() : 0;
	v8::Local<v8::Array> audio_bus_2 = value.As<v8::Array>();
	if (number_of_channels != audio_bus_2->Length())
	return false;

	// If the channel count of AudioBus1[i] and AudioBus2[i] matches, then
	// iterate all the channels in AudioBus1[i] and see if any AudioChannel
	// is detached. (i.e. transferred to a different thread)
	for (uint32_t channel_index = 0; channel_index < audio_bus_2->Length();
	++channel_index) {
	if (!audio_bus_2->Get(context, channel_index).ToLocal(&value) \|\|
	!value->IsFloat32Array())
	return false;
	v8::Local<v8::Float32Array> float32_array = value.As<v8::Float32Array>();

	// If any array is transferred, we need to rebuild them.
	if (float32_array->ByteLength() == 0)
	return false;
	}

	bus_index_counter++;
	}

	return true;
	}

	bool AudioWorkletProcessor::FreezeAudioPort(
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	v8::Local<v8::Array>& audio_port_array) {
	v8::TryCatch try_catch(isolate);

	bool port_frozen;
	if (!audio_port_array
	->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen)
	.To(&port_frozen))
	return false;

	v8::Local<v8::Value> bus_value;
	for (uint32_t bus_index = 0; bus_index < audio_port_array->Length();
	++bus_index) {
	if (!audio_port_array->Get(context, bus_index).ToLocal(&bus_value) \|\|
	!bus_value->IsObject())
	return false;
	bool bus_frozen;
	if (!bus_value.As<v8::Object>()
	->SetIntegrityLevel(context,v8::IntegrityLevel::kFrozen)
	.To(&bus_frozen))
	return false;
	}

	return true;
	}

	bool AudioWorkletProcessor::ClonePortTopology(
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	const Vector<scoped_refptr<AudioBus>>& audio_port_1,
	TraceWrapperV8Reference<v8::Array>& audio_port_2,
	BackingArrayBuffers& array_buffers) {
	TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
	"AudioWorkletProcessor::Process (clone topology)");

	v8::Local<v8::Array> new_port_array =
	v8::Array::New(isolate, audio_port_1.size());
	BackingArrayBuffers new_array_buffers;
	new_array_buffers.ReserveInitialCapacity(audio_port_1.size());

	v8::TryCatch try_catch(isolate);

	uint32_t bus_index = 0;
	for (const auto& audio_bus : audio_port_1) {
	unsigned number_of_channels =
	audio_bus ? audio_bus->NumberOfChannels() : 0;
	size_t bus_length = audio_bus ? audio_bus->length() : 0;
	v8::Local<v8::Array> new_audio_bus =
	v8::Array::New(isolate, number_of_channels);
	bool new_bus_added;
	if (!new_port_array
	->CreateDataProperty(context, bus_index, new_audio_bus)
	.To(&new_bus_added)) {
	return false;
	}
	new_array_buffers.UncheckedAppend(
	HeapVector<TraceWrapperV8Reference<v8::ArrayBuffer>>());
	new_array_buffers.back().ReserveInitialCapacity(number_of_channels);

	for (uint32_t channel_index = 0; channel_index < number_of_channels;
	++channel_index) {
	v8::Local<v8::ArrayBuffer> array_buffer =
	v8::ArrayBuffer::New(isolate, bus_length * sizeof(float));
	v8::Local<v8::Float32Array> float32_array =
	v8::Float32Array::New(array_buffer, 0, bus_length);
	bool new_channel_added;
	if (!new_audio_bus->CreateDataProperty(context, channel_index,
	float32_array)
	.To(&new_channel_added))
	return false;
	new_array_buffers.back().UncheckedAppend(
	TraceWrapperV8Reference<v8::ArrayBuffer>(isolate, array_buffer));
	}

	bus_index++;
	}

	if (!FreezeAudioPort(isolate, context, new_port_array))
	return false;

	audio_port_2.Set(isolate, new_port_array);
	array_buffers.swap(new_array_buffers);
	return true;
	}

	void AudioWorkletProcessor::CopyPortToArrayBuffers(
	v8::Isolate* isolate,
	const Vector<scoped_refptr<AudioBus>>& audio_port,
	BackingArrayBuffers& array_buffers) {
	DCHECK_EQ(audio_port.size(), array_buffers.size());

	for (uint32_t bus_index = 0; bus_index < audio_port.size(); ++bus_index) {
	const scoped_refptr<AudioBus>& audio_bus = audio_port[bus_index];
	size_t bus_length = audio_bus ? audio_bus->length() : 0;
	unsigned number_of_channels = audio_bus ? audio_bus->NumberOfChannels() : 0;
	for (uint32_t channel_index = 0; channel_index < number_of_channels;
	++channel_index) {
	const v8::ArrayBuffer::Contents& contents =
	array_buffers[bus_index][channel_index].NewLocal(isolate)
	->GetContents();
	memcpy(contents.Data(), audio_bus->Channel(channel_index)->Data(),
	bus_length * sizeof(float));
	}
	}
	}

	void AudioWorkletProcessor::CopyArrayBuffersToPort(
	v8::Isolate* isolate,
	const BackingArrayBuffers& array_buffers,
	Vector<scoped_refptr<AudioBus>>& audio_port) {
	DCHECK_EQ(array_buffers.size(), audio_port.size());

	for (uint32_t bus_index = 0; bus_index < audio_port.size(); ++bus_index) {
	const scoped_refptr<AudioBus>& audio_bus = audio_port[bus_index];
	for (uint32_t channel_index = 0;
	channel_index < audio_bus->NumberOfChannels(); ++channel_index) {
	const v8::ArrayBuffer::Contents& contents =
	array_buffers[bus_index][channel_index].NewLocal(isolate)
	->GetContents();
	const size_t bus_length = audio_bus->length() * sizeof(float);

	// An ArrayBuffer might be transferred. So we need to check the byte
	// length and silence the output buffer if needed.
	if (contents.ByteLength() == bus_length) {
	memcpy(audio_bus->Channel(channel_index)->MutableData(),
	contents.Data(), bus_length);
	} else {
	memset(audio_bus->Channel(channel_index)->MutableData(), 0, bus_length);
	}
	}
	}
	}

	void AudioWorkletProcessor::ZeroArrayBuffers(
	v8::Isolate* isolate,
	const BackingArrayBuffers& array_buffers) {
	for (uint32_t bus_index = 0; bus_index < array_buffers.size(); ++bus_index) {
	for (uint32_t channel_index = 0;
	channel_index < array_buffers[bus_index].size(); ++channel_index) {
	const v8::ArrayBuffer::Contents& contents =
	array_buffers[bus_index][channel_index].NewLocal(isolate)
	->GetContents();
	memset(contents.Data(), 0, contents.ByteLength());
	}
	}
	}

	bool AudioWorkletProcessor::ParamValueMapMatchesToParamsObject(
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map,
	const TraceWrapperV8Reference<v8::Object>& params) {
	v8::TryCatch try_catch(isolate);

	if (params.IsEmpty())
	return false;

	v8::Local<v8::Object> params_object = params.NewLocal(isolate);

	for (const auto& entry : param_value_map) {
	const String param_name = entry.key.IsolatedCopy();
	const auto* param_float_array = entry.value.get();
	v8::Local<v8::String> v8_param_name = V8String(isolate, param_name);

	// TODO(crbug.com/1095113): Remove this check and move the logic to
	// AudioWorkletHandler. \|param_float_array\| is always 128 frames, and this
	// could be optimized as well.
	unsigned array_size = 1;
	for (unsigned k = 1; k < param_float_array->size(); ++k) {
	if (param_float_array->Data()[k] != param_float_array->Data()[0]) {
	array_size = param_float_array->size();
	break;
	}
	}

	// The \|param_name\| should exist in the \|param\| object.
	v8::Local<v8::Value> param_array_value;
	if (!params_object->Get(context, v8_param_name)
	.ToLocal(&param_array_value) \|\|
	!param_array_value->IsFloat32Array())
	return false;

	// If the detected array length doesn't match or any underlying array
	// buffer is transferred, we have to reallocate.
	v8::Local<v8::Float32Array> float32_array =
	param_array_value.As<v8::Float32Array>();
	if (float32_array->Length() != array_size \|\|
	float32_array->Buffer()->ByteLength() == 0)
	return false;
	}

	return true;
	}

	bool AudioWorkletProcessor::CloneParamValueMapToObject(
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map,
	TraceWrapperV8Reference<v8::Object>& params) {
	TRACE_EVENT0(
	TRACE_DISABLED_BY_DEFAULT("audio-worklet"),
	"AudioWorkletProcessor::Process (AudioParam memory allocation)");

	v8::TryCatch try_catch(isolate);

	v8::Local<v8::Object> new_params_object = v8::Object::New(isolate);

	for (const auto& entry : param_value_map) {
	const String param_name = entry.key.IsolatedCopy();
	const auto* param_float_array = entry.value.get();
	v8::Local<v8::String> v8_param_name = V8String(isolate, param_name);

	// TODO(crbug.com/1095113): Remove this check and move the logic to
	// AudioWorkletHandler. \|param_float_array\| is always 128 frames, and this
	// could be optimized as well.
	unsigned array_size = 1;
	for (unsigned k = 1; k < param_float_array->size(); ++k) {
	if (param_float_array->Data()[k] != param_float_array->Data()[0]) {
	array_size = param_float_array->size();
	break;
	}
	}
	DCHECK(array_size == 1 \|\| array_size == param_float_array->size());

	v8::Local<v8::ArrayBuffer> array_buffer =
	v8::ArrayBuffer::New(isolate, array_size * sizeof(float));
	v8::Local<v8::Float32Array> float32_array =
	v8::Float32Array::New(array_buffer, 0, array_size);
	bool new_param_array_created;
	if (!new_params_object
	->CreateDataProperty(context, v8_param_name, float32_array)
	.To(&new_param_array_created)) {
	return false;
	}
	}

	bool object_frozen;
	if (!new_params_object
	->SetIntegrityLevel(context,v8::IntegrityLevel::kFrozen)
	.To(&object_frozen))
	return false;

	params.Set(isolate, new_params_object);
	return true;
	}

	bool AudioWorkletProcessor::CopyParamValueMapToObject(
	v8::Isolate* isolate,
	v8::Local<v8::Context> context,
	const HashMap<String, std::unique_ptr<AudioFloatArray>>& param_value_map,
	TraceWrapperV8Reference<v8::Object>& params) {
	v8::TryCatch try_catch(isolate);

	v8::Local<v8::Object> params_object = params.NewLocal(isolate);

	for (const auto& entry : param_value_map) {
	const String param_name = entry.key.IsolatedCopy();
	const AudioFloatArray* param_array = entry.value.get();

	v8::Local<v8::Value> param_array_value;
	if (!params_object->Get(context, V8String(isolate, param_name))
	.ToLocal(&param_array_value) \|\|
	!param_array_value->IsFloat32Array()) {
	return false;
	}

	v8::Local<v8::Float32Array> float32_array =
	param_array_value.As<v8::Float32Array>();
	size_t array_length = float32_array->Length();

	// The \|float32_array\| is neither 1 nor 128 frames, or the array buffer is
	// trasnferred/detached, do not proceed.
	if ((array_length != 1 && array_length != param_array->size()) \|\|
	float32_array->Buffer()->ByteLength() == 0)
	return false;

	memcpy(float32_array->Buffer()->GetContents().Data(), param_array->Data(),
	array_length * sizeof(float));
	}

	return true;
	}

	} // namespace blink