Update for OS X 10.6 SDK.

remoting/host/video_frame_capturer_mac.mm

 // 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/video_frame_capturer.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
@@ skipping 19 matching lines @@
 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;
 }
 
-#if (MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_5)
-// Possibly remove VideoFrameCapturerMac::CgBlitPreLion as well depending on
-// performance of VideoFrameCapturerMac::CgBlitPostLion on 10.6.
-#error No longer need to import CGDisplayCreateImage.
-#else
-// Declared here because CGDisplayCreateImage does not exist in the 10.5 SDK,
-// which we are currently compiling against, and it is required on 10.7 to do
-// screen capture.
-typedef CGImageRef (*CGDisplayCreateImageFunc)(CGDirectDisplayID displayID);
-#endif
-
 // The amount of time allowed for displays to reconfigure.
 const int64 kDisplayReconfigurationTimeoutInSeconds = 10;
 
 class scoped_pixel_buffer_object {
  public:
   scoped_pixel_buffer_object();
   ~scoped_pixel_buffer_object();
 
   bool Init(CGLContextObj cgl_context, int size_in_bytes);
   void Release();
@@ skipping 175 matching lines @@
   // 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_display_;
 
   // Power management assertion to indicate that the user is active.
   IOPMAssertionID power_assertion_id_user_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerMac);
 };
 
 VideoFrameCapturerMac::VideoFrameCapturerMac()
     : 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),
       power_assertion_id_display_(kIOPMNullAssertionID),
       power_assertion_id_user_(kIOPMNullAssertionID) {
 }
 
 VideoFrameCapturerMac::~VideoFrameCapturerMac() {
   ReleaseBuffers();
   CGUnregisterScreenRefreshCallback(
       VideoFrameCapturerMac::ScreenRefreshCallback, this);
   CGScreenUnregisterMoveCallback(
       VideoFrameCapturerMac::ScreenUpdateMoveCallback, this);
@@ skipping 18 matching lines @@
     LOG(ERROR) << "CGScreenRegisterMoveCallback " << err;
     return false;
   }
   err = CGDisplayRegisterReconfigurationCallback(
       VideoFrameCapturerMac::DisplaysReconfiguredCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGDisplayRegisterReconfigurationCallback " << err;
     return false;
   }
 
-  if (base::mac::IsOSLionOrLater()) {
-    display_create_image_func_ =
-        reinterpret_cast<CGDisplayCreateImageFunc>(
-            dlsym(RTLD_NEXT, "CGDisplayCreateImage"));
-    if (!display_create_image_func_) {
-      LOG(ERROR) << "Unable to load CGDisplayCreateImage on Lion";
-      return false;
-    }
-  }
   ScreenConfigurationChanged();
   return true;
 }
 
 void VideoFrameCapturerMac::ReleaseBuffers() {
   if (cgl_context_) {
     pixel_buffer_object_.Release();
     CGLDestroyContext(cgl_context_);
     cgl_context_ = NULL;
   }
   // The buffers might be in use by the encoder, so don't delete them here.
   // Instead, mark them as "needs update"; next time the buffers are used by
   // the capturer, they will be recreated if necessary.
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
 }
 
 void VideoFrameCapturerMac::Start(const CursorShapeChangedCallback& callback) {
   cursor_shape_changed_callback_ = callback;
 
   // Create power management assertions to wake the display and prevent it from
   // going to sleep on user idle.
-  IOPMAssertionCreate(kIOPMAssertionTypeNoDisplaySleep,
-                      kIOPMAssertionLevelOn,
-                      &power_assertion_id_display_);
-  IOPMAssertionCreate(CFSTR("UserIsActive"),
-                      kIOPMAssertionLevelOn,
-                      &power_assertion_id_user_);
+  // TODO(jamiewalch): Use IOPMAssertionDeclareUserActivity on 10.7.3 and above
+  //                   instead of the following two assertions.
+  IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep,
+                              kIOPMAssertionLevelOn,
+                              CFSTR("Chrome Remote Desktop connection active"),
+                              &power_assertion_id_display_);
+  // This assertion ensures that the display is woken up if it  already asleep
+  // (as used by Apple Remote Desktop).
+  IOPMAssertionCreateWithName(CFSTR("UserIsActive"),
+                              kIOPMAssertionLevelOn,
+                              CFSTR("Chrome Remote Desktop connection active"),
+                              &power_assertion_id_user_);
 }
 
 void VideoFrameCapturerMac::Stop() {
   if (power_assertion_id_display_ != kIOPMNullAssertionID) {
     IOPMAssertionRelease(power_assertion_id_display_);
     power_assertion_id_display_ = kIOPMNullAssertionID;
   }
   if (power_assertion_id_user_ != kIOPMNullAssertionID) {
     IOPMAssertionRelease(power_assertion_id_user_);
     power_assertion_id_user_ = kIOPMNullAssertionID;
@@ skipping 15 matching lines @@
 
   // 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) {
-    // Lion requires us to use their new APIs for doing screen capture.
+  if (base::mac::IsOSLionOrLater()) {
+    // Lion requires us to use their new APIs for doing screen capture. These
+    // APIS currently crash on 10.6.8 if there is no monitor attached.
     CgBlitPostLion(current_buffer, region);
   } else if (cgl_context_) {
     flip = true;
     if (pixel_buffer_object_.get() != 0) {
       GlBlitFast(current_buffer, region);
     } else {
       // See comment in scoped_pixel_buffer_object::Init about why the slow
       // path is always used on 10.5.
       GlBlitSlow(current_buffer);
     }
@@ skipping 196 matching lines @@
   const int buffer_height = buffer.size().height();
   const int buffer_width = buffer.size().width();
 
     // Clip to the size of our current screen.
   SkIRect clip_rect = SkIRect::MakeWH(buffer_width, buffer_height);
 
   if (last_buffer_)
     memcpy(buffer.ptr(), last_buffer_, buffer.bytes_per_row() * buffer_height);
   last_buffer_ = buffer.ptr();
   CGDirectDisplayID main_display = CGMainDisplayID();
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
   uint8* display_base_address =
       reinterpret_cast<uint8*>(CGDisplayBaseAddress(main_display));
   CHECK(display_base_address);
   int src_bytes_per_row = CGDisplayBytesPerRow(main_display);
   int src_bytes_per_pixel = CGDisplayBitsPerPixel(main_display) / 8;
+#pragma clang diagnostic pop
   // TODO(hclam): We can reduce the amount of copying here by subtracting
   // |capturer_helper_|s region from |last_invalid_region_|.
   // http://crbug.com/92354
   for(SkRegion::Iterator i(region); !i.done(); i.next()) {
     SkIRect copy_rect = i.rect();
     if (copy_rect.intersect(clip_rect)) {
       CopyRect(display_base_address,
                src_bytes_per_row,
                buffer.ptr(),
                buffer.bytes_per_row(),
                src_bytes_per_pixel,
                copy_rect);
     }
   }
 }
 
 void VideoFrameCapturerMac::CgBlitPostLion(const VideoFrameBuffer& buffer,
                                            const SkRegion& region) {
   const int buffer_height = buffer.size().height();
   const int buffer_width = buffer.size().width();
 
   // Clip to the size of our current screen.
   SkIRect clip_rect = SkIRect::MakeWH(buffer_width, buffer_height);
 
   if (last_buffer_)
     memcpy(buffer.ptr(), last_buffer_, buffer.bytes_per_row() * buffer_height);
   last_buffer_ = buffer.ptr();
   CGDirectDisplayID display = CGMainDisplayID();
   base::mac::ScopedCFTypeRef<CGImageRef> image(
-      display_create_image_func_(display));
+      CGDisplayCreateImage(display));
   if (image.get() == NULL)
     return;
   CGDataProviderRef provider = CGImageGetDataProvider(image);
   base::mac::ScopedCFTypeRef<CFDataRef> data(CGDataProviderCopyData(provider));
   if (data.get() == NULL)
     return;
   const uint8* display_base_address = CFDataGetBytePtr(data);
   int src_bytes_per_row = CGImageGetBytesPerRow(image);
   int src_bytes_per_pixel = CGImageGetBitsPerPixel(image) / 8;
   // TODO(hclam): We can reduce the amount of copying here by subtracting
@@ skipping 19 matching lines @@
 void VideoFrameCapturerMac::ScreenConfigurationChanged() {
   ReleaseBuffers();
   helper_.ClearInvalidRegion();
   last_buffer_ = NULL;
 
   CGDirectDisplayID mainDevice = CGMainDisplayID();
   int width = CGDisplayPixelsWide(mainDevice);
   int height = CGDisplayPixelsHigh(mainDevice);
   helper_.InvalidateScreen(SkISize::Make(width, height));
 
-  if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
-    VLOG(3) << "OpenGL support not available.";
-    return;
-  }
-
-  if (display_create_image_func_ != NULL) {
+  if (base::mac::IsOSLionOrLater()) {
+    LOG(INFO) << "Using CgBlitPostLion.";
     // No need for any OpenGL support on Lion
     return;
   }
 
+  if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
+    LOG(INFO) << "Using CgBlitPreLion.";
+    return;
+  }
+
+  LOG(INFO) << "Using GlBlit";
+
   CGLPixelFormatAttribute attributes[] = {
     kCGLPFAFullScreen,
     kCGLPFADisplayMask,
     (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(mainDevice),
     (CGLPixelFormatAttribute)0
   };
   CGLPixelFormatObj pixel_format = NULL;
   GLint matching_pixel_format_count = 0;
   CGLError err = CGLChoosePixelFormat(attributes,
                                       &pixel_format,
                                       &matching_pixel_format_count);
   DCHECK_EQ(err, kCGLNoError);
   err = CGLCreateContext(pixel_format, NULL, &cgl_context_);
   DCHECK_EQ(err, kCGLNoError);
   CGLDestroyPixelFormat(pixel_format);
-  CGLSetFullScreen(cgl_context_);
+  CGLSetFullScreenOnDisplay(cgl_context_,
+                            CGDisplayIDToOpenGLDisplayMask(mainDevice));
   CGLSetCurrentContext(cgl_context_);
 
   size_t buffer_size = width * height * sizeof(uint32_t);
   pixel_buffer_object_.Init(cgl_context_, buffer_size);
 }
 
 void VideoFrameCapturerMac::ScreenRefresh(CGRectCount count,
                                           const CGRect* rect_array) {
   SkIRect skirect_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
@@ skipping 70 matching lines @@
 VideoFrameCapturer* VideoFrameCapturer::Create() {
   VideoFrameCapturerMac* capturer = new VideoFrameCapturerMac();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting