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 kPowerAssertionTimeoutMs = 5 * 1000; // 5 seconds
+
 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 RefreshPowerAssertion();
+  void ReleasePowerAssertion();
+
   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 power_assertion_id_;
+
+  // Timer to remove the power management assertion on inactivity
+  base::OneShotTimer<CapturerMac> power_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),
+      power_assertion_id_(kIOPMNullAssertionID) {
 }
 
 CapturerMac::~CapturerMac() {
   ReleaseBuffers();
   CGUnregisterScreenRefreshCallback(CapturerMac::ScreenRefreshCallback, this);
   CGScreenUnregisterMoveCallback(CapturerMac::ScreenUpdateMoveCallback, this);
   CGError err = CGDisplayRemoveReconfigurationCallback(
       CapturerMac::DisplaysReconfiguredCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGDisplayRemoveReconfigurationCallback " << err;
   }
+  ReleasePowerAssertion();
 }
 
 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;
 
+  RefreshPowerAssertion();
+
   // 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::RefreshPowerAssertion() {
+  if (power_assertion_timer_.IsRunning()) {
+    DCHECK(power_assertion_id_ != kIOPMNullAssertionID);
+    power_assertion_timer_.Reset();
+    return;
+  }
+
+  IOReturn result = IOPMAssertionCreate(kIOPMAssertionTypeNoDisplaySleep,
+                                        kIOPMAssertionLevelOn,
+                                        &power_assertion_id_);
+
+  if (result == kIOReturnSuccess) {
+    power_assertion_timer_.Start(FROM_HERE,
+                                 base::TimeDelta::FromMilliseconds(
+                                     kPowerAssertionTimeoutMs),
+                                 this,
+                                 &CapturerMac::ReleasePowerAssertion);
+  }
+}
+
+void CapturerMac::ReleasePowerAssertion() {
+  if (power_assertion_id_ != kIOPMNullAssertionID) {
+    IOPMAssertionRelease(power_assertion_id_);
+    power_assertion_id_ = kIOPMNullAssertionID;
+    power_assertion_timer_.Stop();
+  }
+}
+
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   CapturerMac* capturer = new CapturerMac();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting