Run clang-format on .js files in c/b/r/chromeos/chromevox

chrome/browser/resources/chromeos/chromevox/cvox2/background/earcon_engine.js

 // Copyright 2015 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.
 
 /**
  * @fileoverview This is the low-level class that generates ChromeVox's
  * earcons. It's designed to be self-contained and not depend on the
  * rest of the code.
  */
 
@@ skipping 73 matching lines @@
 
   // Private variables.
 
   /** @type {AudioContext} @private The audio context. */
   this.context_ = new AudioContext();
 
   /** @type {?ConvolverNode} @private The reverb node, lazily initialized. */
   this.reverbConvolver_ = null;
 
   /**
-    * @type {Object<string, AudioBuffer>} A map between the name of an
-    *     audio data file and its loaded AudioBuffer.
-    * @private
-    */
+   * @type {Object<string, AudioBuffer>} A map between the name of an
+   *     audio data file and its loaded AudioBuffer.
+   * @private
+   */
   this.buffers_ = {};
 
   /**
    * The source audio nodes for queued tick / tocks for progress.
    * Kept around so they can be canceled.
    *
    * @type {Array<Array<AudioNode>>}
    * @private
    */
   this.progressSources_ = [];
 
   /** @type {number} The current gain for progress sounds. @private */
   this.progressGain_ = 1.0;
 
   /** @type {?number} The current time for progress sounds. @private */
   this.progressTime_ = this.context_.currentTime;
 
   /**
    * @type {?number} The window.setInterval ID for progress sounds.
    * @private
    */
   this.progressIntervalID_ = null;
 
   // Initialization: load the base sound data files asynchronously.
   var allSoundFilesToLoad = EarconEngine.SOUNDS.concat(EarconEngine.REVERBS);
   allSoundFilesToLoad.forEach((function(sound) {
-    var url = EarconEngine.BASE_URL + sound + '.wav';
-    this.loadSound(sound, url);
-  }).bind(this));
+                                var url =
+                                    EarconEngine.BASE_URL + sound + '.wav';
+                                this.loadSound(sound, url);
+                              }).bind(this));
 };
 
 /**
  * @type {Array<string>} The list of sound data files to load.
  * @const
  */
-EarconEngine.SOUNDS = [
-  'control',
-  'selection',
-  'selection_reverse',
-  'skim',
-  'static'];
+EarconEngine.SOUNDS =
+    ['control', 'selection', 'selection_reverse', 'skim', 'static'];
 
 /**
  * @type {Array<string>} The list of reverb data files to load.
  * @const
  */
-EarconEngine.REVERBS = [
-  'small_room_2'];
+EarconEngine.REVERBS = ['small_room_2'];
 
 /**
  * @type {number} The scale factor for one half-step.
  * @const
  */
 EarconEngine.HALF_STEP = Math.pow(2.0, 1.0 / 12.0);
 
 /**
  * @type {string} The base url for earcon sound resources.
  * @const
@@ skipping 11 matching lines @@
  * @param {string} name The name of the sound to load.
  * @param {string} url The url where the sound should be fetched from.
  */
 EarconEngine.prototype.loadSound = function(name, url) {
   var request = new XMLHttpRequest();
   request.open('GET', url, true);
   request.responseType = 'arraybuffer';
 
   // Decode asynchronously.
   request.onload = (function() {
-    this.context_.decodeAudioData(
-        /** @type {!ArrayBuffer} */ (request.response),
-        (function(buffer) {
-          this.buffers_[name] = buffer;
-        }).bind(this));
-  }).bind(this);
+                     this.context_.decodeAudioData(
+                         /** @type {!ArrayBuffer} */ (request.response),
+                         (function(buffer) {
+                           this.buffers_[name] = buffer;
+                         }).bind(this));
+                   }).bind(this);
   request.send();
 };
 
 /**
  * Return an AudioNode containing the final processing that all
  * sounds go through: master volume / gain, panning, and reverb.
  * The chain is hooked up to the destination automatically, so you
  * just need to connect your source to the return value from this
  * method.
  *
@@ skipping 76 matching lines @@
  * @return {AudioBufferSourceNode} The source node, so you can stop it
  *     or set event handlers on it.
  */
 EarconEngine.prototype.play = function(sound, opt_properties) {
   var source = this.context_.createBufferSource();
   source.buffer = this.buffers_[sound];
 
   if (!opt_properties) {
     // This typecast looks silly, but the Closure compiler doesn't support
     // optional fields in record types very well so this is the shortest hack.
-    opt_properties = /** @type {undefined} */({});
+    opt_properties = /** @type {undefined} */ ({});
   }
 
   var pitch = this.masterPitch;
   if (opt_properties.pitch) {
     pitch += opt_properties.pitch;
   }
   if (pitch != 0) {
     source.playbackRate.value = Math.pow(EarconEngine.HALF_STEP, pitch);
   }
 
@@ skipping 30 matching lines @@
 EarconEngine.prototype.onButton = function() {
   this.play('static', {gain: this.clickVolume});
   this.play(this.controlSound);
 };
 
 /**
  * Play the text field sound.
  */
 EarconEngine.prototype.onTextField = function() {
   this.play('static', {gain: this.clickVolume});
-  this.play('static', {time: this.baseDelay * 1.5,
-                       gain: this.clickVolume * 0.5});
+  this.play(
+      'static', {time: this.baseDelay * 1.5, gain: this.clickVolume * 0.5});
   this.play(this.controlSound, {pitch: 4});
-  this.play(this.controlSound,
-            {pitch: 4,
-             time: this.baseDelay * 1.5,
-             gain: 0.5});
+  this.play(
+      this.controlSound, {pitch: 4, time: this.baseDelay * 1.5, gain: 0.5});
 };
 
 /**
  * Play the pop up button sound.
  */
 EarconEngine.prototype.onPopUpButton = function() {
   this.play('static', {gain: this.clickVolume});
 
   this.play(this.controlSound);
-  this.play(this.controlSound,
-            {time: this.baseDelay * 3,
-             gain: 0.2,
-             pitch: 12});
-  this.play(this.controlSound,
-            {time: this.baseDelay * 4.5,
-             gain: 0.2,
-             pitch: 12});
+  this.play(
+      this.controlSound, {time: this.baseDelay * 3, gain: 0.2, pitch: 12});
+  this.play(
+      this.controlSound, {time: this.baseDelay * 4.5, gain: 0.2, pitch: 12});
 };
 
 /**
  * Play the check on sound.
  */
 EarconEngine.prototype.onCheckOn = function() {
   this.play('static', {gain: this.clickVolume});
   this.play(this.controlSound, {pitch: -5});
   this.play(this.controlSound, {pitch: 7, time: this.baseDelay * 2});
 };
@@ skipping 16 matching lines @@
   this.play(this.controlSound, {time: this.baseDelay});
   this.play(this.controlSound, {time: this.baseDelay * 2});
 };
 
 /**
  * Play the slider sound.
  */
 EarconEngine.prototype.onSlider = function() {
   this.play('static', {gain: this.clickVolume});
   this.play(this.controlSound);
-  this.play(this.controlSound,
-            {time: this.baseDelay,
-             gain: 0.5,
-             pitch: 2});
-  this.play(this.controlSound,
-            {time: this.baseDelay * 2,
-             gain: 0.25,
-             pitch: 4});
-  this.play(this.controlSound,
-            {time: this.baseDelay * 3,
-             gain: 0.125,
-             pitch: 6});
-  this.play(this.controlSound,
-            {time: this.baseDelay * 4,
-             gain: 0.0625,
-             pitch: 8});
+  this.play(this.controlSound, {time: this.baseDelay, gain: 0.5, pitch: 2});
+  this.play(
+      this.controlSound, {time: this.baseDelay * 2, gain: 0.25, pitch: 4});
+  this.play(
+      this.controlSound, {time: this.baseDelay * 3, gain: 0.125, pitch: 6});
+  this.play(
+      this.controlSound, {time: this.baseDelay * 4, gain: 0.0625, pitch: 8});
 };
 
 /**
  * Play the skim sound.
  */
 EarconEngine.prototype.onSkim = function() {
   this.play('skim');
 };
 
 /**
@@ skipping 57 matching lines @@
   //
   // If an end frequency is specified, do an exponential ramp to that end
   // frequency.
   var gain = properties.gain;
   for (var i = 0; i < properties.overtones; i++) {
     var osc = this.context_.createOscillator();
     osc.frequency.value = properties.freq * (i + 1);
 
     if (properties.endFreq) {
       osc.frequency.setValueAtTime(
-          properties.freq * (i + 1),
-          this.context_.currentTime + time);
+          properties.freq * (i + 1), this.context_.currentTime + time);
       osc.frequency.exponentialRampToValueAtTime(
           properties.endFreq * (i + 1),
           this.context_.currentTime + properties.dur);
     }
 
     osc.start(this.context_.currentTime + time);
     osc.stop(this.context_.currentTime + time + properties.dur);
 
     var gainNode = this.context_.createGain();
     gainNode.gain.value = gain;
     osc.connect(gainNode);
     gainNode.connect(envelopeNode);
 
     gain *= properties.overtoneFactor;
   }
 
   // Shape the overall sound by an envelope based on the attack and
   // decay times.
   envelopeNode.gain.setValueAtTime(0, this.context_.currentTime + time);
   envelopeNode.gain.linearRampToValueAtTime(
       1, this.context_.currentTime + time + properties.attack);
   envelopeNode.gain.setValueAtTime(
-          1, this.context_.currentTime + time +
-             properties.dur - properties.decay);
+      1, this.context_.currentTime + time + properties.dur - properties.decay);
   envelopeNode.gain.linearRampToValueAtTime(
       0, this.context_.currentTime + time + properties.dur);
 
   // Route everything through the common filters like reverb at the end.
   var destination = this.createCommonFilters({});
   envelopeNode.connect(destination);
 };
 
 /**
  * Play a sweep over a bunch of notes in a scale, with an echo,
@@ skipping 74 matching lines @@
 EarconEngine.prototype.onChromeVoxOff = function() {
   this.onChromeVoxSweep(true);
 };
 
 /**
  * Play an alert sound.
  */
 EarconEngine.prototype.onAlert = function() {
   var freq1 = 220 * Math.pow(EarconEngine.HALF_STEP, this.alertPitch - 2);
   var freq2 = 220 * Math.pow(EarconEngine.HALF_STEP, this.alertPitch - 3);
-  this.generateSinusoidal({attack: 0.02,
-                           decay: 0.07,
-                           dur: 0.15,
-                           gain: 0.3,
-                           freq: freq1,
-                           overtones: 3,
-                           overtoneFactor: 0.1});
-  this.generateSinusoidal({attack: 0.02,
-                           decay: 0.07,
-                           dur: 0.15,
-                           gain: 0.3,
-                           freq: freq2,
-                           overtones: 3,
-                           overtoneFactor: 0.1});
+  this.generateSinusoidal({
+    attack: 0.02,
+    decay: 0.07,
+    dur: 0.15,
+    gain: 0.3,
+    freq: freq1,
+    overtones: 3,
+    overtoneFactor: 0.1
+  });
+  this.generateSinusoidal({
+    attack: 0.02,
+    decay: 0.07,
+    dur: 0.15,
+    gain: 0.3,
+    freq: freq2,
+    overtones: 3,
+    overtoneFactor: 0.1
+  });
 };
 
 /**
  * Play a wrap sound.
  */
 EarconEngine.prototype.onWrap = function() {
   this.play('static', {gain: this.clickVolume * 0.3});
   var freq1 = 220 * Math.pow(EarconEngine.HALF_STEP, this.wrapPitch - 8);
   var freq2 = 220 * Math.pow(EarconEngine.HALF_STEP, this.wrapPitch + 8);
-  this.generateSinusoidal({attack: 0.01,
-                           decay: 0.1,
-                           dur: 0.15,
-                           gain: 0.3,
-                           freq: freq1,
-                           endFreq: freq2,
-                           overtones: 1,
-                           overtoneFactor: 0.1});
+  this.generateSinusoidal({
+    attack: 0.01,
+    decay: 0.1,
+    dur: 0.15,
+    gain: 0.3,
+    freq: freq1,
+    endFreq: freq2,
+    overtones: 1,
+    overtoneFactor: 0.1
+  });
 };
 
 /**
  * Queue up a few tick/tock sounds for a progress bar. This is called
  * repeatedly by setInterval to keep the sounds going continuously.
  * @private
  */
 EarconEngine.prototype.generateProgressTickTocks_ = function() {
   while (this.progressTime_ < this.context_.currentTime + 3.0) {
     var t = this.progressTime_ - this.context_.currentTime;
-    this.progressSources_.push(
-        [this.progressTime_,
-         this.play('static',
-                   {gain: 0.5 * this.progressGain_,
-                    time: t})]);
-    this.progressSources_.push(
-        [this.progressTime_,
-         this.play(this.controlSound,
-                   {pitch: 20,
-                    time: t,
-                    gain: this.progressGain_})]);
+    this.progressSources_.push([
+      this.progressTime_,
+      this.play('static', {gain: 0.5 * this.progressGain_, time: t})
+    ]);
+    this.progressSources_.push([
+      this.progressTime_,
+      this.play(
+          this.controlSound, {pitch: 20, time: t, gain: this.progressGain_})
+    ]);
 
     if (this.progressGain_ > this.progressFinalGain) {
       this.progressGain_ *= this.progressGain_Decay;
     }
     t += 0.5;
 
-    this.progressSources_.push(
-        [this.progressTime_,
-         this.play('static',
-                   {gain: 0.5 * this.progressGain_,
-                    time: t})]);
-    this.progressSources_.push(
-        [this.progressTime_,
-         this.play(this.controlSound,
-                   {pitch: 8,
-                    time: t,
-                    gain: this.progressGain_})]);
+    this.progressSources_.push([
+      this.progressTime_,
+      this.play('static', {gain: 0.5 * this.progressGain_, time: t})
+    ]);
+    this.progressSources_.push([
+      this.progressTime_,
+      this.play(
+          this.controlSound, {pitch: 8, time: t, gain: this.progressGain_})
+    ]);
 
     if (this.progressGain_ > this.progressFinalGain) {
       this.progressGain_ *= this.progressGain_Decay;
     }
 
     this.progressTime_ += 1.0;
   }
 
   var removeCount = 0;
   while (removeCount < this.progressSources_.length &&
-      this.progressSources_[removeCount][0] < this.context_.currentTime - 0.2) {
+         this.progressSources_[removeCount][0] <
+             this.context_.currentTime - 0.2) {
     removeCount++;
   }
   this.progressSources_.splice(0, removeCount);
 };
 
 /**
  * Start playing tick / tock progress sounds continuously until
  * explicitly canceled.
  */
 EarconEngine.prototype.startProgress = function() {
   if (this.progressIntervalID_) {
     this.cancelProgress();
   }
 
   this.progressSources_ = [];
   this.progressGain_ = 0.5;
   this.progressTime_ = this.context_.currentTime;
   this.generateProgressTickTocks_();
-  this.progressIntervalID_ = window.setInterval(
-      this.generateProgressTickTocks_.bind(this), 1000);
+  this.progressIntervalID_ =
+      window.setInterval(this.generateProgressTickTocks_.bind(this), 1000);
 };
 
 /**
  * Stop playing any tick / tock progress sounds.
  */
 EarconEngine.prototype.cancelProgress = function() {
   if (!this.progressIntervalID_) {
     return;
   }
 
@@ skipping 16 matching lines @@
 
   // Clamp.
   x = Math.min(Math.max(x, 0.0), 1.0);
 
   // Map to between the negative maximum pan x position and the positive max x
   // pan position.
   x = (2 * x - 1) * EarconEngine.MAX_PAN_ABS_X_POSITION;
 
   this.masterPan = x;
 };