Add NotificationDisplayServiceProxy

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 "base/files/file_util.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/synchronization/waitable_event.h"
+#include "base/synchronization/lock.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/browser_process.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/notifications/notification_display_service_proxy.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/shell_integration_linux.h"
 #include "content/public/browser/browser_thread.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
@@ skipping 33 matching lines @@
                            const std::string& notification_id,
                            int action_index,
                            const base::NullableString16& reply,
                            Profile* profile) {
   if (!profile)
     return;
 
   NotificationDisplayService* display_service =
       NotificationDisplayServiceFactory::GetForProfile(profile);
 
-  static_cast<NativeNotificationDisplayService*>(display_service)
+  static_cast<NotificationDisplayServiceProxy*>(display_service)
+      ->native_notification_display_service()
       ->ProcessNotificationOperation(operation, notification_type, origin,
                                      notification_id, action_index, reply);
 }
 
 // Writes |data| to a new temporary file and returns its path.
 // Returns base::FilePath() on failure.
 base::FilePath WriteDataToTmpFile(
     const scoped_refptr<base::RefCountedMemory>& data) {
   int data_len = data->size();
   if (data_len == 0)
     return base::FilePath();
   base::FilePath file_path;
   if (!base::CreateTemporaryFile(&file_path))
     return base::FilePath();
   if (base::WriteFile(file_path, data->front_as<char>(), data_len) !=
       data_len) {
     base::DeleteFile(file_path, false);
     return base::FilePath();
   }
   return file_path;
 }
 
 }  // namespace
 
 // static
 NotificationPlatformBridge* NotificationPlatformBridge::Create() {
-  auto npbl = base::MakeUnique<NotificationPlatformBridgeLinux>();
-  if (!npbl->BlockUntilReady())
-    return nullptr;
-  return npbl.release();
+  return new NotificationPlatformBridgeLinux();
 }
 
 class NotificationPlatformBridgeLinux::NativeNotificationThread
     : public base::Thread {
  public:
-  NativeNotificationThread()
-      : base::Thread("FDO Notifications D-Bus thread"),
-        event_(base::WaitableEvent::ResetPolicy::MANUAL,
-               base::WaitableEvent::InitialState::NOT_SIGNALED) {
+  NativeNotificationThread() : base::Thread("FDO Notifications D-Bus thread") {
     base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
     if (!StartWithOptions(thread_options))
-      event_.Signal();
+      OnConnected(false);
   }
 
   ~NativeNotificationThread() override {
     Stop();
     // All of the resources should have been cleaned up on the
     // notification thread.
     DCHECK(notifications_.empty());
   }
 
   void Display(NotificationCommon::Type notification_type,
@@ skipping 129 matching lines @@
   void GetDisplayed(const std::string& profile_id,
                     bool incognito,
                     const DisplayedNotificationsCallback& callback) const {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(callback,
                    base::Passed(base::MakeUnique<std::set<std::string>>()),
                    false));
   }
 
-  // Waits until the D-Bus connection has been created.  Returns true
-  // if |notification_proxy_| is ready to use, and false on error.
-  bool BlockUntilReady() {
-    event_.Wait();
-    return notification_proxy_initialized_.IsSet();
+  void IsConnected(const base::Callback<void(bool)> callback) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    base::AutoLock lock(connected_lock_);
+    if (connected_.has_value()) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI, FROM_HERE,
+          base::Bind(callback, connected_.value()));
+    } else {
+      DCHECK(!on_connected_callback_.has_value());
+      on_connected_callback_ = callback;
+    }
   }
 
  private:
   struct ResourceFile {
     explicit ResourceFile(const base::FilePath& file_path)
         : file_path(file_path) {}
     ~ResourceFile() { base::DeleteFile(file_path, false); }
     const base::FilePath file_path;
   };
 
@@ skipping 38 matching lines @@
 
   void Init() override {
     dbus::Bus::Options bus_options;
     bus_options.bus_type = dbus::Bus::SESSION;
     bus_options.connection_type = dbus::Bus::PRIVATE;
     bus_ = make_scoped_refptr(new dbus::Bus(bus_options));
 
     notification_proxy_ =
         bus_->GetObjectProxy(kFreedesktopNotificationsName,
                              dbus::ObjectPath(kFreedesktopNotificationsPath));
-    if (notification_proxy_)
-      notification_proxy_initialized_.Set();
-    event_.Signal();
+    OnConnected(notification_proxy_);
     if (!notification_proxy_)
       return;
 
     auto on_signal_connected = [](const std::string&, const std::string&,
                                   bool success) { DCHECK(success); };
     notification_proxy_->ConnectToSignal(
         kFreedesktopNotificationsName, "ActionInvoked",
         base::Bind(&NativeNotificationThread::OnActionInvoked,
                    base::Unretained(this)),
         base::Bind(on_signal_connected));
@@ skipping 98 matching lines @@
       return;
 
     NotificationData* data = FindNotificationData(dbus_id);
     if (!data)
       return;
 
     ForwardNotificationOperation(data, NotificationCommon::CLOSE, -1);
     notifications_.erase(data);
   }
 
+  void OnConnected(bool success) {
+    DCHECK_EQ(GetThreadId(), base::PlatformThread::CurrentId());
+    base::AutoLock lock(connected_lock_);
+    connected_ = success;
+    if (on_connected_callback_.has_value()) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI, FROM_HERE,
+          base::Bind(on_connected_callback_.value(), success));
+      on_connected_callback_ = base::nullopt;
+    }
+  }
+
+  // State necessary for OnConnected() and IsConnected().
+  base::Optional<bool> connected_;
+  base::Lock connected_lock_;
+  base::Optional<base::Callback<void(bool)>> on_connected_callback_;
+
   scoped_refptr<dbus::Bus> bus_;
 
   dbus::ObjectProxy* notification_proxy_ = nullptr;
 
-  // Event that will be signaled once |notification_proxy_| is done
-  // connecting, or has failed to connect.
-  base::WaitableEvent event_;
-
-  // Set if the |notification_proxy_| has initialized without error.
-  // Only valid once |event_| has been signaled.
-  base::AtomicFlag notification_proxy_initialized_;
-
   // 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_;
 };
 
 NotificationPlatformBridgeLinux::NotificationPlatformBridgeLinux()
@@ skipping 33 matching lines @@
 void NotificationPlatformBridgeLinux::GetDisplayed(
     const std::string& profile_id,
     bool incognito,
     const DisplayedNotificationsCallback& callback) const {
   thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&NativeNotificationThread::GetDisplayed,
                             base::Unretained(thread_.get()), profile_id,
                             incognito, callback));
 }
 
-bool NotificationPlatformBridgeLinux::BlockUntilReady() {
-  return thread_->BlockUntilReady();
+void NotificationPlatformBridgeLinux::IsConnected(
+    const base::Callback<void(bool)>& callback) {
+  thread_->IsConnected(callback);
 }