Fix a screen capture issue on retina macOS devices.

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 286 matching lines @@
   // Returns false if the selected screen is no longer valid.
   bool CgBlitPostLion(const DesktopFrame& frame,
                       const DesktopRegion& region);
 
   // Called when the screen configuration is changed.
   void ScreenConfigurationChanged();
 
   bool RegisterRefreshAndMoveHandlers();
   void UnregisterRefreshAndMoveHandlers();
 
+  void ScreenUpdateMove(CGFloat delta_x,
+                        CGFloat delta_y,
+                        CGRectCount count,
+                        const CGRect* rect_array);
   void ScreenRefresh(CGRectCount count, const CGRect *rect_array);
   void ReleaseBuffers();
 
   std::unique_ptr<DesktopFrame> CreateFrame();
 
   Callback* callback_ = nullptr;
 
   CGLContextObj cgl_context_ = nullptr;
   ScopedPixelBufferObject pixel_buffer_object_;
 
@@ skipping 631 matching lines @@
 
           if (manager->ShouldIgnoreUpdates())
             return;
 
           // Only pay attention to frame updates.
           if (status != kCGDisplayStreamFrameStatusFrameComplete)
             return;
 
           size_t count = 0;
           const CGRect* rects = CGDisplayStreamUpdateGetRects(
-              updateRef, kCGDisplayStreamUpdateDirtyRects, &count);
+              updateRef, kCGDisplayStreamUpdateMovedRects, &count);

[Sergey Ulanov, 2016/12/20 18:56:51]

I would still prefer to use kCGDisplayStreamUpdateDirtyRects if it works
properly with the rect scaling fixed. Using MovedRects/RefreshedRects here makes
this code more complicated with no clear benefits. 
MovedRects/RefreshedRects may give more precise update region, but it's not
clear if that would always provide any performance benefits. Having too detailed
updated region may be costly as well: each rect results in GlBlit*() call, and
capturing whole screen at once may be faster than every simple change
individually. We currently don't have any benchmarks to show potential
performance wins one way or the other and without them I'd prefer to keep this
simpler code.

           if (count != 0) {
-            // According to CGDisplayStream.h, it's safe to call
-            // CGDisplayStreamStop() from within the callback.
+            CGFloat dx = 0;
+            CGFloat dy = 0;
+            CGDisplayStreamUpdateGetMovedRectsDelta(updateRef, &dx, &dy);
+            ScreenUpdateMove(dx, dy, count, rects);
+          }
+
+          count = 0;
+          rects = CGDisplayStreamUpdateGetRects(
+              updateRef, kCGDisplayStreamUpdateRefreshedRects, &count);
+          if (count != 0) {
             ScreenRefresh(count, rects);
           }
         };
     CGDisplayStreamRef display_stream = CGDisplayStreamCreate(
         display_id, pixel_width, pixel_height, 'BGRA', nullptr, handler);
 
     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);
     }
   }
 
   return true;
 }
 
 void ScreenCapturerMac::UnregisterRefreshAndMoveHandlers() {
   display_stream_manager_->UnregisterActiveStreams();
 }
 
+void ScreenCapturerMac::ScreenUpdateMove(CGFloat delta_x,
+                                         CGFloat delta_y,
+                                         CGRectCount count,
+                                         const CGRect* rect_array) {
+  // Refresh the source rects.
+  ScreenRefresh(count, rect_array);
+
+  // Refresh the destination rects.
+  CGRect refresh_rects[count];
+  for (CGRectCount i = 0; i < count; ++i)
+    refresh_rects[i] = CGRectOffset(rect_array[i], delta_x, delta_y);
+  ScreenRefresh(count, refresh_rects);
+}
+
 void ScreenCapturerMac::ScreenRefresh(CGRectCount count,
                                       const CGRect* rect_array) {
   if (screen_pixel_bounds_.is_empty())
     ScreenConfigurationChanged();
 
   DesktopRegion region;
   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_);
+    // All rects are already in physical pixel coordinates.
+    DesktopRect rect = ScaleAndRoundCGRect(rect_array[i], 1.0);

[Sergey Ulanov, 2016/12/20 18:56:51]

It would be cleaner to write this as 
DesktopRect::MakeXYWH(rect.origin.x, rect.origin.y, rect.size.width,
bounds.size.height) . As you don't really need the rect scaled here, just
converting one rect type to another.

     region.AddRect(rect);
   }
 
   helper_.InvalidateRegion(region);
 }
 
 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_,
@@ skipping 12 matching lines @@
   std::unique_ptr<ScreenCapturerMac> capturer(
       new ScreenCapturerMac(options.configuration_monitor()));
   if (!capturer.get()->Init()) {
     return nullptr;
   }
 
   return capturer;
 }
 
 }  // namespace webrtc