[Media Router] Add UMA histograms tracking component extension version/wakeups

chrome/browser/media/router/media_router_metrics.cc

 // Copyright 2015 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.
 
 #include "chrome/browser/media/router/media_router_metrics.h"
 
+#include <limits.h>
+
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/version.h"
+#include "components/version_info/version_info.h"
+#include "extensions/common/extension.h"
 
 namespace media_router {
 
 // static
 void MediaRouterMetrics::RecordMediaRouterDialogOrigin(
     MediaRouterDialogOpenOrigin origin) {
-  DCHECK_NE(static_cast<int>(origin),
+  DCHECK_LT(static_cast<int>(origin),
             static_cast<int>(MediaRouterDialogOpenOrigin::TOTAL_COUNT));
   UMA_HISTOGRAM_ENUMERATION(
       "MediaRouter.Icon.Click.Location", static_cast<int>(origin),
       static_cast<int>(MediaRouterDialogOpenOrigin::TOTAL_COUNT));
 }
 
 // static
 void MediaRouterMetrics::RecordMediaRouteProviderWakeReason(
     MediaRouteProviderWakeReason reason) {
-  DCHECK_NE(static_cast<int>(reason),
+  DCHECK_LT(static_cast<int>(reason),
             static_cast<int>(MediaRouteProviderWakeReason::TOTAL_COUNT));
   UMA_HISTOGRAM_ENUMERATION(
       "MediaRouter.Provider.WakeReason", static_cast<int>(reason),
       static_cast<int>(MediaRouteProviderWakeReason::TOTAL_COUNT));
 }
 
 // static
 void MediaRouterMetrics::RecordMediaRouterDialogPaint(
     const base::TimeDelta delta) {
   UMA_HISTOGRAM_TIMES("MediaRouter.Ui.Dialog.Paint",
                       delta);
 }
 
 // static
 void MediaRouterMetrics::RecordMediaRouterDialogLoaded(
     const base::TimeDelta delta) {
   UMA_HISTOGRAM_TIMES("MediaRouter.Ui.Dialog.LoadedWithData",
                       delta);
 }
 
 // static
 void MediaRouterMetrics::RecordMediaRouterInitialUserAction(
     MediaRouterUserAction action) {
-  DCHECK_NE(static_cast<int>(action),
+  DCHECK_LT(static_cast<int>(action),
             static_cast<int>(MediaRouterUserAction::TOTAL_COUNT));
   UMA_HISTOGRAM_ENUMERATION(
       "MediaRouter.Ui.FirstAction", static_cast<int>(action),
       static_cast<int>(MediaRouterUserAction::TOTAL_COUNT));
 }
 
 // static
 void MediaRouterMetrics::RecordRouteCreationOutcome(
     MediaRouterRouteCreationOutcome outcome) {
-  DCHECK_NE(static_cast<int>(outcome),
-            static_cast<int>(
-                MediaRouterRouteCreationOutcome::TOTAL_COUNT));
+  DCHECK_LT(static_cast<int>(outcome),
+            static_cast<int>(MediaRouterRouteCreationOutcome::TOTAL_COUNT));
   UMA_HISTOGRAM_ENUMERATION(
     "MediaRouter.Route.CreationOutcome", static_cast<int>(outcome),
     static_cast<int>(MediaRouterRouteCreationOutcome::TOTAL_COUNT));
 }
 
+// static
+void MediaRouterMetrics::RecordMediaRouteProviderVersion(
+    const extensions::Extension& extension) {
+  const base::Version* extension_version = extension.version();
+  if (!extension_version) {
+    MediaRouterMetrics::RecordMediaRouteProviderVersion(
+        MediaRouteProviderVersion::UNKNOWN);
+    return;
+  }
+
+  base::Version browser_version(version_info::GetVersionNumber());
+  int version_difference =
+      GetVersionDifference(*extension_version, browser_version);
+  if (version_difference == std::numeric_limits<int>::min()) {
+    // Extension installed, version is invalid.
+    MediaRouterMetrics::RecordMediaRouteProviderVersion(
+        MediaRouteProviderVersion::UNKNOWN);
+  } else if (version_difference >= 0) {
+    MediaRouterMetrics::RecordMediaRouteProviderVersion(
+        MediaRouteProviderVersion::SAME_VERSION_AS_CHROME);
+  } else if (version_difference == -1) {
+    MediaRouterMetrics::RecordMediaRouteProviderVersion(
+        MediaRouteProviderVersion::ONE_VERSION_BEHIND_CHROME);
+  } else {
+    MediaRouterMetrics::RecordMediaRouteProviderVersion(
+        MediaRouteProviderVersion::MULTIPLE_VERSIONS_BEHIND_CHROME);
+  }
+}
+
+// static
+void MediaRouterMetrics::RecordMediaRouteProviderVersion(
+    MediaRouteProviderVersion version) {
+  DCHECK_LT(static_cast<int>(version),
+            static_cast<int>(MediaRouteProviderVersion::TOTAL_COUNT));
+  UMA_HISTOGRAM_ENUMERATION(
+      "MediaRouter.Provider.Version", static_cast<int>(version),
+      static_cast<int>(MediaRouteProviderVersion::TOTAL_COUNT));
+}
+
+// static
+void MediaRouterMetrics::RecordMediaRouteProviderWakeup(
+    MediaRouteProviderWakeup wakeup) {
+  DCHECK_LT(static_cast<int>(wakeup),
+            static_cast<int>(MediaRouteProviderWakeup::TOTAL_COUNT));
+  UMA_HISTOGRAM_ENUMERATION(
+      "MediaRouter.Provider.Wakeup", static_cast<int>(wakeup),
+      static_cast<int>(MediaRouteProviderWakeup::TOTAL_COUNT));
+}
+
+// static
+int MediaRouterMetrics::GetVersionDifference(const base::Version& first,
+                                             const base::Version& second) {

[Wez, 2016/03/18 18:35:43]

nit: Since we don't need the actual version difference, you could move the
difference->enum logic in to this version and avoid the nasty limits::min() hack
for UNKNOWN. Your test would then be more accurately testing what will actually
get recorded, too.

[mark a. foltz, 2016/03/18 20:11:00]

I'm not sure it's a good idea to have base::Version know about Media Router
specific enums.

[mark a. foltz, 2016/03/18 20:11:00]

I don't think base::Version should know about enums specific to Media Router.

[Wez, 2016/03/18 20:12:31]

Sorry, s/version/function in my original comment.

+  if (!first.IsValid() || !first.components().size() || !second.IsValid() ||
+      !second.components().size()) {
+    return std::numeric_limits<int>::min();
+  }
+
+  uint32_t first_major = first.components()[0];
+  uint32_t second_major = second.components()[0];
+  // Sanity check.
+  if (first_major < 1 || second_major < 1)
+    return std::numeric_limits<int>::min();
+
+  return first_major - second_major;
+}
+
 }  // namespace media_router