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

webrtc/modules/desktop_capture/screen_capturer_x11.cc

 /*
  *  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 48 matching lines @@
   // SharedXDisplay::XEventHandler interface.
   bool HandleXEvent(const XEvent& event) override;
 
   void InitXDamage();
 
   // Capture screen pixels to the current buffer in the queue. In the DAMAGE
   // case, the ScreenCapturerHelper already holds the list of invalid rectangles
   // from HandleXEvent(). In the non-DAMAGE case, this captures the
   // whole screen, then calculates some invalid rectangles that include any
   // differences between this and the previous capture.
-  std::unique_ptr<DesktopFrame> CaptureScreen();
+  DesktopFrame* CaptureScreen();
 
   // Called when the screen configuration is changed.
   void ScreenConfigurationChanged();
 
   // Synchronize the current buffer with |last_buffer_|, by copying pixels from
   // the area of |last_invalid_rects|.
   // Note this only works on the assumption that kNumBuffers == 2, as
   // |last_invalid_rects| holds the differences from the previous buffer and
   // the one prior to that (which will then be the current buffer).
   void SynchronizeFrame();
 
   void DeinitXlib();
 
   DesktopCaptureOptions options_;
 
-  Callback* callback_ = nullptr;
+  Callback* callback_;
 
   // X11 graphics context.
-  GC gc_ = nullptr;
-  Window root_window_ = BadValue;
+  GC gc_;
+  Window root_window_;
 
   // XFixes.
-  bool has_xfixes_ = false;
-  int xfixes_event_base_ = -1;
-  int xfixes_error_base_ = -1;
+  bool has_xfixes_;
+  int xfixes_event_base_;
+  int xfixes_error_base_;
 
   // XDamage information.
-  bool use_damage_ = false;
-  Damage damage_handle_ = 0;
-  int damage_event_base_ = -1;
-  int damage_error_base_ = -1;
-  XserverRegion damage_region_ = 0;
+  bool use_damage_;
+  Damage damage_handle_;
+  int damage_event_base_;
+  int damage_error_base_;
+  XserverRegion damage_region_;
 
   // Access to the X Server's pixel buffer.
   XServerPixelBuffer x_server_pixel_buffer_;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   ScreenCapturerHelper helper_;
 
   // Queue of the frames buffers.
   ScreenCaptureFrameQueue<SharedDesktopFrame> queue_;
 
   // Invalid region from the previous capture. This is used to synchronize the
   // current with the last buffer used.
   DesktopRegion last_invalid_region_;
 
   // |Differ| for use when polling for changes.
   std::unique_ptr<Differ> differ_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerLinux);
 };
 
-ScreenCapturerLinux::ScreenCapturerLinux() {
+ScreenCapturerLinux::ScreenCapturerLinux()
+    : callback_(NULL),
+      gc_(NULL),
+      root_window_(BadValue),
+      has_xfixes_(false),
+      xfixes_event_base_(-1),
+      xfixes_error_base_(-1),
+      use_damage_(false),
+      damage_handle_(0),
+      damage_event_base_(-1),
+      damage_error_base_(-1),
+      damage_region_(0) {
   helper_.SetLogGridSize(4);
 }
 
 ScreenCapturerLinux::~ScreenCapturerLinux() {
   options_.x_display()->RemoveEventHandler(ConfigureNotify, this);
   if (use_damage_) {
     options_.x_display()->RemoveEventHandler(
         damage_event_base_ + XDamageNotify, this);
   }
   DeinitXlib();
@@ skipping 97 matching lines @@
   RTC_DCHECK(!queue_.current_frame() || !queue_.current_frame()->IsShared());
 
   // Process XEvents for XDamage and cursor shape tracking.
   options_.x_display()->ProcessPendingXEvents();
 
   // ProcessPendingXEvents() may call ScreenConfigurationChanged() which
   // reinitializes |x_server_pixel_buffer_|. Check if the pixel buffer is still
   // in a good shape.
   if (!x_server_pixel_buffer_.is_initialized()) {
      // We failed to initialize pixel buffer.
-     callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
+     callback_->OnCaptureCompleted(NULL);
      return;
   }
 
   // If the current frame 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(
-        SharedDesktopFrame::Wrap(std::unique_ptr<DesktopFrame>(
-            new BasicDesktopFrame(x_server_pixel_buffer_.window_size()))));
+    std::unique_ptr<DesktopFrame> frame(
+        new BasicDesktopFrame(x_server_pixel_buffer_.window_size()));
+    queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(frame.release()));
   }
 
   // Refresh the Differ helper used by CaptureFrame(), if needed.
   DesktopFrame* frame = queue_.current_frame();
-  if (!use_damage_ &&
-      (!differ_ || (differ_->width() != frame->size().width()) ||
-       (differ_->height() != frame->size().height()) ||
-       (differ_->bytes_per_row() != frame->stride()))) {
+  if (!use_damage_ && (
+      !differ_.get() ||
+      (differ_->width() != frame->size().width()) ||
+      (differ_->height() != frame->size().height()) ||
+      (differ_->bytes_per_row() != frame->stride()))) {
     differ_.reset(new Differ(frame->size().width(), frame->size().height(),
-                             DesktopFrame::kBytesPerPixel, frame->stride()));
+                             DesktopFrame::kBytesPerPixel,
+                             frame->stride()));
   }
 
-  std::unique_ptr<DesktopFrame> result = CaptureScreen();
+  DesktopFrame* result = CaptureScreen();
   last_invalid_region_ = result->updated_region();
-  result->set_capture_time_ms((rtc::TimeNanos() - capture_start_time_nanos) /
-                              rtc::kNumNanosecsPerMillisec);
-  callback_->OnCaptureResult(Result::SUCCESS, std::move(result));
+  result->set_capture_time_ms(
+      (rtc::TimeNanos() - capture_start_time_nanos) /
+      rtc::kNumNanosecsPerMillisec);
+  callback_->OnCaptureCompleted(result);
 }
 
 bool ScreenCapturerLinux::GetScreenList(ScreenList* screens) {
   RTC_DCHECK(screens->size() == 0);
   // TODO(jiayl): implement screen enumeration.
   Screen default_screen;
   default_screen.id = 0;
   screens->push_back(default_screen);
   return true;
 }
@@ skipping 11 matching lines @@
       return false;
     RTC_DCHECK(damage_event->level == XDamageReportNonEmpty);
     return true;
   } else if (event.type == ConfigureNotify) {
     ScreenConfigurationChanged();
     return true;
   }
   return false;
 }
 
-std::unique_ptr<DesktopFrame> ScreenCapturerLinux::CaptureScreen() {
-  std::unique_ptr<SharedDesktopFrame> frame = queue_.current_frame()->Share();
+DesktopFrame* ScreenCapturerLinux::CaptureScreen() {
+  DesktopFrame* frame = queue_.current_frame()->Share();
   assert(x_server_pixel_buffer_.window_size().equals(frame->size()));
 
   // Pass the screen size to the helper, so it can clip the invalid region if it
   // expands that region to a grid.
   helper_.set_size_most_recent(frame->size());
 
   // In the DAMAGE case, ensure the frame is up-to-date with the previous frame
   // if any.  If there isn't a previous frame, that means a screen-resolution
   // change occurred, and |invalid_rects| will be updated to include the whole
   // screen.
@@ skipping 21 matching lines @@
     helper_.TakeInvalidRegion(updated_region);
 
     // Clip the damaged portions to the current screen size, just in case some
     // spurious XDamage notifications were received for a previous (larger)
     // screen size.
     updated_region->IntersectWith(
         DesktopRect::MakeSize(x_server_pixel_buffer_.window_size()));
 
     for (DesktopRegion::Iterator it(*updated_region);
          !it.IsAtEnd(); it.Advance()) {
-      x_server_pixel_buffer_.CaptureRect(it.rect(), frame.get());
+      x_server_pixel_buffer_.CaptureRect(it.rect(), frame);
     }
   } else {
     // Doing full-screen polling, or this is the first capture after a
     // screen-resolution change.  In either case, need a full-screen capture.
     DesktopRect screen_rect = DesktopRect::MakeSize(frame->size());
-    x_server_pixel_buffer_.CaptureRect(screen_rect, frame.get());
+    x_server_pixel_buffer_.CaptureRect(screen_rect, frame);
 
     if (queue_.previous_frame()) {
       // Full-screen polling, so calculate the invalid rects here, based on the
       // changed pixels between current and previous buffers.
-      RTC_DCHECK(differ_);
+      RTC_DCHECK(differ_.get() != NULL);
       RTC_DCHECK(queue_.previous_frame()->data());
       differ_->CalcDirtyRegion(queue_.previous_frame()->data(),
                                frame->data(), updated_region);
     } else {
       // No previous buffer, so always invalidate the whole screen, whether
       // or not DAMAGE is being used.  DAMAGE doesn't necessarily send a
       // full-screen notification after a screen-resolution change, so
       // this is done here.
       updated_region->SetRect(screen_rect);
     }
   }
 
-  return std::move(frame);
+  return frame;
 }
 
 void ScreenCapturerLinux::ScreenConfigurationChanged() {
   // Make sure the frame buffers will be reallocated.
   queue_.Reset();
 
   helper_.ClearInvalidRegion();
   if (!x_server_pixel_buffer_.Init(display(), DefaultRootWindow(display()))) {
     LOG(LS_ERROR) << "Failed to initialize pixel buffer after screen "
         "configuration change.";
@@ skipping 16 matching lines @@
   RTC_DCHECK(current != last);
   for (DesktopRegion::Iterator it(last_invalid_region_);
        !it.IsAtEnd(); it.Advance()) {
     current->CopyPixelsFrom(*last, it.rect().top_left(), it.rect());
   }
 }
 
 void ScreenCapturerLinux::DeinitXlib() {
   if (gc_) {
     XFreeGC(display(), gc_);
-    gc_ = nullptr;
+    gc_ = NULL;
   }
 
   x_server_pixel_buffer_.Release();
 
   if (display()) {
     if (damage_handle_) {
       XDamageDestroy(display(), damage_handle_);
       damage_handle_ = 0;
     }
 
     if (damage_region_) {
       XFixesDestroyRegion(display(), damage_region_);
       damage_region_ = 0;
     }
   }
 }
 
 }  // namespace
 
 // static
 ScreenCapturer* ScreenCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.x_display())
-    return nullptr;
+    return NULL;
 
   std::unique_ptr<ScreenCapturerLinux> capturer(new ScreenCapturerLinux());
   if (!capturer->Init(options))
     capturer.reset();
   return capturer.release();
 }
 
 }  // namespace webrtc