Use std::unique_ptr<> to pass frame ownership in DesktopCapturer impls.

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 78 matching lines @@
     src_plane += src_plane_stride;
     dest_plane += dest_plane_stride;
   }
 }
 
 // Returns an array of CGWindowID for all the on-screen windows except
 // |window_to_exclude|, or NULL if the window is not found or it fails. The
 // caller should release the returned CFArrayRef.
 CFArrayRef CreateWindowListWithExclusion(CGWindowID window_to_exclude) {
   if (!window_to_exclude)
-    return NULL;
+    return nullptr;
 
   CFArrayRef all_windows = CGWindowListCopyWindowInfo(
       kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
   if (!all_windows)
-    return NULL;
+    return nullptr;
 
-  CFMutableArrayRef returned_array = CFArrayCreateMutable(
-      NULL, CFArrayGetCount(all_windows), NULL);
+  CFMutableArrayRef returned_array =
+      CFArrayCreateMutable(nullptr, CFArrayGetCount(all_windows), nullptr);
 
   bool found = false;
   for (CFIndex i = 0; i < CFArrayGetCount(all_windows); ++i) {
     CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
         CFArrayGetValueAtIndex(all_windows, i));
 
     CFNumberRef id_ref = reinterpret_cast<CFNumberRef>(
         CFDictionaryGetValue(window, kCGWindowNumber));
 
     CGWindowID id;
     CFNumberGetValue(id_ref, kCFNumberIntType, &id);
     if (id == window_to_exclude) {
       found = true;
       continue;
     }
     CFArrayAppendValue(returned_array, reinterpret_cast<void *>(id));
   }
   CFRelease(all_windows);
 
   if (!found) {
     CFRelease(returned_array);
-    returned_array = NULL;
+    returned_array = nullptr;
   }
   return returned_array;
 }
 
 // Returns the bounds of |window| in physical pixels, enlarged by a small amount
 // on four edges to take account of the border/shadow effects.
 DesktopRect GetExcludedWindowPixelBounds(CGWindowID window,
                                          float dip_to_pixel_scale) {
   // The amount of pixels to add to the actual window bounds to take into
   // account of the border/shadow effects.
   static const int kBorderEffectSize = 20;
   CGRect rect;
   CGWindowID ids[1];
   ids[0] = window;
 
   CFArrayRef window_id_array =
-      CFArrayCreate(NULL, reinterpret_cast<const void **>(&ids), 1, NULL);
+      CFArrayCreate(nullptr, reinterpret_cast<const void**>(&ids), 1, nullptr);
   CFArrayRef window_array =
       CGWindowListCreateDescriptionFromArray(window_id_array);
 
   if (CFArrayGetCount(window_array) > 0) {
     CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
         CFArrayGetValueAtIndex(window_array, 0));
     CFDictionaryRef bounds_ref = reinterpret_cast<CFDictionaryRef>(
         CFDictionaryGetValue(window, kCGWindowBounds));
     CGRectMakeWithDictionaryRepresentation(bounds_ref, &rect);
   }
@@ skipping 65 matching lines @@
                         const CGRect *rect_array);
   static void ScreenRefreshCallback(CGRectCount count,
                                     const CGRect *rect_array,
                                     void *user_parameter);
   static void ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
                                        size_t count,
                                        const CGRect *rect_array,
                                        void *user_parameter);
   void ReleaseBuffers();
 
-  DesktopFrame* CreateFrame();
+  std::unique_ptr<DesktopFrame> CreateFrame();
 
-  Callback* callback_;
+  Callback* callback_ = nullptr;
 
-  CGLContextObj cgl_context_;
+  CGLContextObj cgl_context_ = nullptr;
   ScopedPixelBufferObject pixel_buffer_object_;
 
   // Queue of the frames buffers.
   ScreenCaptureFrameQueue<SharedDesktopFrame> queue_;
 
   // Current display configuration.
   MacDesktopConfiguration desktop_config_;
 
   // Currently selected display, or 0 if the full desktop is selected. On OS X
   // 10.6 and before, this is always 0.
-  CGDirectDisplayID current_display_;
+  CGDirectDisplayID current_display_ = 0;
 
   // The physical pixel bounds of the current screen.
   DesktopRect screen_pixel_bounds_;
 
   // The dip to physical pixel scale of the current screen.
-  float dip_to_pixel_scale_;
+  float dip_to_pixel_scale_ = 1.0f;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   ScreenCapturerHelper helper_;
 
   // Contains an invalid region from the previous capture.
   DesktopRegion last_invalid_region_;
 
   // Monitoring display reconfiguration.
   rtc::scoped_refptr<DesktopConfigurationMonitor> desktop_config_monitor_;
 
   // Power management assertion to prevent the screen from sleeping.
-  IOPMAssertionID power_assertion_id_display_;
+  IOPMAssertionID power_assertion_id_display_ = kIOPMNullAssertionID;
 
   // Power management assertion to indicate that the user is active.
-  IOPMAssertionID power_assertion_id_user_;
+  IOPMAssertionID power_assertion_id_user_ = kIOPMNullAssertionID;
 
   // Dynamically link to deprecated APIs for Mac OS X 10.6 support.
-  void* app_services_library_;
-  CGDisplayBaseAddressFunc cg_display_base_address_;
-  CGDisplayBytesPerRowFunc cg_display_bytes_per_row_;
-  CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_;
-  void* opengl_library_;
-  CGLSetFullScreenFunc cgl_set_full_screen_;
+  void* app_services_library_ = nullptr;
+  CGDisplayBaseAddressFunc cg_display_base_address_ = nullptr;
+  CGDisplayBytesPerRowFunc cg_display_bytes_per_row_ = nullptr;
+  CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_ = nullptr;
+  void* opengl_library_ = nullptr;
+  CGLSetFullScreenFunc cgl_set_full_screen_ = nullptr;
 
-  CGWindowID excluded_window_;
+  CGWindowID excluded_window_ = 0;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerMac);
 };
 
 // DesktopFrame wrapper that flips wrapped frame upside down by inverting
 // stride.
 class InvertedDesktopFrame : public DesktopFrame {
  public:
-  // Takes ownership of |frame|.
-  InvertedDesktopFrame(DesktopFrame* frame)
+  InvertedDesktopFrame(std::unique_ptr<DesktopFrame> frame)
       : DesktopFrame(
-            frame->size(), -frame->stride(),
+            frame->size(),
+            -frame->stride(),
             frame->data() + (frame->size().height() - 1) * frame->stride(),
-            frame->shared_memory()),
-        original_frame_(frame) {
-    set_dpi(frame->dpi());
-    set_capture_time_ms(frame->capture_time_ms());
-    mutable_updated_region()->Swap(frame->mutable_updated_region());
+            frame->shared_memory()) {
+    original_frame_ = std::move(frame);
+    set_dpi(original_frame_->dpi());
+    set_capture_time_ms(original_frame_->capture_time_ms());
+    mutable_updated_region()->Swap(original_frame_->mutable_updated_region());
   }
   virtual ~InvertedDesktopFrame() {}
 
  private:
   std::unique_ptr<DesktopFrame> original_frame_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(InvertedDesktopFrame);
 };
 
 ScreenCapturerMac::ScreenCapturerMac(
     rtc::scoped_refptr<DesktopConfigurationMonitor> desktop_config_monitor)
-    : callback_(NULL),
-      cgl_context_(NULL),
-      current_display_(0),
-      dip_to_pixel_scale_(1.0f),
-      desktop_config_monitor_(desktop_config_monitor),
-      power_assertion_id_display_(kIOPMNullAssertionID),
-      power_assertion_id_user_(kIOPMNullAssertionID),
-      app_services_library_(NULL),
-      cg_display_base_address_(NULL),
-      cg_display_bytes_per_row_(NULL),
-      cg_display_bits_per_pixel_(NULL),
-      opengl_library_(NULL),
-      cgl_set_full_screen_(NULL),
-      excluded_window_(0) {
-}
+    : desktop_config_monitor_(desktop_config_monitor) {}
 
 ScreenCapturerMac::~ScreenCapturerMac() {
   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 12 matching lines @@
   desktop_config_ = desktop_config_monitor_->desktop_configuration();
   desktop_config_monitor_->Unlock();
   ScreenConfigurationChanged();
   return true;
 }
 
 void ScreenCapturerMac::ReleaseBuffers() {
   if (cgl_context_) {
     pixel_buffer_object_.Release();
     CGLDestroyContext(cgl_context_);
-    cgl_context_ = NULL;
+    cgl_context_ = nullptr;
   }
   // 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.
   queue_.Reset();
 }
 
 void ScreenCapturerMac::Start(Callback* callback) {
   assert(!callback_);
   assert(callback);
@@ skipping 45 matching lines @@
     queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(CreateFrame()));
 
   DesktopFrame* current_frame = queue_.current_frame();
 
   bool flip = false;  // GL capturers need flipping.
   if (rtc::GetOSVersionName() >= rtc::kMacOSLion) {
     // 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.
     if (!CgBlitPostLion(*current_frame, region)) {
       desktop_config_monitor_->Unlock();
-      callback_->OnCaptureCompleted(NULL);
+      callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
       return;
     }
   } else if (cgl_context_) {
     flip = true;
     if (pixel_buffer_object_.get() != 0) {
       GlBlitFast(*current_frame, region);
     } else {
       // See comment in ScopedPixelBufferObject::Init about why the slow
       // path is always used on 10.5.
       GlBlitSlow(*current_frame);
     }
   } else {
     CgBlitPreLion(*current_frame, region);
   }
 
-  DesktopFrame* new_frame = queue_.current_frame()->Share();
+  std::unique_ptr<DesktopFrame> new_frame = queue_.current_frame()->Share();
   *new_frame->mutable_updated_region() = region;
 
   if (flip)
-    new_frame = new InvertedDesktopFrame(new_frame);
+    new_frame.reset(new InvertedDesktopFrame(std::move(new_frame)));
 
   helper_.set_size_most_recent(new_frame->size());
 
   // Signal that we are done capturing data from the display framebuffer,
   // and accessing display structures.
   desktop_config_monitor_->Unlock();
 
-  new_frame->set_capture_time_ms(
-      (rtc::TimeNanos() - capture_start_time_nanos) /
-      rtc::kNumNanosecsPerMillisec);
-  callback_->OnCaptureCompleted(new_frame);
+  new_frame->set_capture_time_ms((rtc::TimeNanos() - capture_start_time_nanos) /
+                                 rtc::kNumNanosecsPerMillisec);
+  callback_->OnCaptureResult(Result::SUCCESS, std::move(new_frame));
 }
 
 void ScreenCapturerMac::SetExcludedWindow(WindowId window) {
   excluded_window_ = window;
 }
 
 bool ScreenCapturerMac::GetScreenList(ScreenList* screens) {
   assert(screens->size() == 0);
   if (rtc::GetOSVersionName() < rtc::kMacOSLion) {
     // Single monitor cast is not supported on pre OS X 10.7.
@@ skipping 63 matching lines @@
     }
   }
   last_invalid_region_ = region;
 
   CGLContextObj CGL_MACRO_CONTEXT = cgl_context_;
   glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pixel_buffer_object_.get());
   glReadPixels(0, 0, frame.size().width(), frame.size().height(), GL_BGRA,
                GL_UNSIGNED_BYTE, 0);
   GLubyte* ptr = static_cast<GLubyte*>(
       glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY_ARB));
-  if (ptr == NULL) {
+  if (!ptr) {
     // If the buffer can't be mapped, assume that it's no longer valid and
     // release it.
     pixel_buffer_object_.Release();
   } else {
     // Copy only from the dirty rects. Since the image obtained from OpenGL is
     // upside-down we need to do some magic here to copy the correct rectangle.
     const int y_offset = (frame.size().height() - 1) * frame.stride();
     for (DesktopRegion::Iterator i(region);
          !i.IsAtEnd(); i.Advance()) {
       DesktopRect copy_rect = i.rect();
@@ skipping 87 matching lines @@
     }
   }
 }
 
 bool ScreenCapturerMac::CgBlitPostLion(const DesktopFrame& frame,
                                        const DesktopRegion& region) {
   // Copy the entire contents of the previous capture buffer, to capture over.
   // TODO(wez): Get rid of this as per crbug.com/145064, or implement
   // crbug.com/92354.
   if (queue_.previous_frame()) {
-    memcpy(frame.data(),
-           queue_.previous_frame()->data(),
+    memcpy(frame.data(), queue_.previous_frame()->data(),
            frame.stride() * frame.size().height());
   }
 
   MacDisplayConfigurations displays_to_capture;
   if (current_display_) {
     // Capturing a single screen. Note that the screen id may change when
     // screens are added or removed.
     const MacDisplayConfiguration* config =
         desktop_config_.FindDisplayConfigurationById(current_display_);
     if (config) {
@@ skipping 28 matching lines @@
     // Determine which parts of the blit region, if any, lay within the monitor.
     DesktopRegion copy_region = region;
     copy_region.IntersectWith(display_bounds);
     if (copy_region.is_empty())
       continue;
 
     // Translate the region to be copied into display-relative coordinates.
     copy_region.Translate(-display_bounds.left(), -display_bounds.top());
 
     DesktopRect excluded_window_bounds;
-    CGImageRef excluded_image = NULL;
+    CGImageRef excluded_image = nullptr;
     if (excluded_window_ && window_list) {
       // Get the region of the excluded window relative the primary display.
       excluded_window_bounds = GetExcludedWindowPixelBounds(
           excluded_window_, display_config.dip_to_pixel_scale);
       excluded_window_bounds.IntersectWith(display_config.pixel_bounds);
 
       // Create the image under the excluded window first, because it's faster
       // than captuing the whole display.
       if (!excluded_window_bounds.is_empty()) {
         excluded_image = CreateExcludedWindowRegionImage(
             excluded_window_bounds, display_config.dip_to_pixel_scale,
             window_list);
       }
     }
 
     // Create an image containing a snapshot of the display.
     CGImageRef image = CGDisplayCreateImage(display_config.id);
-    if (image == NULL) {
+    if (!image) {
       if (excluded_image)
         CFRelease(excluded_image);
       continue;
     }
 
     // Verify that the image has 32-bit depth.
     int bits_per_pixel = CGImageGetBitsPerPixel(image);
     if (bits_per_pixel / 8 != DesktopFrame::kBytesPerPixel) {
       LOG(LS_ERROR) << "CGDisplayCreateImage() returned imaged with "
                     << bits_per_pixel
@@ skipping 143 matching lines @@
     // deprecated in 10.6 -- it's still functional there, and it's not used on
     // newer OS X versions.
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     kCGLPFAFullScreen,
 #pragma clang diagnostic pop
     kCGLPFADisplayMask,
     (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(mainDevice),
     (CGLPixelFormatAttribute)0
   };
-  CGLPixelFormatObj pixel_format = NULL;
+  CGLPixelFormatObj pixel_format = nullptr;
   GLint matching_pixel_format_count = 0;
   CGLError err = CGLChoosePixelFormat(attributes,
                                       &pixel_format,
                                       &matching_pixel_format_count);
   assert(err == kCGLNoError);
-  err = CGLCreateContext(pixel_format, NULL, &cgl_context_);
+  err = CGLCreateContext(pixel_format, nullptr, &cgl_context_);
   assert(err == kCGLNoError);
   CGLDestroyPixelFormat(pixel_format);
   (*cgl_set_full_screen_)(cgl_context_);
   CGLSetCurrentContext(cgl_context_);
 
   size_t buffer_size = screen_pixel_bounds_.width() *
                        screen_pixel_bounds_.height() *
                        sizeof(uint32_t);
   pixel_buffer_object_.Init(cgl_context_, buffer_size);
 }
@@ skipping 68 matching lines @@
 void ScreenCapturerMac::ScreenUpdateMoveCallback(
     CGScreenUpdateMoveDelta delta,
     size_t count,
     const CGRect* rect_array,
     void* user_parameter) {
   ScreenCapturerMac* capturer =
       reinterpret_cast<ScreenCapturerMac*>(user_parameter);
   capturer->ScreenUpdateMove(delta, count, rect_array);
 }
 
-DesktopFrame* ScreenCapturerMac::CreateFrame() {
+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.release();
+  return frame;
 }
 
 }  // namespace
 
 // static
 ScreenCapturer* ScreenCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.configuration_monitor())
-    return NULL;
+    return nullptr;
 
   std::unique_ptr<ScreenCapturerMac> capturer(
       new ScreenCapturerMac(options.configuration_monitor()));
   if (!capturer->Init())
     capturer.reset();
   return capturer.release();
 }
 
 }  // namespace webrtc