Awake Mac host display when remote session starts.

remoting/host/capturer_mac.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 "remoting/host/capturer.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <dlfcn.h>
+#include <IOKit/pwr_mgt/IOPMLib.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/time.h"
+#include "base/timer.h"
 #include "remoting/base/util.h"
 #include "remoting/host/capturer_helper.h"
 
 
 namespace remoting {
 
 namespace {
 
+const int64 kPMAssertionTimeoutMs = 5 * 1000; // 30 seconds

[Wez, 2012/04/14 00:08:22]

This looks like five seconds, not thirty?

[Wez, 2012/04/14 00:08:22]

See note below re naming.

[dcaiafa, 2012/04/14 00:21:41]

Done.

[dcaiafa, 2012/04/14 00:21:41]

Done.

+
 SkIRect CGRectToSkIRect(const CGRect& rect) {
   SkIRect sk_rect = {
     SkScalarRound(rect.origin.x),
     SkScalarRound(rect.origin.y),
     SkScalarRound(rect.origin.x + rect.size.width),
     SkScalarRound(rect.origin.y + rect.size.height)
   };
   return sk_rect;
 }
 
@@ skipping 149 matching lines @@
                                     void *user_parameter);
   static void ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
                                        size_t count,
                                        const CGRect *rect_array,
                                        void *user_parameter);
   static void DisplaysReconfiguredCallback(CGDirectDisplayID display,
                                            CGDisplayChangeSummaryFlags flags,
                                            void *user_parameter);
 
   void ReleaseBuffers();
+  void RefreshPowerManagementAssertion();
+  void ReleasePowerManagementAssertion();
+
   CGLContextObj cgl_context_;
   static const int kNumBuffers = 2;
   scoped_pixel_buffer_object pixel_buffer_object_;
   VideoFrameBuffer buffers_[kNumBuffers];
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   CapturerHelper helper_;
 
   // The current buffer with valid data for reading.
   int current_buffer_;
 
   // The previous buffer into which we captured, or NULL for the first capture
   // for a particular screen resolution.
   uint8* last_buffer_;
 
   // Contains an invalid region from the previous capture.
   SkRegion last_invalid_region_;
 
   // Format of pixels returned in buffer.
   media::VideoFrame::Format pixel_format_;
 
   // Acts as a critical section around our display configuration data
   // structures. Specifically cgl_context_ and pixel_buffer_object_.
   base::WaitableEvent display_configuration_capture_event_;
 
   // Will be non-null on lion.
   CGDisplayCreateImageFunc display_create_image_func_;
 
+  // Power management assertion to prevent the screen from sleeping.
+  IOPMAssertionID pm_assertion_id_;

[Wez, 2012/04/14 00:08:22]

Style guide requires that names not be abbreviated unless the abbreviation is
well established - consider changing this to power_assertion_id, and renaming
the methods to Refresh/ReleasePowerAssertion.

[dcaiafa, 2012/04/14 00:21:41]

Done.

+
+  // Indicates that a power management assertion was created and that
+  // pm_assertion_id_ is valid.
+  bool pm_assertion_created_;

[Wez, 2012/04/14 00:08:22]

Why not just check whether the timer is started, rather than keeping a separate
flag?

[dcaiafa, 2012/04/14 00:21:41]

Because when ReleasePowerAssertion is called by the timer, the timer will have
been stopped.

On 2012/04/14 00:08:22, Wez wrote:

[Wez, 2012/04/14 00:24:39]

OK.  Is zero a valid power management assertion Id?  If not then testing the Id
for being zero would avoid the need for the separate flag.

On 2012/04/14 00:21:41, dcaiafa wrote:

[dcaiafa, 2012/04/14 00:37:43]

Turns out that there is a constant called kIOPMNullAssertionID. I failed to find
it in my first look at the headers.

On 2012/04/14 00:24:39, Wez wrote:

+
+  // Timer to remove the power management assertion on inactivity
+  base::OneShotTimer<CapturerMac> pm_assertion_timer_;
+
   DISALLOW_COPY_AND_ASSIGN(CapturerMac);
 };
 
 CapturerMac::CapturerMac()
     : cgl_context_(NULL),
       current_buffer_(0),
       last_buffer_(NULL),
       pixel_format_(media::VideoFrame::RGB32),
       display_configuration_capture_event_(false, true),
-      display_create_image_func_(NULL) {
+      display_create_image_func_(NULL),
+      pm_assertion_id_(0),
+      pm_assertion_created_(false) {
 }
 
 CapturerMac::~CapturerMac() {
   ReleaseBuffers();
   CGUnregisterScreenRefreshCallback(CapturerMac::ScreenRefreshCallback, this);
   CGScreenUnregisterMoveCallback(CapturerMac::ScreenUpdateMoveCallback, this);
   CGError err = CGDisplayRemoveReconfigurationCallback(
       CapturerMac::DisplaysReconfiguredCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGDisplayRemoveReconfigurationCallback " << err;
   }
+  ReleasePowerManagementAssertion();
 }
 
 bool CapturerMac::Init() {
   CGError err =
       CGRegisterScreenRefreshCallback(CapturerMac::ScreenRefreshCallback,
                                       this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGRegisterScreenRefreshCallback " << err;
     return false;
   }
@@ skipping 98 matching lines @@
 
 void CapturerMac::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
 }
 
 void CapturerMac::CaptureInvalidRegion(
     const CaptureCompletedCallback& callback) {
   // Only allow captures when the display configuration is not occurring.
   scoped_refptr<CaptureData> data;
 
+  RefreshPowerManagementAssertion();
+
   // Critical section shared with DisplaysReconfigured(...).
   CHECK(display_configuration_capture_event_.TimedWait(
       base::TimeDelta::FromSeconds(kDisplayReconfigurationTimeoutInSeconds)));
   SkRegion region;
   helper_.SwapInvalidRegion(&region);
   VideoFrameBuffer& current_buffer = buffers_[current_buffer_];
   current_buffer.Update();
 
   bool flip = false;  // GL capturers need flipping.
   if (display_create_image_func_ != NULL) {
@@ skipping 246 matching lines @@
 }
 
 void CapturerMac::DisplaysReconfiguredCallback(
     CGDirectDisplayID display,
     CGDisplayChangeSummaryFlags flags,
     void *user_parameter) {
   CapturerMac *capturer = reinterpret_cast<CapturerMac *>(user_parameter);
   capturer->DisplaysReconfigured(display, flags);
 }
 
+// Creates or refreshes a power management assertion to prevent the display from
+// going to sleep.
+void CapturerMac::RefreshPowerManagementAssertion() {
+  if (pm_assertion_timer_.IsRunning()) {
+    DCHECK(pm_assertion_created_);
+    pm_assertion_timer_.Reset();
+    return;
+  }
+
+  IOReturn result = IOPMAssertionCreateWithName(
+      kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn,
+      CFSTR("Chromoting"), &pm_assertion_id_);
+
+  if (result == kIOReturnSuccess) {
+    pm_assertion_created_ = true;
+    pm_assertion_timer_.Start(FROM_HERE,
+                              base::TimeDelta::FromMilliseconds(
+                                  kPMAssertionTimeoutMs),
+                              this,
+                              &CapturerMac::ReleasePowerManagementAssertion);
+  }
+}
+
+void CapturerMac::ReleasePowerManagementAssertion() {
+  if (pm_assertion_created_) {
+    IOPMAssertionRelease(pm_assertion_id_);
+    pm_assertion_id_ = 0;

[Wez, 2012/04/14 00:08:22]

nit: Zeroing this when it's not started effectively duplicates the
pm_assertion_created_ flag's function, and since you never DCHECK()
pm_assertion_id_ there's no real need to zero it here.

[dcaiafa, 2012/04/14 00:21:41]

Done.

+    pm_assertion_created_ = false;
+    pm_assertion_timer_.Stop();
+  }
+}
+
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   CapturerMac* capturer = new CapturerMac();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting