Cards Clicked Metrics

chrome/browser/resources/google_now/background.js

 // Copyright (c) 2013 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.
 
 'use strict';
 
 /**
  * @fileoverview The event page for Google Now for Chrome implementation.
  * The Google Now event page gets Google Now cards from the server and shows
  * them as Chrome notifications.
@@ skipping 216 matching lines @@
   DELETED_SHOW_WELCOME_TOAST: 8,
   STOPPED: 9,
   DELETED_USER_SUPPRESSED: 10,
   SIGNED_OUT: 11,
   NOTIFICATION_DISABLED: 12,
   GOOGLE_NOW_DISABLED: 13,
   EVENTS_TOTAL: 14  // EVENTS_TOTAL is not an event; all new events need to be
                     // added before it.
 };
 
+// CARD_TYPES_TOTAL is the maximum histogram value and card type value.
+var CARD_TYPES_TOTAL = 300;

[Ilya Sherman, 2014/03/26 00:32:50]

Hmm, can you use a sparse histogram rather than allocating memory for 300
buckets, most of which will probably be empty?

[robliao, 2014/03/26 00:42:53]

Got docs on how to do this? I only see histogram-log and histogram-linear as
options. 

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/common/exte...
On 2014/03/26 00:32:50, Ilya Sherman wrote:

[Ilya Sherman, 2014/03/26 03:55:41]

You might need to expand the metricsPrivate API to support this -- I'm not very
familiar with what all this API supports.  In C++ code, the macro to call is
UMA_HISTOGRAM_SPARSE_SLOWLY.

On 2014/03/26 00:42:53, robliao wrote:

[robliao, 2014/03/27 00:51:51]

Done. https://codereview.chromium.org/213433003/
On 2014/03/26 03:55:41, Ilya Sherman wrote:

+
 /**
  * Records a Google Now Event.
  * @param {GoogleNowEvent} event Event identifier.
  */
 function recordEvent(event) {
   var metricDescription = {
     metricName: 'GoogleNow.Event',
     type: 'histogram-linear',
     min: 1,
     max: GoogleNowEvent.EVENTS_TOTAL,
     buckets: GoogleNowEvent.EVENTS_TOTAL + 1
   };
 
   chrome.metricsPrivate.recordValue(metricDescription, event);
 }
 
 /**
+ * Records a notification clicked event.
+ * @param {number|undefined} cardTypeId Card type ID.
+ */
+function recordNotificationClick(cardTypeId) {
+  if (cardTypeId !== undefined) {
+    var metricDescription = {
+      metricName: 'GoogleNow.Card.Clicked',
+      type: 'histogram-linear',
+      min: 1,
+      max: CARD_TYPES_TOTAL,
+      buckets: CARD_TYPES_TOTAL + 1
+    };
+    chrome.metricsPrivate.recordValue(metricDescription, cardTypeId);
+  }
+}
+
+/**
+ * Records a button clicked event.
+ * @param {number|undefined} cardTypeId Card type ID.
+ * @param {number} buttonIndex Button Index
+ */
+function recordButtonClick(cardTypeId, buttonIndex) {
+  if (cardTypeId !== undefined) {
+    var metricDescription = {
+      metricName: 'GoogleNow.Card.Button.Clicked' + buttonIndex,
+      type: 'histogram-linear',
+      min: 1,
+      max: CARD_TYPES_TOTAL,
+      buckets: CARD_TYPES_TOTAL + 1
+    };
+    chrome.metricsPrivate.recordValue(metricDescription, cardTypeId);
+  }
+}
+
+/**
  * Checks the result of the HTTP Request and updates the authentication
  * manager on any failure.
  * @param {string} token Authentication token to validate against an
  *     XMLHttpRequest.
  * @return {function(XMLHttpRequest)} Function that validates the token with the
  *     supplied XMLHttpRequest.
  */
 function checkAuthenticationStatus(token) {
   return function(request) {
     if (request.status == HTTP_FORBIDDEN ||
@@ skipping 532 matching lines @@
       chrome.windows.update(tab.windowId, {focused: true});
     else
       chrome.windows.create({url: url, focused: true});
   });
 }
 
 /**
  * Opens URL corresponding to the clicked part of the notification.
  * @param {ChromeNotificationId} chromeNotificationId chrome.notifications ID of
  *     the card.
- * @param {function((ActionUrls|undefined)): (string|undefined)} selector
- *     Function that extracts the url for the clicked area from the button
- *     action URLs info.
+ * @param {function(NotificationDataEntry): (string|undefined)} selector
+ *     Function that extracts the url for the clicked area from the
+ *     notification data entry.
  */
 function onNotificationClicked(chromeNotificationId, selector) {
   fillFromChromeLocalStorage({
     /** @type {Object.<string, NotificationDataEntry>} */
     notificationsData: {}
   }).then(function(items) {
     /** @type {(NotificationDataEntry|undefined)} */
-    var notificationData = items.notificationsData[chromeNotificationId];
-    if (!notificationData)
+    var notificationDataEntry = items.notificationsData[chromeNotificationId];
+    if (!notificationDataEntry)
       return;
 
-    var url = selector(notificationData.actionUrls);
+    var url = selector(notificationDataEntry);
     if (!url)
       return;
 
     openUrl(url);
   });
 }
 
 /**
  * Callback for chrome.notifications.onClosed event.
  * @param {ChromeNotificationId} chromeNotificationId chrome.notifications ID of
@@ skipping 272 matching lines @@
 });
 
 authenticationManager.addListener(function() {
   console.log('signIn State Change');
   onStateChange();
 });
 
 instrumented.notifications.onClicked.addListener(
     function(chromeNotificationId) {
       chrome.metricsPrivate.recordUserAction('GoogleNow.MessageClicked');
-      onNotificationClicked(chromeNotificationId, function(actionUrls) {
-        return actionUrls && actionUrls.messageUrl;
-      });
-    });
+      onNotificationClicked(chromeNotificationId,
+          function(notificationDataEntry) {
+            var actionUrls = notificationDataEntry.actionUrls;
+            var url = actionUrls && actionUrls.messageUrl;
+            if (url) {
+              recordNotificationClick(notificationDataEntry.cardTypeId);
+            }
+            return url;
+          });
+        });
 
 instrumented.notifications.onButtonClicked.addListener(
     function(chromeNotificationId, buttonIndex) {
       chrome.metricsPrivate.recordUserAction(
           'GoogleNow.ButtonClicked' + buttonIndex);
-      onNotificationClicked(chromeNotificationId, function(actionUrls) {
-        var url = actionUrls.buttonUrls[buttonIndex];
-        verify(url !== undefined, 'onButtonClicked: no url for a button');
-        return url;
-      });
-    });
+      onNotificationClicked(chromeNotificationId,
+          function(notificationDataEntry) {
+            var actionUrls = notificationDataEntry.actionUrls;
+            var url = actionUrls.buttonUrls[buttonIndex];
+            if (url) {
+              recordButtonClick(notificationDataEntry.cardTypeId, buttonIndex);
+            } else {
+              verify(false, 'onButtonClicked: no url for a button');
+            }
+            return url;
+          });
+        });
 
 instrumented.notifications.onClosed.addListener(onNotificationClosed);
 
 instrumented.notifications.onPermissionLevelChanged.addListener(
     function(permissionLevel) {
       console.log('Notifications permissionLevel Change');
       onStateChange();
     });
 
 instrumented.notifications.onShowSettings.addListener(function() {
@@ skipping 28 matching lines @@
             lastPollNowPayloads: items.lastPollNowPayloads,
             notificationGroups: items.notificationGroups
           });
 
           requestCards();
         }
       });
     });
   }
 });