setValueCurveAtTime takes sequence<float> for curve

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

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 184 matching lines @@
   // The time line code does not expect a timeConstant of 0. (IT
   // returns NaN or Infinity due to division by zero.  The caller
   // should have converted this to a SetValueEvent.
   DCHECK_NE(time_constant, 0);
   return WTF::WrapUnique(
       new ParamEvent(ParamEvent::kSetTarget, value, time, time_constant));
 }
 
 std::unique_ptr<AudioParamTimeline::ParamEvent>
 AudioParamTimeline::ParamEvent::CreateSetValueCurveEvent(
-    const DOMFloat32Array* curve,
+    const Vector<float>& curve,
     double time,
     double duration) {
-  double curve_points = (curve->length() - 1) / duration;
-  float end_value = curve->Data()[curve->length() - 1];
+  double curve_points = (curve.size() - 1) / duration;
+  float end_value = curve.Data()[curve.size() - 1];
 
   return WTF::WrapUnique(new ParamEvent(ParamEvent::kSetValueCurve, time,
                                         duration, curve, curve_points,
                                         end_value));
 }
 
 std::unique_ptr<AudioParamTimeline::ParamEvent>
 AudioParamTimeline::ParamEvent::CreateCancelValuesEvent(
     double time,
     std::unique_ptr<ParamEvent> saved_event) {
@@ skipping 134 matching lines @@
       saved_event_(nullptr),
       needs_time_clamp_check_(true),
       has_default_cancelled_value_(false) {
   DCHECK_EQ(type, ParamEvent::kSetTarget);
 }
 
 // Create a setValueCurve event
 AudioParamTimeline::ParamEvent::ParamEvent(ParamEvent::Type type,
                                            double time,
                                            double duration,
-                                           const DOMFloat32Array* curve,
+                                           const Vector<float>& curve,
                                            double curve_points_per_second,
                                            float curve_end_value)
     : type_(type),
       value_(0),
       time_(time),
       initial_value_(0),
       call_time_(0),
       time_constant_(0),
       duration_(duration),
       curve_points_per_second_(curve_points_per_second),
       curve_end_value_(curve_end_value),
       saved_event_(nullptr),
       needs_time_clamp_check_(true),
       has_default_cancelled_value_(false) {
   DCHECK_EQ(type, ParamEvent::kSetValueCurve);
-  if (curve) {
-    unsigned curve_length = curve->length();
-    curve_.Resize(curve->length());
-    memcpy(curve_.Data(), curve->Data(), curve_length * sizeof(float));
-  }
+  unsigned curve_length = curve.size();
+  curve_.Resize(curve_length);
+  memcpy(curve_.Data(), curve.Data(), curve_length * sizeof(float));
 }
 
 // Create CancelValues event
 AudioParamTimeline::ParamEvent::ParamEvent(
     ParamEvent::Type type,
     double time,
     std::unique_ptr<ParamEvent> saved_event)
     : type_(type),
       value_(0),
       time_(time),
@@ skipping 81 matching lines @@
   // If timeConstant = 0, we instantly jump to the target value, so
   // insert a SetValueEvent instead of SetTargetEvent.
   if (time_constant == 0) {
     InsertEvent(ParamEvent::CreateSetValueEvent(target, time), exception_state);
   } else {
     InsertEvent(ParamEvent::CreateSetTargetEvent(target, time, time_constant),
                 exception_state);
   }
 }
 
-void AudioParamTimeline::SetValueCurveAtTime(DOMFloat32Array* curve,
+void AudioParamTimeline::SetValueCurveAtTime(const Vector<float>& curve,
                                              double time,
                                              double duration,
                                              ExceptionState& exception_state) {
   DCHECK(IsMainThread());
-  DCHECK(curve);
 
   if (!IsNonNegativeAudioParamTime(time, exception_state) ||
       !IsPositiveAudioParamTime(duration, exception_state, "Duration"))
     return;
 
-  if (curve->length() < 2) {
+  if (curve.size() < 2) {
     exception_state.ThrowDOMException(
-        kInvalidStateError, ExceptionMessages::IndexExceedsMinimumBound(
-                                "curve length", curve->length(), 2U));
+        kInvalidStateError,
+        ExceptionMessages::IndexExceedsMinimumBound(
+            "curve length", curve.size(), static_cast<size_t>(2)));
     return;
   }
 
   MutexLocker locker(events_lock_);
   InsertEvent(ParamEvent::CreateSetValueCurveEvent(curve, time, duration),
               exception_state);
 
   // Insert a setValueAtTime event too to establish an event so that all
   // following events will process from the end of the curve instead of the
   // beginning.
-  InsertEvent(ParamEvent::CreateSetValueEvent(
-                  curve->Data()[curve->length() - 1], time + duration),
+  InsertEvent(ParamEvent::CreateSetValueEvent(curve.Data()[curve.size() - 1],
+                                              time + duration),
               exception_state);
 }
 
 void AudioParamTimeline::InsertEvent(std::unique_ptr<ParamEvent> event,
                                      ExceptionState& exception_state) {
   DCHECK(IsMainThread());
 
   // Sanity check the event. Be super careful we're not getting infected with
   // NaN or Inf. These should have been handled by the caller.
   bool is_valid = event->GetType() < ParamEvent::kLastType &&
@@ skipping 1253 matching lines @@
                                              unsigned write_index) {
   size_t index = write_index;
 
   for (; index < end_frame; ++index)
     values[index] = default_value;
 
   return index;
 }
 
 }  // namespace blink