chromeos: Block system suspend while uploading files to Drive

content/browser/power_save_blocker_linux.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 "content/browser/power_save_blocker.h"
+#include "content/public/browser/power_save_blocker.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 // Xlib #defines Status, but we can't have that for some of our headers.
 #ifdef Status
 #undef Status
 #endif
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "base/message_pump_aurax11.h"
 #endif
 #include "base/nix/xdg_util.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/browser_thread.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
+namespace content {
+
 namespace {
 
 enum DBusAPI {
   NO_API,           // Disable. No supported API available.
   GNOME_API,        // Use the GNOME API. (Supports more features.)
   FREEDESKTOP_API,  // Use the FreeDesktop API, for KDE4 and XFCE.
 };
 
 // Inhibit flags defined in the org.gnome.SessionManager interface.
 // Can be OR'd together and passed as argument to the Inhibit() method
 // to specify which power management features we want to suspend.
 enum GnomeAPIInhibitFlags {
   INHIBIT_LOGOUT            = 1,
   INHIBIT_SWITCH_USER       = 2,
   INHIBIT_SUSPEND_SESSION   = 4,
   INHIBIT_MARK_SESSION_IDLE = 8
 };
 
 const char kGnomeAPIServiceName[] = "org.gnome.SessionManager";
 const char kGnomeAPIInterfaceName[] = "org.gnome.SessionManager";
 const char kGnomeAPIObjectPath[] = "/org/gnome/SessionManager";
 
 const char kFreeDesktopAPIServiceName[] = "org.freedesktop.PowerManagement";
 const char kFreeDesktopAPIInterfaceName[] =
     "org.freedesktop.PowerManagement.Inhibit";
 const char kFreeDesktopAPIObjectPath[] =
     "/org/freedesktop/PowerManagement/Inhibit";
 
-}  // anonymous namespace
+class PowerSaveBlockerLinux : public PowerSaveBlocker {
+ public:
+  PowerSaveBlockerLinux(PowerSaveBlockerType type, const std::string& reason);
+  virtual ~PowerSaveBlockerLinux();
 
-namespace content {
+ private:
+  class Delegate;
 
-class PowerSaveBlocker::Delegate
-    : public base::RefCountedThreadSafe<PowerSaveBlocker::Delegate> {
+  // A second object with different lifetime than the RAII container.
+  scoped_refptr<Delegate> delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(PowerSaveBlockerLinux);
+};
+
+class PowerSaveBlockerLinux::Delegate
+    : public base::RefCountedThreadSafe<PowerSaveBlockerLinux::Delegate> {
  public:
   // Picks an appropriate D-Bus API to use based on the desktop environment.
   Delegate(PowerSaveBlockerType type, const std::string& reason);
 
   // 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.
   void Init();
 
   // Post a task to remove the power save block on the FILE thread, unless it
   // hasn't yet been applied, in which case we just prevent it from applying.
@@ skipping 39 matching lines @@
 
   scoped_refptr<dbus::Bus> bus_;
 
   // The cookie that identifies our inhibit request,
   // or 0 if there is no active inhibit request.
   uint32 inhibit_cookie_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
-PowerSaveBlocker::Delegate::Delegate(PowerSaveBlockerType type,
+PowerSaveBlockerLinux::Delegate::Delegate(PowerSaveBlockerType type,
                                      const std::string& reason)
     : type_(type),
       reason_(reason),
       api_(NO_API),
       enqueue_apply_(false),
       inhibit_cookie_(0) {
   // 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 PowerSaveBlocker::Delegate::Init() {
+void PowerSaveBlockerLinux::Delegate::Init() {
   base::AutoLock lock(lock_);
   DCHECK(!enqueue_apply_);
   enqueue_apply_ = true;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&Delegate::InitOnUIThread, this));
 }
 
-void PowerSaveBlocker::Delegate::CleanUp() {
+void PowerSaveBlockerLinux::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 (api_ != NO_API) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                             base::Bind(&Delegate::RemoveBlock, this, api_));
   }
 }
 
-void PowerSaveBlocker::Delegate::InitOnUIThread() {
+void PowerSaveBlockerLinux::Delegate::InitOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
   api_ = SelectAPI();
   if (enqueue_apply_ && api_ != NO_API) {
     // 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.
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                             base::Bind(&Delegate::ApplyBlock, this, api_));
   }
   enqueue_apply_ = false;
 }
 
-void PowerSaveBlocker::Delegate::ApplyBlock(DBusAPI api) {
+void PowerSaveBlockerLinux::Delegate::ApplyBlock(DBusAPI api) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(!bus_.get());  // ApplyBlock() should only be called once.
 
   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;
   scoped_ptr<dbus::MethodCall> method_call;
@@ skipping 59 matching lines @@
     // this request. It should be used as an argument to Uninhibit()
     // in order to remove the request.
     dbus::MessageReader message_reader(response.get());
     if (!message_reader.PopUint32(&inhibit_cookie_))
       LOG(ERROR) << "Invalid Inhibit() response: " << response->ToString();
   } else {
     LOG(ERROR) << "No response to Inhibit() request!";
   }
 }
 
-void PowerSaveBlocker::Delegate::RemoveBlock(DBusAPI api) {
+void PowerSaveBlockerLinux::Delegate::RemoveBlock(DBusAPI api) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(bus_.get());  // RemoveBlock() should only be called once.
 
   scoped_refptr<dbus::ObjectProxy> object_proxy;
   scoped_ptr<dbus::MethodCall> method_call;
 
   switch (api) {
     case NO_API:
       NOTREACHED();  // We should never call this method with this value.
       return;
@@ skipping 21 matching lines @@
     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_ = NULL;
 }
 
 // static
-bool PowerSaveBlocker::Delegate::DPMSEnabled() {
+bool PowerSaveBlockerLinux::Delegate::DPMSEnabled() {
   Display* display = base::MessagePumpForUI::GetDefaultXDisplay();
   BOOL enabled = false;
   int dummy;
   if (DPMSQueryExtension(display, &dummy, &dummy) && DPMSCapable(display)) {
     CARD16 state;
     DPMSInfo(display, &state, &enabled);
   }
   return enabled;
 }
 
 // static
-DBusAPI PowerSaveBlocker::Delegate::SelectAPI() {
+DBusAPI PowerSaveBlockerLinux::Delegate::SelectAPI() {
   scoped_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:
       if (DPMSEnabled())
         return FREEDESKTOP_API;
       break;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_OTHER:
       // Not supported.
       break;
   }
   return NO_API;
 }
 
-PowerSaveBlocker::PowerSaveBlocker(
+PowerSaveBlockerLinux::PowerSaveBlockerLinux(
     PowerSaveBlockerType type, const std::string& reason)
     : delegate_(new Delegate(type, reason)) {
   delegate_->Init();
 }
 
-PowerSaveBlocker::~PowerSaveBlocker() {
+PowerSaveBlockerLinux::~PowerSaveBlockerLinux() {
   delegate_->CleanUp();
 }
 
+}  // namespace
+
+// static
+scoped_ptr<PowerSaveBlocker> PowerSaveBlocker::Create(
+    PowerSaveBlockerType type,
+    const std::string& reason) {
+  return scoped_ptr<PowerSaveBlocker>(new PowerSaveBlockerLinux(type, reason));
+}
+
 }  // namespace content