Add UMA to hotword trigger extension.

chrome/browser/resources/hotword/nacl_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';
 
 /**
  * Class used to manage the state of the NaCl recognizer plugin. Handles all
  * control of the NaCl plugin, including creation, start, stop, trigger, and
@@ skipping 59 matching lines @@
   LOADING: 1,
   STOPPING: 2,
   STOPPED: 3,
   STARTING: 4,
   RUNNING: 5,
   ERROR: 6,
   SHUTDOWN: 7,
 };
 var ManagerState_ = NaClManager.ManagerState_;
 var Error_ = hotword.constants.Error;
+var UmaNaClMessageTimeout_ = hotword.constants.UmaNaClMessageTimeout;
+var UmaNaClPluginLoadResult_ = hotword.constants.UmaNaClPluginLoadResult;
 
 NaClManager.prototype.__proto__ = cr.EventTarget.prototype;
 
 /**
  * Called when an error occurs. Dispatches an event.
  * @param {!hotword.constants.Error} error
  * @private
  */
 NaClManager.prototype.handleError_ = function(error) {
   event = new Event(hotword.constants.Event.ERROR);
   event.data = error;
   this.dispatchEvent(event);
 };
 
 /**
+ * Record the result of loading the NaCl plugin to UMA.
+ * @param {!hotword.constants.UmaNaClPluginLoadResult} error
+ * @private
+ */
+NaClManager.prototype.logPluginLoadResult_ = function(error) {
+  hotword.metrics.recordEnum(
+      hotword.constants.UmaMetrics.NACL_PLUGIN_LOAD_RESULT,
+      error,
+      UmaNaClPluginLoadResult_.MAX);
+};
+
+/**
  * @return {boolean} True if the recognizer is in a running state.
  */
 NaClManager.prototype.isRunning = function() {
   return this.recognizerState_ == ManagerState_.RUNNING;
 };
 
 /**
  * Set a timeout. Only allow one timeout to exist at any given time.
  * @param {!function()} func
  * @param {number} timeout
@@ skipping 138 matching lines @@
     }
     this.modelUrl_ = chrome.extension.getURL(dataSrc);
     this.stream_ = stream;
     this.recognizerState_ = ManagerState_.LOADING;
 
     plugin.addEventListener('message',
                             this.handlePluginMessage_.bind(this),
                             false);
 
     plugin.addEventListener('crash',
-                            this.handleError_.bind(this, Error_.NACL_CRASH),
+                            function() {
+                              this.handleError_(Error_.NACL_CRASH);
+                              this.logPluginLoadResult_(
+                                  UmaNaClPluginLoadResult_.CRASH);
+                            }.bind(this),
                             false);
     return true;
   }
   this.recognizerState_ = ManagerState_.ERROR;
+  this.logPluginLoadResult_(UmaNaClPluginLoadResult_.NO_MODULE_FOUND);
   return false;
 };
 
 /**
  * Shuts down the NaCl plugin and frees all resources.
  */
 NaClManager.prototype.shutdown = function() {
   if (this.plugin_ != null) {
     document.body.removeChild(this.plugin_);
     this.plugin_ = null;
@@ skipping 22 matching lines @@
  * @param {!string} message Message to wait for.
  * @private
  */
 NaClManager.prototype.waitForMessage_ = function(timeout, message) {
   assert(this.expectingMessage_ == null,
          'Already waiting for message ' + this.expectingMessage_);
   this.setTimeout_(
       function() {
         this.recognizerState_ = ManagerState_.ERROR;
         this.handleError_(Error_.TIMEOUT);
+        this.logPluginLoadResult_(UmaNaClPluginLoadResult_.MESSAGE_TIMEOUT);
+        switch (this.expectingMessage_) {
+          case hotword.constants.NaClPlugin.REQUEST_MODEL:
+            var metricValue = UmaNaClMessageTimeout_.REQUEST_MODEL;
+            break;
+          case hotword.constants.NaClPlugin.MODEL_LOADED:
+            var metricValue = UmaNaClMessageTimeout_.MODEL_LOADED;
+            break;
+          case hotword.constants.NaClPlugin.READY_FOR_AUDIO:
+            var metricValue = UmaNaClMessageTimeout_.READY_FOR_AUDIO;
+            break;
+          case hotword.constants.NaClPlugin.STOPPED:
+            var metricValue = UmaNaClMessageTimeout_.STOPPED;
+            break;
+          case hotword.constants.NaClPlugin.HOTWORD_DETECTED:
+            var metricValue = UmaNaClMessageTimeout_.HOTWORD_DETECTED;
+            break;
+          case hotword.constants.NaClPlugin.MS_CONFIGURED:
+            var metricValue = UmaNaClMessageTimeout_.MS_CONFIGURED;
+            break;
+        }
+        hotword.metrics.recordEnum(
+            hotword.constants.UmaMetrics.NACL_MESSAGE_TIMEOUT,
+            metricValue,

[rpetterson, 2014/10/23 19:03:36]

Perhaps success should simply be one of the cases here?

[Anand Mistry (off Chromium), 2014/10/23 21:38:16]

I don't understand. I don't think we want to track successes for this metric
since I don't think it would be a useful denominator.

+            UmaNaClMessageTimeout_.MAX);
       }.bind(this), timeout);
   this.expectingMessage_ = message;
 };
 
 /**
  * Called when a message is received from the plugin. If we're waiting for that
  * message, cancel the pending timeout.
  * @param {string} message Message received.
  * @private
  */
 NaClManager.prototype.receivedMessage_ = function(message) {
   if (message == this.expectingMessage_) {
     this.clearTimeout_();
     this.expectingMessage_ = null;
   }
 };
 
 /**
  * Handle a REQUEST_MODEL message from the plugin.
  * The plugin sends this message immediately after starting.
  * @private
  */
 NaClManager.prototype.handleRequestModel_ = function() {
   if (this.recognizerState_ != ManagerState_.LOADING) {
     return;
   }
+  this.logPluginLoadResult_(UmaNaClPluginLoadResult_.SUCCESS);
   this.sendDataToPlugin_(
       hotword.constants.NaClPlugin.MODEL_PREFIX + this.modelUrl_);
   this.waitForMessage_(hotword.constants.TimeoutMs.LONG,
                        hotword.constants.NaClPlugin.MODEL_LOADED);
 };
 
 /**
  * Handle a MODEL_LOADED message from the plugin.
  * The plugin sends this message after successfully loading the language model.
  * @private
@@ skipping 93 matching lines @@
         break;
     }
   }
 };
 
 return {
   NaClManager: NaClManager
 };
 
 });