Add UMA metrics for the linux distro.

chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.cc

 // 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.
 
 #include "chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 22 matching lines @@
 #include "chrome/browser/metrics/tab_usage_recorder.h"
 #endif  // !defined(OS_ANDROID)
 
 #if defined(OS_ANDROID) && defined(__arm__)
 #include <cpu-features.h>
 #endif  // defined(OS_ANDROID) && defined(__arm__)
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include <gnu/libc-version.h>
 
+#include "base/linux_util.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/version.h"
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
 #endif
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 
 #if defined(USE_OZONE) || defined(USE_X11)
 #include "ui/events/devices/input_device_event_observer.h"
 #include "ui/events/devices/input_device_manager.h"
 #endif  // defined(USE_OZONE) || defined(USE_X11)
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/shell_integration_win.h"
 #include "chrome/installer/util/google_update_settings.h"
 #endif  // defined(OS_WIN)
 
 namespace {
 
+// These values are written to logs.  New enum values can be added, but existing
+// enums must never be renumbered or deleted and reused.
+enum UMALinuxDistro {
+  UMA_LINUX_DISTRO_UNKNOWN = 0,
+  UMA_LINUX_DISTRO_UBUNTU_OTHER = 1,
+  UMA_LINUX_DISTRO_UBUNTU_14_04 = 2,
+  UMA_LINUX_DISTRO_UBUNTU_16_04 = 3,
+  UMA_LINUX_DISTRO_UBUNTU_16_10 = 4,
+  UMA_LINUX_DISTRO_UBUNTU_17_04 = 5,
+  UMA_LINUX_DISTRO_DEBIAN_OTHER = 6,
+  UMA_LINUX_DISTRO_DEBIAN_8 = 7,
+  UMA_LINUX_DISTRO_OPENSUSE_OTHER = 8,
+  UMA_LINUX_DISTRO_OPENSUSE_LEAP_42_2 = 9,
+  UMA_LINUX_DISTRO_FEDORA_OTHER = 10,
+  UMA_LINUX_DISTRO_FEDORA_24 = 11,
+  UMA_LINUX_DISTRO_FEDORA_25 = 12,
+  // Note: Add new distros to the list above this line, and update LinuxDistro
+  // in tools/metrics/histograms/enums.xml accordingly.
+  UMA_LINUX_DISTRO_MAX
+};
+
 enum UMALinuxGlibcVersion {
   UMA_LINUX_GLIBC_NOT_PARSEABLE,
   UMA_LINUX_GLIBC_UNKNOWN,
   UMA_LINUX_GLIBC_2_11,
   // To log newer versions, just update tools/metrics/histograms/histograms.xml.
 };
 
 enum UMALinuxWindowManager {
   UMA_LINUX_WINDOW_MANAGER_OTHER,
   UMA_LINUX_WINDOW_MANAGER_BLACKBOX,
@@ skipping 83 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Windows.InCompatibilityMode",
                         os_info.version() != os_info.Kernel32Version());
 #endif  // defined(OS_WIN)
 
 #if defined(OS_MACOSX)
   bluetooth_utility::BluetoothAvailability availability =
       bluetooth_utility::GetBluetoothAvailability();
   UMA_HISTOGRAM_ENUMERATION("OSX.BluetoothAvailability",
                             availability,
                             bluetooth_utility::BLUETOOTH_AVAILABILITY_COUNT);
-#endif   // defined(OS_MACOSX)
+#endif  // defined(OS_MACOSX)
 
   // Record whether Chrome is the default browser or not.
   shell_integration::DefaultWebClientState default_state =
       shell_integration::GetDefaultBrowser();
   UMA_HISTOGRAM_ENUMERATION("DefaultBrowser.State", default_state,
                             shell_integration::NUM_DEFAULT_STATES);
 }
 
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+void RecordLinuxDistro() {
+  UMALinuxDistro distro_result = UMA_LINUX_DISTRO_UNKNOWN;
+
+  std::vector<std::string> distro_tokens =
+      base::SplitString(base::GetLinuxDistro(), base::kWhitespaceASCII,
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  if (distro_tokens.size() > 0) {
+    if (distro_tokens[0] == "Ubuntu") {
+      // Format: Ubuntu YY.MM.P [LTS]
+      // We are only concerned with release (YY.MM) not the patch (P).
+      distro_result = UMA_LINUX_DISTRO_UBUNTU_OTHER;
+      if (distro_tokens.size() >= 3) {
+        base::Version version(distro_tokens[1]);
+        if (version.IsValid()) {
+          if (version.CompareToWildcardString("14.04.*") == 0) {
+            distro_result = UMA_LINUX_DISTRO_UBUNTU_14_04;
+          } else if (version.CompareToWildcardString("16.04.*") == 0) {
+            distro_result = UMA_LINUX_DISTRO_UBUNTU_16_04;
+          } else if (version.CompareToWildcardString("16.10.*") == 0) {
+            distro_result = UMA_LINUX_DISTRO_UBUNTU_16_10;
+          } else if (version.CompareToWildcardString("17.04.*") == 0) {
+            distro_result = UMA_LINUX_DISTRO_UBUNTU_17_04;
+          }
+        }
+      }
+    } else if (distro_tokens[0] == "openSUSE") {
+      // Format: openSUSE Leap RR.R
+      distro_result = UMA_LINUX_DISTRO_OPENSUSE_OTHER;
+      if (distro_tokens.size() >= 4 && distro_tokens[1] == "Leap" &&
+          distro_tokens[2] == "42.2") {
+        distro_result = UMA_LINUX_DISTRO_OPENSUSE_LEAP_42_2;
+      }
+    } else if (distro_tokens[0] == "Debian") {
+      // Format: Debian GNU/Linux R.P (<codename>)
+      // We are only concerned with the release (R) not the patch (P).
+      distro_result = UMA_LINUX_DISTRO_DEBIAN_OTHER;
+      if (distro_tokens.size() >= 3) {
+        base::Version version(distro_tokens[2]);
+        if (version.IsValid() && version.CompareToWildcardString("8.*")) {
+          distro_result = UMA_LINUX_DISTRO_DEBIAN_8;
+        }
+      }
+    } else if (distro_tokens[0] == "Fedora") {
+      // Format: Fedora release RR (<codename>)
+      distro_result = UMA_LINUX_DISTRO_FEDORA_OTHER;
+      if (distro_tokens.size() >= 3) {
+        if (distro_tokens[2] == "24") {
+          distro_result = UMA_LINUX_DISTRO_FEDORA_24;
+        } else if (distro_tokens[2] == "25") {
+          distro_result = UMA_LINUX_DISTRO_FEDORA_25;
+        }
+      }
+    }
+  }
+
+  UMA_HISTOGRAM_ENUMERATION("Linux.Distro", distro_result,
+                            UMA_LINUX_DISTRO_MAX);
+}
+#endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
+
 void RecordLinuxGlibcVersion() {
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   base::Version version(gnu_get_libc_version());
 
   UMALinuxGlibcVersion glibc_version_result = UMA_LINUX_GLIBC_NOT_PARSEABLE;
   if (version.IsValid() && version.components().size() == 2) {
     glibc_version_result = UMA_LINUX_GLIBC_UNKNOWN;
     uint32_t glibc_major_version = version.components()[0];
     uint32_t glibc_minor_version = version.components()[1];
     if (glibc_major_version == 2) {
@@ skipping 190 matching lines @@
                                                             );
 #endif
 }
 
 void ChromeBrowserMainExtraPartsMetrics::PostBrowserStart() {
   RecordLinuxGlibcVersion();
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
   UMA_HISTOGRAM_ENUMERATION("Linux.WindowManager",
                             GetLinuxWindowManager(),
                             UMA_LINUX_WINDOW_MANAGER_COUNT);
+  base::PostTaskWithTraits(FROM_HERE,
+                           {base::MayBlock(), base::TaskPriority::BACKGROUND},
+                           base::BindOnce(&RecordLinuxDistro));
 #endif
 
 #if defined(USE_OZONE) || defined(USE_X11)
   // The touch event state for X11 and Ozone based event sub-systems are based
   // on device scans that happen asynchronously. So we may need to attach an
   // observer to wait until these scans complete.
   if (ui::InputDeviceManager::GetInstance()->AreDeviceListsComplete()) {
     RecordTouchEventState();
   } else {
     input_device_event_observer_.reset(
@@ skipping 52 matching lines @@
   }
 }
 
 namespace chrome {
 
 void AddMetricsExtraParts(ChromeBrowserMainParts* main_parts) {
   main_parts->AddParts(new ChromeBrowserMainExtraPartsMetrics());
 }
 
 }  // namespace chrome