Run tools/clang-format-js on chrome/browser/resources/hotword/

chrome/browser/resources/hotword/state_manager.js

 // Copyright 2014 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.
 
 cr.define('hotword', function() {
   'use strict';
 
   /**
    * Trivial container class for session information.
    * @param {!hotword.constants.SessionSource} source Source of the hotword
    *     session.
    * @param {!function()} triggerCb Callback invoked when the hotword has
    *     triggered.
    * @param {!function()} startedCb Callback invoked when the session has
    *     been started successfully.
    * @param {function()=} opt_modelSavedCb Callback invoked when the speaker
    *     model has been saved successfully.
    * @constructor
    * @struct
    * @private
    */
   function Session_(source, triggerCb, startedCb, opt_modelSavedCb) {
     /**
      * Source of the hotword session request.
      * @private {!hotword.constants.SessionSource}
      */
     this.source_ = source;
 
-     /**
-      * Callback invoked when the hotword has triggered.
-      * @private {!function()}
-      */
+    /**
+     * Callback invoked when the hotword has triggered.
+     * @private {!function()}
+     */
     this.triggerCb_ = triggerCb;
 
     /**
      * Callback invoked when the session has been started successfully.
      * @private {?function()}
      */
     this.startedCb_ = startedCb;
 
     /**
      * Callback invoked when the session has been started successfully.
@@ skipping 43 matching lines @@
      * Event that fires when the hotwording status has changed.
      * @type {!ChromeEvent}
      */
     this.onStatusChanged = new chrome.Event();
 
     /**
      * Hotword trigger audio notification... a.k.a The Chime (tm).
      * @private {!HTMLAudioElement}
      */
     this.chime_ =
-        /** @type {!HTMLAudioElement} */(document.createElement('audio'));
+        /** @type {!HTMLAudioElement} */ (document.createElement('audio'));
 
     /**
      * Chrome event listeners. Saved so that they can be de-registered when
      * hotwording is disabled.
      * @private
      */
     this.idleStateChangedListener_ = this.handleIdleStateChanged_.bind(this);
     this.startupListener_ = this.handleStartup_.bind(this);
 
     /**
@@ skipping 102 matching lines @@
      * hotwordPrivate.onEnabledChanged() event.
      */
     updateStatus: function() {
       chrome.hotwordPrivate.getStatus(this.handleStatus_.bind(this));
     },
 
     /**
      * @return {boolean} True if google.com/NTP/launcher hotwording is enabled.
      */
     isSometimesOnEnabled: function() {
-      assert(this.hotwordStatus_,
-             'No hotwording status (isSometimesOnEnabled)');
+      assert(
+          this.hotwordStatus_, 'No hotwording status (isSometimesOnEnabled)');
       // Although the two settings are supposed to be mutually exclusive, it's
       // possible for both to be set. In that case, always-on takes precedence.
       return this.hotwordStatus_.enabled &&
           !this.hotwordStatus_.alwaysOnEnabled;
     },
 
     /**
      * @return {boolean} True if always-on hotwording is enabled.
      */
     isAlwaysOnEnabled: function() {
@@ skipping 25 matching lines @@
     },
 
     /**
      * Updates state based on the current status.
      * @private
      */
     updateStateFromStatus_: function() {
       if (!this.hotwordStatus_)
         return;
 
-      if (this.hotwordStatus_.enabled ||
-          this.hotwordStatus_.alwaysOnEnabled ||
+      if (this.hotwordStatus_.enabled || this.hotwordStatus_.alwaysOnEnabled ||
           this.hotwordStatus_.trainingEnabled) {
         // Detect changes to audio logging and kill the detector if that setting
         // has changed.
         if (this.hotwordStatus_.audioLoggingEnabled != this.loggingEnabled_)
           this.shutdownDetector_();
         this.loggingEnabled_ = this.hotwordStatus_.audioLoggingEnabled;
 
         // If the training state has changed, we need to first shut down the
         // detector so that we can restart in a different mode.
         if (this.hotwordStatus_.trainingEnabled != this.trainingEnabled_)
@@ skipping 37 matching lines @@
       // Last attempt to start detector resulted in an error.
       if (this.state_ == State_.ERROR) {
         // TODO(amistry): Do some error rate tracking here and disable the
         // extension if we error too often.
       }
 
       if (!this.pluginManager_) {
         this.state_ = State_.STARTING;
         var isHotwordStream = this.isAlwaysOnEnabled() &&
             this.hotwordStatus_.hotwordHardwareAvailable;
-        this.pluginManager_ = new hotword.NaClManager(this.loggingEnabled_,
-                                                      isHotwordStream);
-        this.pluginManager_.addEventListener(hotword.constants.Event.READY,
-                                             this.onReady_.bind(this));
-        this.pluginManager_.addEventListener(hotword.constants.Event.ERROR,
-                                             this.onError_.bind(this));
-        this.pluginManager_.addEventListener(hotword.constants.Event.TRIGGER,
-                                             this.onTrigger_.bind(this));
-        this.pluginManager_.addEventListener(hotword.constants.Event.TIMEOUT,
-                                             this.onTimeout_.bind(this));
+        this.pluginManager_ =
+            new hotword.NaClManager(this.loggingEnabled_, isHotwordStream);
+        this.pluginManager_.addEventListener(
+            hotword.constants.Event.READY, this.onReady_.bind(this));
+        this.pluginManager_.addEventListener(
+            hotword.constants.Event.ERROR, this.onError_.bind(this));
+        this.pluginManager_.addEventListener(
+            hotword.constants.Event.TRIGGER, this.onTrigger_.bind(this));
+        this.pluginManager_.addEventListener(
+            hotword.constants.Event.TIMEOUT, this.onTimeout_.bind(this));
         this.pluginManager_.addEventListener(
             hotword.constants.Event.SPEAKER_MODEL_SAVED,
             this.onSpeakerModelSaved_.bind(this));
         chrome.runtime.getPlatformInfo(function(platform) {
           var naclArch = platform.nacl_arch;
 
           // googDucking set to false so that audio output level from other tabs
           // is not affected when hotword is enabled. https://crbug.com/357773
           // content/common/media/media_stream_options.cc
           // When always-on is enabled, request the hotword stream.
           // Optional because we allow power users to bypass the hardware
           // detection via a flag, and hence the hotword stream may not be
           // available.
           var constraints = /** @type {googMediaStreamConstraints} */
-              ({audio: {optional: [
-                { googDucking: false },
-                { googHotword: this.isAlwaysOnEnabled() }
-              ]}});
+              ({
+                audio: {
+                  optional: [
+                    {googDucking: false},
+                    {googHotword: this.isAlwaysOnEnabled()}
+                  ]
+                }
+              });
           navigator.webkitGetUserMedia(
               /** @type {MediaStreamConstraints} */ (constraints),
               function(stream) {
                 hotword.metrics.recordEnum(
                     hotword.constants.UmaMetrics.MEDIA_STREAM_RESULT,
                     hotword.constants.UmaMediaStreamOpenResult.SUCCESS,
                     hotword.constants.UmaMediaStreamOpenResult.MAX);
                 // The detector could have been shut down before the stream
                 // finishes opening.
                 if (this.pluginManager_ == null) {
@@ skipping 82 matching lines @@
     shutdownDetector_: function() {
       this.state_ = State_.STOPPED;
       this.shutdownPluginManager_();
     },
 
     /**
      * Finalizes the speaker model. Assumes the plugin has been loaded and
      * started.
      */
     finalizeSpeakerModel: function() {
-      assert(this.pluginManager_,
-             'Cannot finalize speaker model: No NaCl plugin loaded');
+      assert(
+          this.pluginManager_,
+          'Cannot finalize speaker model: No NaCl plugin loaded');
       if (this.state_ != State_.RUNNING) {
         hotword.debug('Cannot finalize speaker model: NaCl plugin not started');
         return;
       }
       this.pluginManager_.finalizeSpeakerModel();
     },
 
     /**
      * Handle the hotword plugin being ready to start.
      * @private
@@ skipping 103 matching lines @@
      * @param {!hotword.constants.SessionSource} source Source of the hotword
      *     session request.
      * @param {!function()} startedCb Callback invoked when the session has
      *     been started successfully.
      * @param {!function()} triggerCb Callback invoked when the hotword has
      * @param {function()=} modelSavedCb Callback invoked when the speaker model
      *     has been saved.
      * @param {hotword.constants.RecognizerStartMode=} opt_mode The mode to
      *     start the recognizer in.
      */
-    startSession: function(source, startedCb, triggerCb,
-                           opt_modelSavedCb, opt_mode) {
+    startSession: function(
+        source, startedCb, triggerCb, opt_modelSavedCb, opt_mode) {
       if (this.isTrainingEnabled() && opt_mode) {
         this.startMode_ = opt_mode;
       } else {
         this.startMode_ = hotword.constants.RecognizerStartMode.NORMAL;
       }
       hotword.debug('Starting session for source: ' + source);
       this.removeSession_(source);
-      this.sessions_.push(new Session_(source, triggerCb, startedCb,
-                                       opt_modelSavedCb));
+      this.sessions_.push(
+          new Session_(source, triggerCb, startedCb, opt_modelSavedCb));
       this.updateStateFromStatus_();
     },
 
     /**
      * Stops a hotwording session.
      * @param {!hotword.constants.SessionSource} source Source of the hotword
      *     session request.
      */
     stopSession: function(source) {
       hotword.debug('Stopping session for source: ' + source);
@@ skipping 25 matching lines @@
     /**
      * Handles a chrome.runtime.onStartup event.
      * @private
      */
     handleStartup_: function() {
       // Nothing specific needs to be done here. This function exists solely to
       // be registered on the startup event.
     }
   };
 
-  return {
-    StateManager: StateManager
-  };
+  return {StateManager: StateManager};
 });