Linux native notifications: Add const variables for DBus strings.

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>
@@ skipping 20 matching lines @@
 #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 {
 
+// DBus names, paths, methods, and signals.

[Tom Anderson, 2017/05/10 06:11:48]

nit: give the methods and signals their own sections instead of grouping them
here?

[Lei Zhang, 2017/05/10 21:11:56]

Done.

 const char kFreedesktopNotificationsName[] = "org.freedesktop.Notifications";
 const char kFreedesktopNotificationsPath[] = "/org/freedesktop/Notifications";
+const char kMethodCloseNotification[] = "CloseNotification";
+const char kMethodGetCapabilities[] = "GetCapabilities";
+const char kMethodNotify[] = "Notify";
+const char kMethodGetServerInformation[] = "GetServerInformation";
+const char kSignalActionInvoked[] = "ActionInvoked";
+const char kSignalNotificationClosed[] = "NotificationClosed";
 
+// Capabilities
+const char kCapabilityActionIcons[] = "action-icons";
+const char kCapabilityActions[] = "actions";
+const char kCapabilityBody[] = "body";
+const char kCapabilityBodyHyperlinks[] = "body-hyperlinks";
+const char kCapabilityBodyImages[] = "body-images";
+const char kCapabilityBodyMarkup[] = "body-markup";
+const char kCapabilityIconMulti[] = "icon-multi";
+const char kCapabilityIconStatic[] = "icon-static";
+const char kCapabilityPersistence[] = "persistence";
+const char kCapabilitySound[] = "sound";
+
+// Button IDs.
 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,
@@ skipping 276 matching lines @@
         bus_->GetObjectProxy(kFreedesktopNotificationsName,
                              dbus::ObjectPath(kFreedesktopNotificationsPath));
     if (!notification_proxy_) {
       OnConnectionInitializationFinishedOnTaskRunner(
           ConnectionInitializationStatusCode::
               NATIVE_NOTIFICATIONS_NOT_SUPPORTED);
       return;
     }
 
     dbus::MethodCall get_capabilities_call(kFreedesktopNotificationsName,
-                                           "GetCapabilities");
+                                           kMethodGetCapabilities);
     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();
 
     dbus::MethodCall get_server_information_call(kFreedesktopNotificationsName,
-                                                 "GetServerInformation");
+                                                 kMethodGetServerInformation);
     std::unique_ptr<dbus::Response> server_information_response =
         notification_proxy_->CallMethodAndBlock(
             &get_server_information_call,
             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
     if (server_information_response) {
       dbus::MessageReader reader(server_information_response.get());
       std::string spec_version;
       reader.PopString(&spec_version);  // name
       reader.PopString(&spec_version);  // vendor
       reader.PopString(&spec_version);  // version
       reader.PopString(&spec_version);  // spec_version
       spec_version_ = base::Version(spec_version);
     }
     // The minimum supported spec version is 1.1, because this was the
     // version that added image hints.
     if (!spec_version_.IsValid() ||
         spec_version_ < base::Version(std::vector<uint32_t>{1, 1})) {
       OnConnectionInitializationFinishedOnTaskRunner(
           ConnectionInitializationStatusCode::INCOMPATIBLE_SPEC_VERSION);
       return;
     }
 
     connected_signals_barrier_ = base::BarrierClosure(
         2, base::Bind(&NotificationPlatformBridgeLinuxImpl::
                           OnConnectionInitializationFinishedOnTaskRunner,
                       this, ConnectionInitializationStatusCode::SUCCESS));
     notification_proxy_->ConnectToSignal(
-        kFreedesktopNotificationsName, "ActionInvoked",
+        kFreedesktopNotificationsName, kSignalActionInvoked,
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnActionInvoked, this),
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnSignalConnected,
                    this));
     notification_proxy_->ConnectToSignal(
-        kFreedesktopNotificationsName, "NotificationClosed",
+        kFreedesktopNotificationsName, kSignalNotificationClosed,
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnNotificationClosed,
                    this),
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnSignalConnected,
                    this));
   }
 
   void CleanUpOnTaskRunner() {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     if (bus_)
       bus_->ShutdownAndBlock();
@@ skipping 16 matching lines @@
       data->notification_type = notification_type;
       data->resource_files.clear();
     } else {
       // Send the notification for the first time.
       data =
           new NotificationData(notification_type, notification_id, profile_id,
                                is_incognito, notification->origin_url());
       notifications_.emplace(data, base::WrapUnique(data));
     }
 
-    dbus::MethodCall method_call(kFreedesktopNotificationsName, "Notify");
+    dbus::MethodCall method_call(kFreedesktopNotificationsName, kMethodNotify);
     dbus::MessageWriter writer(&method_call);
 
     // app_name passed implicitly via desktop-entry.
     writer.AppendString("");
 
     writer.AppendUint32(data->dbus_id);
 
     // app_icon passed implicitly via desktop-entry.
     writer.AppendString("");
 
     writer.AppendString(base::UTF16ToUTF8(notification->title()));
 
     std::string body;
-    if (base::ContainsKey(capabilities_, "body")) {
+    if (base::ContainsKey(capabilities_, kCapabilityBody)) {
       body = base::UTF16ToUTF8(notification->message());
-      if (base::ContainsKey(capabilities_, "body-markup")) {
+      if (base::ContainsKey(capabilities_, kCapabilityBodyMarkup)) {
         base::ReplaceSubstringsAfterOffset(&body, 0, "&", "&amp;");
         base::ReplaceSubstringsAfterOffset(&body, 0, "<", "&lt;");
         base::ReplaceSubstringsAfterOffset(&body, 0, ">", "&gt;");
       }
     }
     writer.AppendString(body);
 
     // Even-indexed elements in this vector are action IDs passed back to
     // us in OnActionInvoked().  Odd-indexed ones contain the button text.
     std::vector<std::string> actions;
-    if (base::ContainsKey(capabilities_, "actions")) {
+    if (base::ContainsKey(capabilities_, kCapabilityActions)) {
       data->action_start = data->action_end;
       for (const auto& button_info : notification->buttons()) {
         // FDO notification buttons can contain either an icon or a label,
         // but not both, and the type of all buttons must be the same (all
         // labels or all icons), so always use labels.
         const std::string id = base::SizeTToString(data->action_end++);
         const std::string label = base::UTF16ToUTF8(button_info.title);
         actions.push_back(id);
         actions.push_back(label);
       }
@@ skipping 67 matching lines @@
   // Makes the "CloseNotification" call to D-Bus.
   void CloseOnTaskRunner(const std::string& profile_id,
                          const std::string& notification_id) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     std::vector<NotificationData*> to_erase;
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->notification_id == notification_id &&
           data->profile_id == profile_id) {
         dbus::MethodCall method_call(kFreedesktopNotificationsName,
-                                     "CloseNotification");
+                                     kMethodCloseNotification);
         dbus::MessageWriter writer(&method_call);
         writer.AppendUint32(data->dbus_id);
         notification_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
         to_erase.push_back(data);
       }
     }
     for (NotificationData* data : to_erase)
       notifications_.erase(data);
   }
@@ skipping 129 matching lines @@
       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",
-                          base::ContainsKey(capabilities_, "action-icons"));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.ActionIcons",
+        base::ContainsKey(capabilities_, kCapabilityActionIcons));
     UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Actions",
-                          base::ContainsKey(capabilities_, "actions"));
+                          base::ContainsKey(capabilities_, kCapabilityActions));
     UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Body",
-                          base::ContainsKey(capabilities_, "body"));
+                          base::ContainsKey(capabilities_, kCapabilityBody));
     UMA_HISTOGRAM_BOOLEAN(
         "Notifications.Freedesktop.Capabilities.BodyHyperlinks",
-        base::ContainsKey(capabilities_, "body-hyperlinks"));
-    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.BodyImages",
-                          base::ContainsKey(capabilities_, "body-images"));
-    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.BodyMarkup",
-                          base::ContainsKey(capabilities_, "body-markup"));
-    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.IconMulti",
-                          base::ContainsKey(capabilities_, "icon-multi"));
-    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.IconStatic",
-                          base::ContainsKey(capabilities_, "icon-static"));
-    UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Persistence",
-                          base::ContainsKey(capabilities_, "persistence"));
+        base::ContainsKey(capabilities_, kCapabilityBodyHyperlinks));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.BodyImages",
+        base::ContainsKey(capabilities_, kCapabilityBodyImages));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.BodyMarkup",
+        base::ContainsKey(capabilities_, kCapabilityBodyMarkup));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.IconMulti",
+        base::ContainsKey(capabilities_, kCapabilityIconMulti));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.IconStatic",
+        base::ContainsKey(capabilities_, kCapabilityIconStatic));
+    UMA_HISTOGRAM_BOOLEAN(
+        "Notifications.Freedesktop.Capabilities.Persistence",
+        base::ContainsKey(capabilities_, kCapabilityPersistence));
     UMA_HISTOGRAM_BOOLEAN("Notifications.Freedesktop.Capabilities.Sound",
-                          base::ContainsKey(capabilities_, "sound"));
+                          base::ContainsKey(capabilities_, kCapabilitySound));
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Members used only on the UI thread.
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   content::NotificationRegistrar registrar_;
 
   // State necessary for OnConnectionInitializationFinished() and
@@ skipping 60 matching lines @@
 }
 
 void NotificationPlatformBridgeLinux::SetReadyCallback(
     NotificationBridgeReadyCallback callback) {
   impl_->SetReadyCallback(std::move(callback));
 }
 
 void NotificationPlatformBridgeLinux::CleanUp() {
   impl_->CleanUp();
 }