Don't start the hotword extension on Chrome startup if the user doesn't have hotwording enabled.

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
@@ skipping 83 matching lines @@
      */
     this.chime_ =
         /** @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);
 
     /**
      * Whether this user is locked.
      * @private {boolean}
      */
     this.isLocked_ = false;
 
     /**
      * Current state of audio logging.
      * This is tracked separately from hotwordStatus_ because we need to restart
@@ skipping 20 matching lines @@
     // Get the initial status.
     chrome.hotwordPrivate.getStatus(this.handleStatus_.bind(this));
 
     // Setup the chime and insert into the page.
     // Set preload=none to prevent an audio output stream from being created
     // when the extension loads.
     this.chime_.preload = 'none';
     this.chime_.src = chrome.extension.getURL(
         hotword.constants.SHARED_MODULE_ROOT + '/audio/chime.wav');
     document.body.appendChild(this.chime_);
+
+    // In order to remove this listener, it must first be added. This handles
+    // the case on first Chrome startup where this event is never registered,
+    // so can't be removed when it's determined that hotwording is disabled.
+    // Why not only remove the listener if it exists? Extension API events have
+    // two parts to them, the Javascript listeners, and a browser-side component
+    // that wakes up the extension if it's an event page. The browser-side
+    // wake-up event is only removed when the number of javascript listeners
+    // becomes 0. To clear the browser wake-up event, a listener first needs to
+    // be added, then removed in order to drop the count to 0 and remove the
+    // event.
+    chrome.runtime.onStartup.addListener(this.startupListener_);
   }
 
   /**
    * @enum {number}
    * @private
    */
   StateManager.State_ = {
     STOPPED: 0,
     STARTING: 1,
     RUNNING: 2,
@@ skipping 118 matching lines @@
           this.startDetector_();
         } else {
           this.shutdownDetector_();
         }
 
         if (!chrome.idle.onStateChanged.hasListener(
                 this.idleStateChangedListener_)) {
           chrome.idle.onStateChanged.addListener(
               this.idleStateChangedListener_);
         }
+        if (!chrome.runtime.onStartup.hasListener(this.startupListener_))
+          chrome.runtime.onStartup.addListener(this.startupListener_);
       } else {
         // Not enabled. Shut down if running.
         this.shutdownDetector_();
 
         chrome.idle.onStateChanged.removeListener(
             this.idleStateChangedListener_);
+        // If hotwording isn't enabled, don't start this component extension on
+        // Chrome startup. If a user enables hotwording, the status change
+        // event will be fired and the onStartup event will be registered.
+        chrome.runtime.onStartup.removeListener(this.startupListener_);
       }
     },
 
     /**
      * Starts the hotword detector.
      * @private
      */
     startDetector_: function() {
       // Last attempt to start detector resulted in an error.
       if (this.state_ == State_.ERROR) {
@@ skipping 297 matching lines @@
     handleIdleStateChanged_: function(state) {
       hotword.debug('Idle state changed: ' + state);
       var oldLocked = this.isLocked_;
       if (state == 'locked')
         this.isLocked_ = true;
       else
         this.isLocked_ = false;
 
       if (oldLocked != this.isLocked_)
         this.updateStateFromStatus_();
+    },
+
+    /**
+     * Handles a chrome.runtime.onStartup event.
+     * @private
+     */
+    handleStartup_: function() {
+      updateStatus();
     }
   };
 
   return {
     StateManager: StateManager
   };
 });