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 70 matching lines @@
 }
 
 void ForwardNotificationOperationOnUiThread(
     NotificationCommon::Operation operation,
     NotificationCommon::Type notification_type,
     const std::string& origin,
     const std::string& notification_id,
     int action_index,
     const std::string& profile_id,
     bool is_incognito) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   profile_manager->LoadProfile(
       profile_id, is_incognito,
       base::Bind(&ProfileLoadedCallback, operation, notification_type, origin,
                  notification_id, action_index, base::NullableString16()));
 }
 
 // Writes |data| to a new temporary file and returns its path.
 // Returns base::FilePath() on failure.
@@ skipping 18 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))) {
+  NotificationPlatformBridgeLinuxImpl(
+      scoped_refptr<base::SequencedTaskRunner> notification_task_runner,
+      scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+      scoped_refptr<dbus::Bus> bus)
+      : notification_task_runner_(notification_task_runner),
+        ui_task_runner_(ui_task_runner),
+        bus_(bus) {
+    if (!notification_task_runner_) {
+      notification_task_runner_ = base::CreateSingleThreadTaskRunnerWithTraits(
+          base::TaskTraits().MayBlock().WithPriority(
+              base::TaskPriority::USER_BLOCKING));
+    }
+    DCHECK(ui_task_runner_);
     registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                    content::NotificationService::AllSources());
+  }
+
+  // Init() cannot be called 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 InitAfterConstructor() {
     PostTaskToTaskRunnerThread(
         base::BindOnce(&NotificationPlatformBridgeLinuxImpl::Init, 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);
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     // Notifications contain gfx::Image's which have reference counts
     // that are not thread safe.  Because of this, we duplicate the
     // notification and its images.  Wrap the notification in a
     // unique_ptr to transfer ownership of the notification (and the
     // non-thread-safe reference counts) to the task runner thread.
     auto notification_copy = base::MakeUnique<Notification>(notification);
     notification_copy->set_icon(DeepCopyImage(notification_copy->icon()));
     notification_copy->set_image(gfx::Image());
     notification_copy->set_small_image(gfx::Image());
     for (size_t i = 0; i < notification_copy->buttons().size(); i++)
       notification_copy->SetButtonIcon(i, gfx::Image());
 
     PostTaskToTaskRunnerThread(base::BindOnce(
         &NotificationPlatformBridgeLinuxImpl::DisplayOnTaskRunner, this,
         notification_type, notification_id, profile_id, is_incognito,
         base::Passed(&notification_copy)));
   }
 
   void Close(const std::string& profile_id,
              const std::string& notification_id) override {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     PostTaskToTaskRunnerThread(
         base::BindOnce(&NotificationPlatformBridgeLinuxImpl::CloseOnTaskRunner,
                        this, profile_id, notification_id));
   }
 
   void GetDisplayed(
       const std::string& profile_id,
       bool incognito,
       const GetDisplayedNotificationsCallback& callback) const override {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     PostTaskToTaskRunnerThread(base::BindOnce(
         &NotificationPlatformBridgeLinuxImpl::GetDisplayedOnTaskRunner, this,
         profile_id, incognito, callback));
   }
 
   void SetReadyCallback(NotificationBridgeReadyCallback callback) override {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (connected_.has_value()) {
       std::move(callback).Run(connected_.value());
     } else {
       on_connected_callbacks_.push_back(std::move(callback));
     }
   }
 
+  void CleanUp() {
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+    if (cleanup_posted_)
+      return;
+    PostTaskToTaskRunnerThread(base::BindOnce(
+        &NotificationPlatformBridgeLinuxImpl::CleanUpOnTaskRunner, this));
+    cleanup_posted_ = true;
+  }
+
  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 30 matching lines @@
     size_t action_start = 0;
     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(cleanup_posted_);
     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(ui_task_runner_->RunsTasksOnCurrentThread());
     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(notification_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(ui_task_runner_);
+    bool success = ui_task_runner_->PostTask(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(ui_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_);
+    bool success =
+        notification_task_runner_->PostTask(FROM_HERE, std::move(closure));
     DCHECK(success);
   }
 
   // Sets up the D-Bus connection.
   void Init() {
-    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));
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
+    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 = notification_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());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     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,
                            std::unique_ptr<Notification> notification) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     NotificationData* data =
         FindNotificationData(notification_id, profile_id, is_incognito);
     if (data) {
       // Update an existing notification.
       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,
@@ skipping 87 matching lines @@
     }
     if (!data->dbus_id) {
       // There was some sort of error with creating the notification.
       notifications_.erase(data);
     }
   }
 
   // Makes the "CloseNotification" call to D-Bus.
   void CloseOnTaskRunner(const std::string& profile_id,
                          const std::string& notification_id) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_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");
         dbus::MessageWriter writer(&method_call);
         writer.AppendUint32(data->dbus_id);
         notification_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
       }
     }
     for (NotificationData* data : to_erase)
       notifications_.erase(data);
   }
 
   void GetDisplayedOnTaskRunner(
       const std::string& profile_id,
       bool incognito,
       const GetDisplayedNotificationsCallback& callback) const {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     // TODO(thomasanderson): Implement.
     PostTaskToUiThread(base::BindOnce(
         callback, base::Passed(base::MakeUnique<std::set<std::string>>()),
         false));
   }
 
   NotificationData* FindNotificationData(const std::string& notification_id,
                                          const std::string& profile_id,
                                          bool is_incognito) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->notification_id == notification_id &&
           data->profile_id == profile_id &&
           data->is_incognito == is_incognito) {
         return data;
       }
     }
 
     return nullptr;
   }
 
   NotificationData* FindNotificationData(uint32_t dbus_id) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->dbus_id == dbus_id)
         return data;
     }
 
     return nullptr;
   }
 
   void ForwardNotificationOperation(NotificationData* data,
                                     NotificationCommon::Operation operation,
                                     int action_index) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     PostTaskToUiThread(base::BindOnce(
         ForwardNotificationOperationOnUiThread, operation,
         data->notification_type, data->origin_url.spec(), data->notification_id,
         action_index, data->profile_id, data->is_incognito));
   }
 
   void OnActionInvoked(dbus::Signal* signal) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     dbus::MessageReader reader(signal);
     uint32_t dbus_id;
     if (!reader.PopUint32(&dbus_id))
       return;
     std::string action;
     if (!reader.PopString(&action))
       return;
 
     NotificationData* data = FindNotificationData(dbus_id);
     if (!data)
@@ skipping 10 matching lines @@
       size_t n_buttons = data->action_end - data->action_start;
       size_t id_zero_based = id - data->action_start;
       if (id_zero_based >= n_buttons)
         return;
       ForwardNotificationOperation(data, NotificationCommon::CLICK,
                                    id_zero_based);
     }
   }
 
   void OnNotificationClosed(dbus::Signal* signal) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     dbus::MessageReader reader(signal);
     uint32_t dbus_id;
     if (!reader.PopUint32(&dbus_id))
       return;
 
     NotificationData* data = FindNotificationData(dbus_id);
     if (!data)
       return;
 
     ForwardNotificationOperation(data, NotificationCommon::CLOSE, -1);
     notifications_.erase(data);
   }
 
   // Called once the connection has been set up (or not).  |success|
   // indicates the connection is ready to use.
   void OnConnectionInitializationFinishedOnUiThread(bool success) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     connected_ = success;
     for (auto& callback : on_connected_callbacks_)
       std::move(callback).Run(success);
     on_connected_callbacks_.clear();
     if (!success)
       CleanUp();
   }
 
   void OnConnectionInitializationFinishedOnTaskRunner(bool success) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     PostTaskToUiThread(
         base::BindOnce(&NotificationPlatformBridgeLinuxImpl::
                            OnConnectionInitializationFinishedOnUiThread,
                        this, success));
   }
 
   void OnSignalConnected(const std::string& interface_name,
                          const std::string& signal_name,
                          bool success) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(notification_task_runner_->RunsTasksOnCurrentThread());
     if (!success) {
       OnConnectionInitializationFinishedOnTaskRunner(false);
       return;
     }
     connected_signals_barrier_.Run();
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Members used only on the UI thread.
 
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> notification_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<base::SequencedTaskRunner> ui_task_runner_;
+
   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,
+          content::BrowserThread::GetTaskRunnerForThread(
+              content::BrowserThread::UI),
+          nullptr) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+}
+
+NotificationPlatformBridgeLinux::NotificationPlatformBridgeLinux(
+    scoped_refptr<base::SequencedTaskRunner> notification_task_runner,
+    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+    scoped_refptr<dbus::Bus> bus)
+    : impl_(new NotificationPlatformBridgeLinuxImpl(notification_task_runner,
+                                                    ui_task_runner,
+                                                    bus)) {
+  impl_->InitAfterConstructor();
+}
 
 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();
+}