Slightly reduce memory usage in OscillatorNode

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

 /*
  * Copyright (C) 2012, 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 23 matching lines @@
 #include "platform/audio/VectorMath.h"
 #include "platform/wtf/MathExtras.h"
 #include "platform/wtf/StdLibExtras.h"
 
 namespace blink {
 
 using namespace VectorMath;
 
 OscillatorHandler::OscillatorHandler(AudioNode& node,
                                      float sample_rate,
+                                     const String& oscillator_type,
+                                     PeriodicWave* wave_table,
                                      AudioParamHandler& frequency,
                                      AudioParamHandler& detune)
     : AudioScheduledSourceHandler(kNodeTypeOscillator, node, sample_rate),
-      type_(SINE),
       frequency_(frequency),
       detune_(detune),
       first_render_(true),
       virtual_read_index_(0),
       phase_increments_(AudioUtilities::kRenderQuantumFrames),
       detune_values_(AudioUtilities::kRenderQuantumFrames) {
-  // Sets up default wavetable.
-  SetType(type_);
+  if (wave_table) {
+    // A PeriodicWave overrides any value for the oscillator type,
+    // forcing the type to be 'custom".
+    SetPeriodicWave(wave_table);
+  } else {
+    if (oscillator_type == "sine")
+      SetType(SINE);
+    else if (oscillator_type == "square")
+      SetType(SQUARE);
+    else if (oscillator_type == "sawtooth")
+      SetType(SAWTOOTH);
+    else if (oscillator_type == "triangle")
+      SetType(TRIANGLE);
+    else
+      NOTREACHED();
+  }
 
   // An oscillator is always mono.
   AddOutput(1);
 
   Initialize();
 }
 
 PassRefPtr<OscillatorHandler> OscillatorHandler::Create(
     AudioNode& node,
     float sample_rate,
+    const String& oscillator_type,
+    PeriodicWave* wave_table,
     AudioParamHandler& frequency,
     AudioParamHandler& detune) {
-  return AdoptRef(new OscillatorHandler(node, sample_rate, frequency, detune));
+  return AdoptRef(new OscillatorHandler(node, sample_rate, oscillator_type,
+                                        wave_table, frequency, detune));
 }
 
 OscillatorHandler::~OscillatorHandler() {
   Uninitialize();
 }
 
 String OscillatorHandler::GetType() const {
   switch (type_) {
     case SINE:
       return "sine";
@@ skipping 280 matching lines @@
   periodic_wave_ = periodic_wave;
   type_ = CUSTOM;
 }
 
 bool OscillatorHandler::PropagatesSilence() const {
   return !IsPlayingOrScheduled() || HasFinished() || !periodic_wave_.Get();
 }
 
 // ----------------------------------------------------------------
 
-OscillatorNode::OscillatorNode(BaseAudioContext& context)
+OscillatorNode::OscillatorNode(BaseAudioContext& context,
+                               const String& oscillator_type,
+                               PeriodicWave* wave_table)
     : AudioScheduledSourceNode(context),
       // Use musical pitch standard A440 as a default.
       frequency_(AudioParam::Create(context,
                                     kParamTypeOscillatorFrequency,
                                     440,
                                     -context.sampleRate() / 2,
                                     context.sampleRate() / 2)),
       // Default to no detuning.
       detune_(AudioParam::Create(context, kParamTypeOscillatorDetune, 0)) {
   SetHandler(OscillatorHandler::Create(
-      *this, context.sampleRate(), frequency_->Handler(), detune_->Handler()));
+      *this, context.sampleRate(), oscillator_type, wave_table,
+      frequency_->Handler(), detune_->Handler()));
 }
 
 OscillatorNode* OscillatorNode::Create(BaseAudioContext& context,
+                                       const String& oscillator_type,
+                                       PeriodicWave* wave_table,
                                        ExceptionState& exception_state) {
   DCHECK(IsMainThread());
 
   if (context.IsContextClosed()) {
     context.ThrowExceptionForClosedState(exception_state);
     return nullptr;
   }
 
-  return new OscillatorNode(context);
+  return new OscillatorNode(context, oscillator_type, wave_table);
 }
 
 OscillatorNode* OscillatorNode::Create(BaseAudioContext* context,
                                        const OscillatorOptions& options,
                                        ExceptionState& exception_state) {
-  OscillatorNode* node = Create(*context, exception_state);
+  if (options.type() == "custom" && !options.hasPeriodicWave()) {
+    exception_state.ThrowDOMException(
+        kInvalidStateError,
+        "A PeriodicWave must be specified if the type is set to \"custom\"");
+    return nullptr;
+  }
+
+  OscillatorNode* node =
+      Create(*context, options.type(), options.periodicWave(), exception_state);
 
   if (!node)
     return nullptr;
 
   node->HandleChannelOptions(options, exception_state);
 
-  if (options.hasPeriodicWave()) {
-    // Set up the custom wave; this also sets the type to "custom",
-    // overriding any |type| option the user may have set.  Per spec.
-    node->setPeriodicWave(options.periodicWave());
-  } else {
-    node->setType(options.type(), exception_state);
-  }
-
   node->detune()->setValue(options.detune());
   node->frequency()->setValue(options.frequency());
 
   return node;
 }
 
 DEFINE_TRACE(OscillatorNode) {
   visitor->Trace(frequency_);
   visitor->Trace(detune_);
   AudioScheduledSourceNode::Trace(visitor);
@@ skipping 18 matching lines @@
 
 AudioParam* OscillatorNode::detune() {
   return detune_;
 }
 
 void OscillatorNode::setPeriodicWave(PeriodicWave* wave) {
   GetOscillatorHandler().SetPeriodicWave(wave);
 }
 
 }  // namespace blink