Linux native notifications: Add server capabilities metrics

chrome/browser/notifications/notification_platform_bridge_linux.cc

 // Copyright 2017 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/notifications/notification_platform_bridge_linux.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/notifications/native_notification_display_service.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_display_service_factory.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/shell_integration_linux.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 const char kFreedesktopNotificationsName[] = "org.freedesktop.Notifications";
 const char kFreedesktopNotificationsPath[] = "/org/freedesktop/Notifications";
 
 const char kDefaultButtonId[] = "default";
 const char kSettingsButtonId[] = "settings";
 
+// The values in this enumeration correspond to those of the
+// Linux.NotificationPlatformBridge.InitializationStatus histogram, so
+// the ordering should not be changed.  New error codes should be
+// added at the end, before NUM_ITEMS.
+enum class ConnectionInitializationStatusCode {
+  SUCCESS = 0,
+  NATIVE_NOTIFICATIONS_NOT_SUPPORTED = 1,
+  MISSING_REQUIRED_CAPABILITIES = 2,
+  COULD_NOT_CONNECT_TO_SIGNALS = 3,
+  NUM_ITEMS
+};
+
 gfx::Image DeepCopyImage(const gfx::Image& image) {
   std::unique_ptr<gfx::ImageSkia> image_skia(image.CopyImageSkia());
   return gfx::Image(*image_skia);
 }
 
 int NotificationPriorityToFdoUrgency(int priority) {
   enum FdoUrgency {
     LOW = 0,
     NORMAL = 1,
     CRITICAL = 2,
@@ skipping 251 matching lines @@
       bus_options.bus_type = dbus::Bus::SESSION;
       bus_options.connection_type = dbus::Bus::PRIVATE;
       bus_options.dbus_task_runner = task_runner_;
       bus_ = make_scoped_refptr(new dbus::Bus(bus_options));
     }
 
     notification_proxy_ =
         bus_->GetObjectProxy(kFreedesktopNotificationsName,
                              dbus::ObjectPath(kFreedesktopNotificationsPath));
     if (!notification_proxy_) {
-      OnConnectionInitializationFinishedOnTaskRunner(false);
+      OnConnectionInitializationFinishedOnTaskRunner(
+          ConnectionInitializationStatusCode::
+              NATIVE_NOTIFICATIONS_NOT_SUPPORTED);
       return;
     }
 
+    dbus::MethodCall get_capabilities_call(kFreedesktopNotificationsName,
+                                           "GetCapabilities");
+    std::unique_ptr<dbus::Response> capabilities_response =
+        notification_proxy_->CallMethodAndBlock(
+            &get_capabilities_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
+    if (capabilities_response) {
+      dbus::MessageReader reader(capabilities_response.get());
+      std::vector<std::string> capabilities;
+      reader.PopArrayOfStrings(&capabilities);
+      for (const std::string& capability : capabilities)
+        capabilities_.insert(capability);
+    }
+    RecordMetricsForCapabilities();
+
     connected_signals_barrier_ = base::BarrierClosure(
         2, base::Bind(&NotificationPlatformBridgeLinuxImpl::
                           OnConnectionInitializationFinishedOnTaskRunner,
-                      this, true));
+                      this, ConnectionInitializationStatusCode::SUCCESS));
     notification_proxy_->ConnectToSignal(
         kFreedesktopNotificationsName, "ActionInvoked",
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnActionInvoked, this),
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnSignalConnected,
                    this));
     notification_proxy_->ConnectToSignal(
         kFreedesktopNotificationsName, "NotificationClosed",
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnNotificationClosed,
                    this),
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnSignalConnected,
@@ skipping 245 matching lines @@
   void OnConnectionInitializationFinishedOnUiThread(bool success) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     connected_ = success;
     for (auto& callback : on_connected_callbacks_)
       std::move(callback).Run(success);
     on_connected_callbacks_.clear();
     if (!success)
       CleanUp();
   }
 
-  void OnConnectionInitializationFinishedOnTaskRunner(bool success) {
+  void OnConnectionInitializationFinishedOnTaskRunner(
+      ConnectionInitializationStatusCode status) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
-    PostTaskToUiThread(
-        base::BindOnce(&NotificationPlatformBridgeLinuxImpl::
-                           OnConnectionInitializationFinishedOnUiThread,
-                       this, success));
+    UMA_HISTOGRAM_ENUMERATION(
+        "Notifications.Linux.BridgeInitializationStatus",
+        static_cast<int>(status),
+        static_cast<int>(ConnectionInitializationStatusCode::NUM_ITEMS));
+    PostTaskToUiThread(base::BindOnce(
+        &NotificationPlatformBridgeLinuxImpl::
+            OnConnectionInitializationFinishedOnUiThread,
+        this, status == ConnectionInitializationStatusCode::SUCCESS));
   }
 
   void OnSignalConnected(const std::string& interface_name,
                          const std::string& signal_name,
                          bool success) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     if (!success) {
-      OnConnectionInitializationFinishedOnTaskRunner(false);
+      OnConnectionInitializationFinishedOnTaskRunner(
+          ConnectionInitializationStatusCode::COULD_NOT_CONNECT_TO_SIGNALS);
       return;
     }
     connected_signals_barrier_.Run();
   }
 
+  void RecordMetricsForCapabilities() {
+    // Histogram macros must be called with the same name for each
+    // callsite, so we can't roll the below into a nice loop.
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.ActionIcons",
+                          capabilities_.count("action-icons"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Actions",
+                          capabilities_.count("actions"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Body",
+                          capabilities_.count("body"));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.BodyHyperlinks",
+        capabilities_.count("body-hyperlinks"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.BodyImages",
+                          capabilities_.count("body-images"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.BodyMarkup",
+                          capabilities_.count("body-markup"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.IconMulti",
+                          capabilities_.count("icon-multi"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.IconStatic",
+                          capabilities_.count("icon-static"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Persistence",
+                          capabilities_.count("persistence"));
+    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Sound",
+                          capabilities_.count("sound"));
+  }
+
   //////////////////////////////////////////////////////////////////////////////
   // Members used only on the UI thread.
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   content::NotificationRegistrar registrar_;
 
   // State necessary for OnConnectionInitializationFinished() and
   // SetReadyCallback().
   base::Optional<bool> connected_;
   std::vector<NotificationBridgeReadyCallback> on_connected_callbacks_;
 
   //////////////////////////////////////////////////////////////////////////////
   // Members used only on the task runner thread.
 
   scoped_refptr<dbus::Bus> bus_;
 
   dbus::ObjectProxy* notification_proxy_ = nullptr;
 
+  std::unordered_set<std::string> capabilities_;
+
   base::Closure connected_signals_barrier_;
 
   // A std::set<std::unique_ptr<T>> doesn't work well because
   // eg. std::set::erase(T) would require a std::unique_ptr<T>
   // argument, so the data would get double-destructed.
   template <typename T>
   using UnorderedUniqueSet = std::unordered_map<T*, std::unique_ptr<T>>;
 
   UnorderedUniqueSet<NotificationData> notifications_;
 
@@ skipping 35 matching lines @@
 }
 
 void NotificationPlatformBridgeLinux::SetReadyCallback(
     NotificationBridgeReadyCallback callback) {
   impl_->SetReadyCallback(std::move(callback));
 }
 
 void NotificationPlatformBridgeLinux::CleanUp() {
   impl_->CleanUp();
 }