Modify ScreenCaptureFrameQueue into a template

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.
  */
 
 #include "webrtc/modules/desktop_capture/screen_capturer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/macutils.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/desktop_geometry.h"
 #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_capture_queue.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"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 
 namespace {
 
 // Definitions used to dynamic-link to deprecated OS 10.6 functions.
 const char* kApplicationServicesLibraryName =
     "/System/Library/Frameworks/ApplicationServices.framework/"
@@ skipping 174 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_;
 
   CGLContextObj cgl_context_;
   ScopedPixelBufferObject pixel_buffer_object_;
 
   // Queue of the frames buffers.
-  ScreenCaptureFrameQueue queue_;
+  ScreenCaptureQueue<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_;
 
   // The physical pixel bounds of the current screen.
   DesktopRect screen_pixel_bounds_;
@@ skipping 128 matching lines @@
   // (as used by Apple Remote Desktop).
   IOPMAssertionCreateWithName(CFSTR("UserIsActive"),
                               kIOPMAssertionLevelOn,
                               CFSTR("Chrome Remote Desktop connection active"),
                               &power_assertion_id_user_);
 }
 
 void ScreenCapturerMac::Capture(const DesktopRegion& region_to_capture) {
   TickTime capture_start_time = TickTime::Now();
 
-  queue_.MoveToNextFrame();
+  queue_.MoveToNext();
+  RTC_DCHECK(!queue_.current() || !queue_.current()->IsShared());
 
   desktop_config_monitor_->Lock();
   MacDesktopConfiguration new_config =
       desktop_config_monitor_->desktop_configuration();
   if (!desktop_config_.Equals(new_config)) {
     desktop_config_ = new_config;
     // If the display configuraiton has changed then refresh capturer data
     // structures. Occasionally, the refresh and move handlers are lost when
     // the screen mode changes, so re-register them here.
     UnregisterRefreshAndMoveHandlers();
     RegisterRefreshAndMoveHandlers();
     ScreenConfigurationChanged();
   }
 
   DesktopRegion region;
   helper_.TakeInvalidRegion(&region);
 
   // If the current buffer is from an older generation then allocate a new one.
   // Note that we can't reallocate other buffers at this point, since the caller
   // may still be reading from them.
-  if (!queue_.current_frame())
-    queue_.ReplaceCurrentFrame(CreateFrame());
+  if (!queue_.current())
+    queue_.ReplaceCurrent(SharedDesktopFrame::Wrap(CreateFrame()));
 
-  DesktopFrame* current_frame = queue_.current_frame();
+  DesktopFrame* current_frame = queue_.current();
 
   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);
       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();
+  DesktopFrame* new_frame = queue_.current()->Share();
   *new_frame->mutable_updated_region() = region;
 
   if (flip)
     new_frame = new InvertedDesktopFrame(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();
@@ skipping 45 matching lines @@
   }
 
   ScreenConfigurationChanged();
   return true;
 }
 
 void ScreenCapturerMac::GlBlitFast(const DesktopFrame& frame,
                                    const DesktopRegion& region) {
   // Clip to the size of our current screen.
   DesktopRect clip_rect = DesktopRect::MakeSize(frame.size());
-  if (queue_.previous_frame()) {
+  if (queue_.previous()) {
     // We are doing double buffer for the capture data so we just need to copy
     // the invalid region from the previous capture in the current buffer.
     // TODO(hclam): We can reduce the amount of copying here by subtracting
     // |capturer_helper_|s region from |last_invalid_region_|.
     // http://crbug.com/92354
 
     // Since the image obtained from OpenGL is upside-down, 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(last_invalid_region_);
          !i.IsAtEnd(); i.Advance()) {
       DesktopRect copy_rect = i.rect();
       copy_rect.IntersectWith(clip_rect);
       if (!copy_rect.is_empty()) {
-        CopyRect(queue_.previous_frame()->data() + y_offset,
+        CopyRect(queue_.previous()->data() + y_offset,
                  -frame.stride(),
                  frame.data() + y_offset,
                  -frame.stride(),
                  DesktopFrame::kBytesPerPixel,
                  copy_rect);
       }
     }
   }
   last_invalid_region_ = region;
 
@@ skipping 48 matching lines @@
   glReadPixels(0, 0, frame.size().width(), frame.size().height(),
                GL_BGRA, GL_UNSIGNED_BYTE, frame.data());
   glPopClientAttrib();
 }
 
 void ScreenCapturerMac::CgBlitPreLion(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()) {
+  if (queue_.previous()) {
     memcpy(frame.data(),
-           queue_.previous_frame()->data(),
+           queue_.previous()->data(),
            frame.stride() * frame.size().height());
   }
 
   for (size_t i = 0; i < desktop_config_.displays.size(); ++i) {
     const MacDisplayConfiguration& display_config = desktop_config_.displays[i];
 
     // Use deprecated APIs to determine the display buffer layout.
     assert(cg_display_base_address_ && cg_display_bytes_per_row_ &&
         cg_display_bits_per_pixel_);
     uint8_t* display_base_address = reinterpret_cast<uint8_t*>(
@@ skipping 32 matching lines @@
                i.rect());
     }
   }
 }
 
 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()) {
+  if (queue_.previous()) {
     memcpy(frame.data(),
-           queue_.previous_frame()->data(),
+           queue_.previous()->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 305 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;
 
   std::unique_ptr<ScreenCapturerMac> capturer(
       new ScreenCapturerMac(options.configuration_monitor()));
   if (!capturer->Init())
     capturer.reset();
   return capturer.release();
 }
 
 }  // namespace webrtc