Use PowerSaveBlocker for audio and video on Chrome OS.

content/browser/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 "content/browser/power_save_blocker_impl.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
@@ skipping 49 matching lines @@
     "/org/freedesktop/PowerManagement/Inhibit";
 
 }  // namespace
 
 namespace content {
 
 class PowerSaveBlockerImpl::Delegate
     : public base::RefCountedThreadSafe<PowerSaveBlockerImpl::Delegate> {
  public:
   // Picks an appropriate D-Bus API to use based on the desktop environment.
-  Delegate(PowerSaveBlockerType type, const std::string& reason);
+  Delegate(PowerSaveBlockerType type, const std::string& description);
 
   // 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.
   void CleanUp();
 
  private:
@@ skipping 16 matching lines @@
   // to try to disable power saving, since on some desktop environments that may
   // enable DPMS with very poor default settings (e.g. turning off the display
   // after only 1 second). Must be called on the UI thread.
   static bool DPMSEnabled();
 
   // Returns an appropriate D-Bus API to use based on the desktop environment.
   // Must be called on the UI thread, as it may call DPMSEnabled() above.
   static DBusAPI SelectAPI();
 
   const PowerSaveBlockerType type_;
-  const std::string reason_;
+  const std::string description_;
 
   // Initially, we post a message to the UI thread to select an API. When it
   // finishes, it will post a message to the FILE thread to perform the actual
   // application of the block, unless enqueue_apply_ is false. We set it to
   // false when we post that message, or when RemoveBlock() is called before
   // ApplyBlock() has run. Both api_ and enqueue_apply_ are guarded by lock_.
   DBusAPI api_;
   bool enqueue_apply_;
   base::Lock lock_;
 
   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);
 };
 
 PowerSaveBlockerImpl::Delegate::Delegate(PowerSaveBlockerType type,
-                                         const std::string& reason)
+                                         const std::string& description)
     : type_(type),
-      reason_(reason),
+      description_(description),
       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 PowerSaveBlockerImpl::Delegate::Init() {
   base::AutoLock lock(lock_);
   DCHECK(!enqueue_apply_);
@@ skipping 54 matching lines @@
           new dbus::MethodCall(kGnomeAPIInterfaceName, "Inhibit"));
       message_writer.reset(new dbus::MessageWriter(method_call.get()));
       // The arguments of the method are:
       //     app_id:        The application identifier
       //     toplevel_xid:  The toplevel X window identifier
       //     reason:        The reason for the inhibit
       //     flags:         Flags that spefify what should be inhibited
       message_writer->AppendString(
           base::CommandLine::ForCurrentProcess()->GetProgram().value());
       message_writer->AppendUint32(0);  // should be toplevel_xid
-      message_writer->AppendString(reason_);
+      message_writer->AppendString(description_);
       {
         uint32 flags = 0;
         switch (type_) {
           case kPowerSaveBlockPreventDisplaySleep:
             flags |= INHIBIT_MARK_SESSION_IDLE;
             flags |= INHIBIT_SUSPEND_SESSION;
             break;
           case kPowerSaveBlockPreventAppSuspension:
             flags |= INHIBIT_SUSPEND_SESSION;
             break;
         }
         message_writer->AppendUint32(flags);
       }
       break;
     case FREEDESKTOP_API:
       object_proxy = bus_->GetObjectProxy(
           kFreeDesktopAPIServiceName,
           dbus::ObjectPath(kFreeDesktopAPIObjectPath));
       method_call.reset(
           new dbus::MethodCall(kFreeDesktopAPIInterfaceName, "Inhibit"));
       message_writer.reset(new dbus::MessageWriter(method_call.get()));
       // The arguments of the method are:
       //     app_id:        The application identifier
       //     reason:        The reason for the inhibit
       message_writer->AppendString(
           base::CommandLine::ForCurrentProcess()->GetProgram().value());
-      message_writer->AppendString(reason_);
+      message_writer->AppendString(description_);
       break;
   }
 
   // We could do this method call asynchronously, but if we did, we'd need to
   // handle the case where we want to cancel the block before we get a reply.
   // We're on the FILE thread so it should be OK to block briefly here.
   scoped_ptr<dbus::Response> response(object_proxy->CallMethodAndBlock(
       method_call.get(), dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (response) {
     // The method returns an inhibit_cookie, used to uniquely identify
@@ skipping 75 matching lines @@
         return FREEDESKTOP_API;
       break;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_OTHER:
       // Not supported.
       break;
   }
   return NO_API;
 }
 
-PowerSaveBlockerImpl::PowerSaveBlockerImpl(
-    PowerSaveBlockerType type, const std::string& reason)
-    : delegate_(new Delegate(type, reason)) {
+PowerSaveBlockerImpl::PowerSaveBlockerImpl(PowerSaveBlockerType type,
+                                           Reason reason,
+                                           const std::string& description)
+    : delegate_(new Delegate(type, description)) {
   delegate_->Init();
 }
 
 PowerSaveBlockerImpl::~PowerSaveBlockerImpl() {
   delegate_->CleanUp();
 }
 
 }  // namespace content