Merge PowerSaveBlockerImpl and PowerSaveBlocker

device/power_save_blocker/power_save_blocker_x11.cc

 // Copyright (c) 2012 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 <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/scrnsaver.h>
 #include <stdint.h>
 
 #include <memory>
 
-#include "device/power_save_blocker/power_save_blocker_impl.h"
+#include "device/power_save_blocker/power_save_blocker.h"
+
 // Xlib #defines Status, but we can't have that for some of our headers.
 #ifdef Status
 #undef Status
 #endif
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
@@ skipping 40 matching lines @@
     "/org/freedesktop/PowerManagement/Inhibit";
 
 const char kFreeDesktopAPIScreenServiceName[] = "org.freedesktop.ScreenSaver";
 const char kFreeDesktopAPIScreenInterfaceName[] = "org.freedesktop.ScreenSaver";
 const char kFreeDesktopAPIScreenObjectPath[] = "/org/freedesktop/ScreenSaver";
 
 }  // namespace
 
 namespace device {
 
-class PowerSaveBlockerImpl::Delegate
-    : public base::RefCountedThreadSafe<PowerSaveBlockerImpl::Delegate> {
+class PowerSaveBlocker::Delegate
+    : public base::RefCountedThreadSafe<PowerSaveBlocker::Delegate> {
  public:
   // Picks an appropriate D-Bus API to use based on the desktop environment.
   Delegate(PowerSaveBlockerType type,
            const std::string& description,
            bool freedesktop_only,
            scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
            scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner);
 
   // Post a task to initialize the delegate on the UI thread, which will itself
   // then post a task to apply the power save block on the FILE thread.
@@ skipping 74 matching lines @@
   // The cookie that identifies our inhibit request,
   // or 0 if there is no active inhibit request.
   uint32_t inhibit_cookie_;
 
   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
-PowerSaveBlockerImpl::Delegate::Delegate(
+PowerSaveBlocker::Delegate::Delegate(
     PowerSaveBlockerType type,
     const std::string& description,
     bool freedesktop_only,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner)
     : type_(type),
       description_(description),
       freedesktop_only_(freedesktop_only),
       api_(NO_API),
       enqueue_apply_(false),
       inhibit_cookie_(0),
       ui_task_runner_(ui_task_runner),
       blocking_task_runner_(blocking_task_runner) {
   // We're on the client's thread here, so we don't allocate the dbus::Bus
   // object yet. We'll do it later in ApplyBlock(), on the FILE thread.
 }
 
-void PowerSaveBlockerImpl::Delegate::Init() {
+void PowerSaveBlocker::Delegate::Init() {
   base::AutoLock lock(lock_);
   DCHECK(!enqueue_apply_);
   enqueue_apply_ = true;
   block_inflight_ = false;
   unblock_inflight_ = false;
   enqueue_unblock_ = false;
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&Delegate::InitOnUIThread, this));
 }
 
-void PowerSaveBlockerImpl::Delegate::CleanUp() {
+void PowerSaveBlocker::Delegate::CleanUp() {
   base::AutoLock lock(lock_);
   if (enqueue_apply_) {
     // If a call to ApplyBlock() has not yet been enqueued because we are still
     // initializing on the UI thread, then just cancel it. We don't need to
     // remove the block because we haven't even applied it yet.
     enqueue_apply_ = false;
   } else {
     if (ShouldBlock()) {
       blocking_task_runner_->PostTask(FROM_HERE,
                                       base::Bind(&Delegate::RemoveBlock, this));
     }
 
     ui_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Delegate::XSSSuspendSet, this, false));
   }
 }
 
-void PowerSaveBlockerImpl::Delegate::InitOnUIThread() {
+void PowerSaveBlocker::Delegate::InitOnUIThread() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   base::AutoLock lock(lock_);
   api_ = SelectAPI();
 
   if (enqueue_apply_) {
     if (ShouldBlock()) {
       // The thread we use here becomes the origin and D-Bus thread for the
       // D-Bus library, so we need to use the same thread above for
       // RemoveBlock(). It must be a thread that allows I/O operations, so we
       // use the FILE thread.
       blocking_task_runner_->PostTask(FROM_HERE,
                                       base::Bind(&Delegate::ApplyBlock, this));
     }
     XSSSuspendSet(true);
   }
   enqueue_apply_ = false;
 }
 
-bool PowerSaveBlockerImpl::Delegate::ShouldBlock() const {
+bool PowerSaveBlocker::Delegate::ShouldBlock() const {
   return freedesktop_only_ ? api_ == FREEDESKTOP_API : api_ != NO_API;
 }
 
-void PowerSaveBlockerImpl::Delegate::ApplyBlock() {
+void PowerSaveBlocker::Delegate::ApplyBlock() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!bus_);  // ApplyBlock() should only be called once.
   DCHECK(!block_inflight_);
 
   dbus::Bus::Options options;
   options.bus_type = dbus::Bus::SESSION;
   options.connection_type = dbus::Bus::PRIVATE;
   bus_ = new dbus::Bus(options);
 
   scoped_refptr<dbus::ObjectProxy> object_proxy;
@@ skipping 56 matching lines @@
       //     reason:        The reason for the inhibit
       message_writer->AppendString(
           base::CommandLine::ForCurrentProcess()->GetProgram().value());
       message_writer->AppendString(description_);
       break;
   }
 
   block_inflight_ = true;
   object_proxy->CallMethod(
       method_call.get(), dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-      base::Bind(&PowerSaveBlockerImpl::Delegate::ApplyBlockFinished, this));
+      base::Bind(&PowerSaveBlocker::Delegate::ApplyBlockFinished, this));
 }
 
-void PowerSaveBlockerImpl::Delegate::ApplyBlockFinished(
-    dbus::Response* response) {
+void PowerSaveBlocker::Delegate::ApplyBlockFinished(dbus::Response* response) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(bus_);
   DCHECK(block_inflight_);
   block_inflight_ = false;
 
   if (response) {
     // The method returns an inhibit_cookie, used to uniquely identify
     // this request. It should be used as an argument to Uninhibit()
     // in order to remove the request.
     dbus::MessageReader message_reader(response);
     if (!message_reader.PopUint32(&inhibit_cookie_))
       LOG(ERROR) << "Invalid Inhibit() response: " << response->ToString();
   } else {
     LOG(ERROR) << "No response to Inhibit() request!";
   }
 
   if (enqueue_unblock_) {
     enqueue_unblock_ = false;
     // RemoveBlock() was called while the Inhibit operation was in flight,
     // so go ahead and remove the block now.
     blocking_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&Delegate::RemoveBlock, this));
   }
 }
 
-void PowerSaveBlockerImpl::Delegate::RemoveBlock() {
+void PowerSaveBlocker::Delegate::RemoveBlock() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(bus_);  // RemoveBlock() should only be called once.
   DCHECK(!unblock_inflight_);
 
   if (block_inflight_) {
     DCHECK(!enqueue_unblock_);
     // Can't call RemoveBlock until ApplyBlock's async operation has
     // finished. Enqueue it for execution once ApplyBlock is done.
     enqueue_unblock_ = true;
     return;
@@ skipping 30 matching lines @@
           break;
       }
       break;
   }
 
   dbus::MessageWriter message_writer(method_call.get());
   message_writer.AppendUint32(inhibit_cookie_);
   unblock_inflight_ = true;
   object_proxy->CallMethod(
       method_call.get(), dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-      base::Bind(&PowerSaveBlockerImpl::Delegate::RemoveBlockFinished, this));
+      base::Bind(&PowerSaveBlocker::Delegate::RemoveBlockFinished, this));
 }
 
-void PowerSaveBlockerImpl::Delegate::RemoveBlockFinished(
-    dbus::Response* response) {
+void PowerSaveBlocker::Delegate::RemoveBlockFinished(dbus::Response* response) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(bus_);
   unblock_inflight_ = false;
 
   if (!response)
     LOG(ERROR) << "No response to Uninhibit() request!";
   // We don't care about checking the result. We assume it works; we can't
   // really do anything about it anyway if it fails.
   inhibit_cookie_ = 0;
 
   bus_->ShutdownAndBlock();
   bus_ = nullptr;
 }
 
-void PowerSaveBlockerImpl::Delegate::XSSSuspendSet(bool suspend) {
+void PowerSaveBlocker::Delegate::XSSSuspendSet(bool suspend) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   if (!XSSAvailable())
     return;
 
   XDisplay* display = gfx::GetXDisplay();
   XScreenSaverSuspend(display, suspend);
 }
 
-bool PowerSaveBlockerImpl::Delegate::DPMSEnabled() {
+bool PowerSaveBlocker::Delegate::DPMSEnabled() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   XDisplay* display = gfx::GetXDisplay();
   BOOL enabled = false;
   int dummy;
   if (DPMSQueryExtension(display, &dummy, &dummy) && DPMSCapable(display)) {
     CARD16 state;
     DPMSInfo(display, &state, &enabled);
   }
   return enabled;
 }
 
-bool PowerSaveBlockerImpl::Delegate::XSSAvailable() {
+bool PowerSaveBlocker::Delegate::XSSAvailable() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   XDisplay* display = gfx::GetXDisplay();
   int dummy;
   int major;
   int minor;
 
   if (!XScreenSaverQueryExtension(display, &dummy, &dummy))
     return false;
 
   if (!XScreenSaverQueryVersion(display, &major, &minor))
     return false;
 
   return major > 1 || (major == 1 && minor >= 1);
 }
 
-DBusAPI PowerSaveBlockerImpl::Delegate::SelectAPI() {
+DBusAPI PowerSaveBlocker::Delegate::SelectAPI() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   std::unique_ptr<base::Environment> env(base::Environment::Create());
   switch (base::nix::GetDesktopEnvironment(env.get())) {
     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
     case base::nix::DESKTOP_ENVIRONMENT_UNITY:
       if (DPMSEnabled())
         return GNOME_API;
       break;
     case base::nix::DESKTOP_ENVIRONMENT_XFCE:
     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
     case base::nix::DESKTOP_ENVIRONMENT_KDE5:
       if (DPMSEnabled())
         return FREEDESKTOP_API;
       break;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_OTHER:
       // Not supported.
       break;
   }
   return NO_API;
 }
 
-PowerSaveBlockerImpl::PowerSaveBlockerImpl(
+PowerSaveBlocker::PowerSaveBlocker(
     PowerSaveBlockerType type,
     Reason reason,
     const std::string& description,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner)
     : delegate_(new Delegate(type,
                              description,
                              false /* freedesktop_only */,
                              ui_task_runner,
                              blocking_task_runner)),
       ui_task_runner_(ui_task_runner),
       blocking_task_runner_(blocking_task_runner) {
   delegate_->Init();
 
   if (type == kPowerSaveBlockPreventDisplaySleep) {
     freedesktop_suspend_delegate_ = new Delegate(
         kPowerSaveBlockPreventAppSuspension, description,
         true /* freedesktop_only */, ui_task_runner, blocking_task_runner);
     freedesktop_suspend_delegate_->Init();
   }
 }
 
-PowerSaveBlockerImpl::~PowerSaveBlockerImpl() {
+PowerSaveBlocker::~PowerSaveBlocker() {
   delegate_->CleanUp();
   if (freedesktop_suspend_delegate_)
     freedesktop_suspend_delegate_->CleanUp();
 }
 
 }  // namespace device