Several fixes to screen capturer mac.

webrtc/modules/desktop_capture/screen_capturer_mac.mm

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 22 matching lines @@
 #include "webrtc/modules/desktop_capture/desktop_region.h"
 #include "webrtc/modules/desktop_capture/mac/desktop_configuration.h"
 #include "webrtc/modules/desktop_capture/mac/desktop_configuration_monitor.h"
 #include "webrtc/modules/desktop_capture/mac/scoped_pixel_buffer_object.h"
 #include "webrtc/modules/desktop_capture/screen_capture_frame_queue.h"
 #include "webrtc/modules/desktop_capture/screen_capturer_differ_wrapper.h"
 #include "webrtc/modules/desktop_capture/screen_capturer_helper.h"
 #include "webrtc/modules/desktop_capture/shared_desktop_frame.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
+// Once Chrome no longer supports OSX 10.8, everything within this
+// preprocessor block can be removed. https://crbug.com/579255
+#if !defined(MAC_OS_X_VERSION_10_9) || \
+    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_9
+CG_EXTERN const CGRect* CGDisplayStreamUpdateGetRects(
+    CGDisplayStreamUpdateRef updateRef,
+    CGDisplayStreamUpdateRectType rectType,
+    size_t* rectCount);
+CG_EXTERN CFRunLoopSourceRef
+CGDisplayStreamGetRunLoopSource(CGDisplayStreamRef displayStream);
+CG_EXTERN CGError CGDisplayStreamStop(CGDisplayStreamRef displayStream);
+CG_EXTERN CGError CGDisplayStreamStart(CGDisplayStreamRef displayStream);
+CG_EXTERN CGDisplayStreamRef
+CGDisplayStreamCreate(CGDirectDisplayID display,
+                      size_t outputWidth,
+                      size_t outputHeight,
+                      int32_t pixelFormat,
+                      CFDictionaryRef properties,
+                      CGDisplayStreamFrameAvailableHandler handler);
+#endif
+
 namespace webrtc {
 
 namespace {
 
 // CGDisplayStreamRefs need to be destroyed asynchronously after receiving a
 // kCGDisplayStreamFrameStatusStopped callback from CoreGraphics. This may
 // happen after the ScreenCapturerMac has been destroyed. DisplayStreamManager
 // is responsible for destroying all extant CGDisplayStreamRefs, and will
 // destroy itself once it's done.
 class DisplayStreamManager {
  public:
   int GetUniqueId() { return ++unique_id_generator_; }
   void DestroyStream(int unique_id) {
     auto it = display_stream_wrappers_.find(unique_id);
     RTC_CHECK(it != display_stream_wrappers_.end());
     RTC_CHECK(!it->second.active);
     CFRelease(it->second.stream);
     display_stream_wrappers_.erase(it);
 
     if (ready_for_self_destruction_ && display_stream_wrappers_.empty())
       delete this;
   }
 
-  void SaveStream(int unique_id, CGDisplayStreamRef stream) {
+  void SaveStream(int unique_id,
+                  CGDisplayStreamRef stream) {
     RTC_CHECK(unique_id <= unique_id_generator_);
     DisplayStreamWrapper wrapper;
     wrapper.stream = stream;
     display_stream_wrappers_[unique_id] = wrapper;
   }
 
   void UnregisterActiveStreams() {
     for (auto& pair : display_stream_wrappers_) {
       DisplayStreamWrapper& wrapper = pair.second;
       if (wrapper.active) {
         wrapper.active = false;
-// CGDisplayStream* functions are only available in 10.8+. Chrome only supports
-// 10.9+, but we can't remove these warning suppressions until the deployment
-// target is updated. https://crbug.com/579255
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
+        CFRunLoopSourceRef source =
+            CGDisplayStreamGetRunLoopSource(wrapper.stream);
+        CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source,
+                              kCFRunLoopDefaultMode);
         CGDisplayStreamStop(wrapper.stream);
-#pragma clang diagnostic pop
       }
     }
   }
 
   void PrepareForSelfDestruction() {
     ready_for_self_destruction_ = true;
 
     if (display_stream_wrappers_.empty())
       delete this;
   }
@@ skipping 185 matching lines @@
   bool CgBlitPostLion(const DesktopFrame& frame,
                       const DesktopRegion& region);
 
   // Called when the screen configuration is changed.
   void ScreenConfigurationChanged();
 
   bool RegisterRefreshAndMoveHandlers();
   void UnregisterRefreshAndMoveHandlers();
 
   void ScreenRefresh(CGRectCount count, const CGRect *rect_array);
-  void ScreenUpdateMove(CGFloat delta_x,
-                        CGFloat delta_y,
-                        size_t count,
-                        const CGRect* rect_array);
-  void ScreenRefreshCallback(CGRectCount count, const CGRect* rect_array);
   void ReleaseBuffers();
 
   std::unique_ptr<DesktopFrame> CreateFrame();
 
   Callback* callback_ = nullptr;
 
   CGLContextObj cgl_context_ = nullptr;
   ScopedPixelBufferObject pixel_buffer_object_;
 
   // Queue of the frames buffers.
@@ skipping 613 matching lines @@
   pixel_buffer_object_.Init(cgl_context_, buffer_size);
 }
 
 bool ScreenCapturerMac::RegisterRefreshAndMoveHandlers() {
   desktop_config_ = desktop_config_monitor_->desktop_configuration();
   for (const auto& config : desktop_config_.displays) {
     size_t pixel_width = config.pixel_bounds.width();
     size_t pixel_height = config.pixel_bounds.height();
     if (pixel_width == 0 || pixel_height == 0)
       continue;
-    int unique_id = display_stream_manager_->GetUniqueId();
+    // Using a local variable forces the block to capture the raw pointer.
+    DisplayStreamManager* manager = display_stream_manager_;
+    int unique_id = manager->GetUniqueId();
     CGDirectDisplayID display_id = config.id;
     CGDisplayStreamFrameAvailableHandler handler =
         ^(CGDisplayStreamFrameStatus status, uint64_t display_time,
           IOSurfaceRef frame_surface, CGDisplayStreamUpdateRef updateRef) {
           if (status == kCGDisplayStreamFrameStatusStopped) {
-            display_stream_manager_->DestroyStream(unique_id);
+            manager->DestroyStream(unique_id);
             return;
           }
 
-          if (display_stream_manager_->ShouldIgnoreUpdates())
+          if (manager->ShouldIgnoreUpdates())
             return;
 
           // Only pay attention to frame updates.
           if (status != kCGDisplayStreamFrameStatusFrameComplete)
             return;
 
           size_t count = 0;
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
-// TODO(erikchen): Use kCGDisplayStreamUpdateDirtyRects.
           const CGRect* rects = CGDisplayStreamUpdateGetRects(
-              updateRef, kCGDisplayStreamUpdateMovedRects, &count);
-#pragma clang diagnostic pop
-          if (count != 0) {
-            CGFloat dx = 0;
-            CGFloat dy = 0;
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
-            CGDisplayStreamUpdateGetMovedRectsDelta(updateRef, &dx, &dy);
-#pragma clang diagnostic pop
-            ScreenUpdateMove(dx, dy, count, rects);
-          }
-
-          count = 0;
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
-          rects = CGDisplayStreamUpdateGetRects(
-              updateRef, kCGDisplayStreamUpdateRefreshedRects, &count);
-#pragma clang diagnostic pop
+              updateRef, kCGDisplayStreamUpdateDirtyRects, &count);
           if (count != 0) {
             // According to CGDisplayStream.h, it's safe to call
             // CGDisplayStreamStop() from within the callback.
-            ScreenRefreshCallback(count, rects);
+            ScreenRefresh(count, rects);
           }
         };
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
     CGDisplayStreamRef display_stream = CGDisplayStreamCreate(
         display_id, pixel_width, pixel_height, 'BGRA', nullptr, handler);
-#pragma clang diagnostic pop
+
     if (display_stream) {
+      CGError error = CGDisplayStreamStart(display_stream);
+      if (error != kCGErrorSuccess)
+        return false;
+
+      CFRunLoopSourceRef source =
+          CGDisplayStreamGetRunLoopSource(display_stream);
+      CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
       display_stream_manager_->SaveStream(unique_id, display_stream);
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunguarded-availability"
-      CGDisplayStreamStart(display_stream);
-#pragma clang diagnostic pop
     }
   }
 
   return true;
 }
 
 void ScreenCapturerMac::UnregisterRefreshAndMoveHandlers() {
   display_stream_manager_->UnregisterActiveStreams();
 }
 
 void ScreenCapturerMac::ScreenRefresh(CGRectCount count,
                                       const CGRect* rect_array) {
   if (screen_pixel_bounds_.is_empty())
-    return;
+    ScreenConfigurationChanged();
 
   DesktopRegion region;
   DesktopVector translate_vector =
       DesktopVector().subtract(screen_pixel_bounds_.top_left());
   for (CGRectCount i = 0; i < count; ++i) {
     // Convert from Density-Independent Pixel to physical pixel coordinates.
     DesktopRect rect = ScaleAndRoundCGRect(rect_array[i], dip_to_pixel_scale_);
     // Translate from local desktop to capturer framebuffer coordinates.
     rect.Translate(translate_vector);
     region.AddRect(rect);
   }
 
   helper_.InvalidateRegion(region);
 }
 
-void ScreenCapturerMac::ScreenUpdateMove(CGFloat delta_x,
-                                         CGFloat delta_y,
-                                         size_t count,
-                                         const CGRect* rect_array) {
-  // Translate |rect_array| to identify the move's destination.
-  CGRect refresh_rects[count];
-  for (CGRectCount i = 0; i < count; ++i) {
-    refresh_rects[i] = CGRectOffset(rect_array[i], delta_x, delta_y);
-  }
-
-  // Currently we just treat move events the same as refreshes.
-  ScreenRefresh(count, refresh_rects);
-}
-
-void ScreenCapturerMac::ScreenRefreshCallback(CGRectCount count,
-                                              const CGRect* rect_array) {
-  if (screen_pixel_bounds_.is_empty())
-    ScreenConfigurationChanged();
-  ScreenRefresh(count, rect_array);
-}
-
 std::unique_ptr<DesktopFrame> ScreenCapturerMac::CreateFrame() {
   std::unique_ptr<DesktopFrame> frame(
       new BasicDesktopFrame(screen_pixel_bounds_.size()));
   frame->set_dpi(DesktopVector(kStandardDPI * dip_to_pixel_scale_,
                                kStandardDPI * dip_to_pixel_scale_));
   return frame;
 }
 
 }  // namespace
 
 // static
 ScreenCapturer* ScreenCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.configuration_monitor())
     return nullptr;
 
   std::unique_ptr<ScreenCapturer> capturer(
       new ScreenCapturerMac(options.configuration_monitor()));
   if (!static_cast<ScreenCapturerMac*>(capturer.get())->Init()) {
     return nullptr;
   }
 
   if (options.detect_updated_region()) {
     capturer.reset(new ScreenCapturerDifferWrapper(std::move(capturer)));
   }
 
   return capturer.release();
 }
 
 }  // namespace webrtc