Linux native notifications: Add initial unit test

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/barrier_closure.h"
 #include "base/files/file_util.h"
@@ skipping 109 matching lines @@
 // static
 NotificationPlatformBridge* NotificationPlatformBridge::Create() {
   return new NotificationPlatformBridgeLinux();
 }
 
 class NotificationPlatformBridgeLinuxImpl
     : public NotificationPlatformBridge,
       public content::NotificationObserver,
       public base::RefCountedThreadSafe<NotificationPlatformBridgeLinuxImpl> {
  public:
-  NotificationPlatformBridgeLinuxImpl()
-      : task_runner_(base::CreateSingleThreadTaskRunnerWithTraits(
-            base::TaskTraits().MayBlock().WithPriority(
-                base::TaskPriority::USER_BLOCKING))) {
+  explicit NotificationPlatformBridgeLinuxImpl(scoped_refptr<dbus::Bus> bus)
+      : bus_(bus) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    task_runner_ = base::CreateSingleThreadTaskRunnerWithTraits(
+        base::TaskTraits().MayBlock().WithPriority(
+            base::TaskPriority::USER_BLOCKING));
     registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                    content::NotificationService::AllSources());
-    PostTaskToTaskRunnerThread(
-        base::BindOnce(&NotificationPlatformBridgeLinuxImpl::Init, this));
+  }
+
+  // InitOnTaskRunner() cannot be posted from within the constructor
+  // because of a race condition.  The reference count for |this|
+  // starts out as 0.  Posting the Init task would increment the count
+  // to 1.  If the task finishes before the constructor returns, the
+  // count will go to 0 and the object would be prematurely
+  // destructed.
+  void Init() {
+    PostTaskToTaskRunnerThread(base::BindOnce(
+        &NotificationPlatformBridgeLinuxImpl::InitOnTaskRunner, this));
   }
 
   void Display(NotificationCommon::Type notification_type,
                const std::string& notification_id,
                const std::string& profile_id,
                bool is_incognito,
                const Notification& notification) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     // Notifications contain gfx::Image's which have reference counts
     // that are not thread safe.  Because of this, we duplicate the
@@ skipping 33 matching lines @@
 
   void SetReadyCallback(NotificationBridgeReadyCallback callback) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     if (connected_.has_value()) {
       std::move(callback).Run(connected_.value());
     } else {
       on_connected_callbacks_.push_back(std::move(callback));
     }
   }
 
+  void CleanUp() {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    PostTaskToTaskRunnerThread(base::BindOnce(
+        &NotificationPlatformBridgeLinuxImpl::CleanUpOnTaskRunner, this));
+  }
+
  private:
   friend class base::RefCountedThreadSafe<NotificationPlatformBridgeLinuxImpl>;
 
   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 31 matching lines @@
     size_t action_end = 0;
 
     // Temporary resource files associated with the notification that
     // should be cleaned up when the notification is closed or on
     // shutdown.
     std::vector<std::unique_ptr<ResourceFile>> resource_files;
   };
 
   ~NotificationPlatformBridgeLinuxImpl() override {
     DCHECK(!bus_);
+    DCHECK(!notification_proxy_);
     DCHECK(notifications_.empty());
   }
 
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     DCHECK_EQ(chrome::NOTIFICATION_APP_TERMINATING, type);
     // The browser process is about to exit.  Post the CleanUp() task
     // while we still can.
     CleanUp();
   }
 
   void PostTaskToUiThread(base::OnceClosure closure) const {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     bool success = content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE, std::move(closure));
     DCHECK(success);
   }
 
   void PostTaskToTaskRunnerThread(base::OnceClosure closure) const {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     DCHECK(task_runner_);
     bool success = task_runner_->PostTask(FROM_HERE, std::move(closure));
     DCHECK(success);
   }
 
   // Sets up the D-Bus connection.
-  void Init() {
+  void InitOnTaskRunner() {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
-    dbus::Bus::Options bus_options;
-    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));
+    // |bus_| may be non-null in unit testing where a fake bus is used.
+    if (!bus_) {
+      dbus::Bus::Options bus_options;
+      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);
       return;
     }
 
     connected_signals_barrier_ = base::BarrierClosure(
         2, base::Bind(&NotificationPlatformBridgeLinuxImpl::
                           OnConnectionInitializationFinishedOnTaskRunner,
                       this, true));
     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,
                    this));
   }
 
-  void CleanUp() {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-    if (cleanup_posted_)
-      return;
-    PostTaskToTaskRunnerThread(base::BindOnce(
-        &NotificationPlatformBridgeLinuxImpl::CleanUpOnTaskRunner, this));
-    cleanup_posted_ = true;
-  }
-
   void CleanUpOnTaskRunner() {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
-    bus_->ShutdownAndBlock();
+    if (bus_)
+      bus_->ShutdownAndBlock();
     bus_ = nullptr;
     notification_proxy_ = nullptr;
     notifications_.clear();
   }
 
   // Makes the "Notify" call to D-Bus.
   void DisplayOnTaskRunner(NotificationCommon::Type notification_type,
                            const std::string& notification_id,
                            const std::string& profile_id,
                            bool is_incognito,
@@ skipping 254 matching lines @@
 
   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_;
 
-  bool cleanup_posted_ = false;
-
   //////////////////////////////////////////////////////////////////////////////
   // Members used only on the task runner thread.
 
   scoped_refptr<dbus::Bus> bus_;
 
   dbus::ObjectProxy* notification_proxy_ = nullptr;
 
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationPlatformBridgeLinuxImpl);
 };
 
 NotificationPlatformBridgeLinux::NotificationPlatformBridgeLinux()
-    : impl_(new NotificationPlatformBridgeLinuxImpl()) {}
+    : NotificationPlatformBridgeLinux(nullptr) {}
+
+NotificationPlatformBridgeLinux::NotificationPlatformBridgeLinux(
+    scoped_refptr<dbus::Bus> bus)
+    : impl_(new NotificationPlatformBridgeLinuxImpl(bus)) {
+  impl_->Init();
+}
 
 NotificationPlatformBridgeLinux::~NotificationPlatformBridgeLinux() = default;
 
 void NotificationPlatformBridgeLinux::Display(
     NotificationCommon::Type notification_type,
     const std::string& notification_id,
     const std::string& profile_id,
     bool is_incognito,
     const Notification& notification) {
   impl_->Display(notification_type, notification_id, profile_id, is_incognito,
@@ skipping 10 matching lines @@
     const std::string& profile_id,
     bool incognito,
     const GetDisplayedNotificationsCallback& callback) const {
   impl_->GetDisplayed(profile_id, incognito, callback);
 }
 
 void NotificationPlatformBridgeLinux::SetReadyCallback(
     NotificationBridgeReadyCallback callback) {
   impl_->SetReadyCallback(std::move(callback));
 }
+
+void NotificationPlatformBridgeLinux::CleanUp() {
+  impl_->CleanUp();
+}