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.
+    chrome.runtime.onStartup.addListener(this.startupListener_);

[Matt Giuca, 2015/05/15 06:54:42]

Why not just not remove it if it hasn't been added?

if (chrome.runtime.onStartup.hasListener(this.startupListener_))
  chrome.runtime.onStartup.removeListener(this.startupListener_);

[Anand Mistry (off Chromium), 2015/05/15 07:08:36]

Ah, undocumented and poorly understood behaviour of extension API events. Even
if there's no listener registered from the JS perspective, there could still be
a wake-up listener registered to re-start the event page. If order to clear
that, you first need to add one. Then when you remove it, JS sees the refcount
go to 0 and remove the wake-up event. So this forces one to be added so that the
JS part of the API implementation does the right thing. This pattern is used
heavily in this extension since it it's the only way to achieve deterministic
results.

[Matt Giuca, 2015/05/15 08:32:43]

Gross :(

Could you explain that a bit in the comment (otherwise it just begs the
question: "why not just check if it's removed?")

(Not the whole thing, but just enough to let readers know that there could be
one registered even if you can't see it.)

[Anand Mistry (off Chromium), 2015/05/18 01:24:22]

Done.

   }
 
   /**
    * @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
   };
 });