Linux native notifications: Remove spec_version check

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 <sstream>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
 #include "base/i18n/number_formatting.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
-#include "base/version.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 "chrome/grit/generated_resources.h"
 #include "components/url_formatter/elide_url.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 "net/base/escape.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 // DBus name / path.
 const char kFreedesktopNotificationsName[] = "org.freedesktop.Notifications";
 const char kFreedesktopNotificationsPath[] = "/org/freedesktop/Notifications";
 
 // DBus methods.
 const char kMethodCloseNotification[] = "CloseNotification";
 const char kMethodGetCapabilities[] = "GetCapabilities";
 const char kMethodNotify[] = "Notify";
-const char kMethodGetServerInformation[] = "GetServerInformation";
 
 // DBus signals.
 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";
@@ skipping 14 matching lines @@
 
 // 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,
-  INCOMPATIBLE_SPEC_VERSION = 4,
+  INCOMPATIBLE_SPEC_VERSION = 4,  // DEPRECATED
   NUM_ITEMS
 };
 
 int ClampInt(int value, int low, int hi) {
   return std::max(std::min(value, hi), low);
 }
 
 base::string16 CreateNotificationTitle(const Notification& notification) {
   base::string16 title;
   if (notification.type() == message_center::NOTIFICATION_TYPE_PROGRESS) {
@@ skipping 323 matching lines @@
       std::vector<std::string> capabilities;
       reader.PopArrayOfStrings(&capabilities);
       for (const std::string& capability : capabilities)
         capabilities_.insert(capability);
     }
     RecordMetricsForCapabilities();
     PostTaskToUiThread(base::BindOnce(
         &NotificationPlatformBridgeLinuxImpl::SetBodyImagesSupported, this,
         base::ContainsKey(capabilities_, kCapabilityBodyImages)));
 
-    dbus::MethodCall get_server_information_call(kFreedesktopNotificationsName,
-                                                 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, kSignalActionInvoked,
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnActionInvoked, this),
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnSignalConnected,
                    this));
     notification_proxy_->ConnectToSignal(
@@ skipping 155 matching lines @@
     desktop_file = desktop_file.RemoveFinalExtension();
     dbus::MessageWriter desktop_entry_writer(nullptr);
     hints_writer.OpenDictEntry(&desktop_entry_writer);
     desktop_entry_writer.AppendString("desktop-entry");
     desktop_entry_writer.AppendVariantOfString(desktop_file.value());
     hints_writer.CloseContainer(&desktop_entry_writer);
 
     std::unique_ptr<ResourceFile> icon_file =
         WriteDataToTmpFile(notification->icon().As1xPNGBytes());
     if (icon_file) {
-      dbus::MessageWriter image_path_writer(nullptr);
-      hints_writer.OpenDictEntry(&image_path_writer);
-      image_path_writer.AppendString(
-          spec_version_ == base::Version(std::vector<uint32_t>{1, 1})
-              ? "image_path"
-              : "image-path");
-      image_path_writer.AppendVariantOfString(icon_file->file_path().value());
-      hints_writer.CloseContainer(&image_path_writer);
+      for (const std::string& hint_name : {"image_path", "image-path"}) {
+        dbus::MessageWriter image_path_writer(nullptr);
+        hints_writer.OpenDictEntry(&image_path_writer);
+        image_path_writer.AppendString(hint_name);
+        image_path_writer.AppendVariantOfString(icon_file->file_path().value());
+        hints_writer.CloseContainer(&image_path_writer);
+      }
       data->resource_files.push_back(std::move(icon_file));
     }
 
     writer.CloseContainer(&hints_writer);
 
     const int32_t kExpireTimeoutDefault = -1;
     const int32_t kExpireTimeoutNever = 0;
     writer.AppendInt32(notification->never_timeout() ? kExpireTimeoutNever
                                                      : kExpireTimeoutDefault);
 
@@ skipping 217 matching lines @@
 
   //////////////////////////////////////////////////////////////////////////////
   // 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::Version spec_version_;
-
   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();
 }