Return scoped_refptr<CaptureData> from VideoFrameCapturerLinux::CaptureScreen()

remoting/host/video_frame_capturer_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[Sergey Ulanov, 2012/12/19 01:07:30]

FYI: I moved this file to remoting/capturer

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/video_frame_capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
 
@@ skipping 67 matching lines @@
   // Capture the cursor image and notify the delegate if it was captured.
   void CaptureCursor();
 
   // Capture screen pixels, and return the data in a new CaptureData object,
   // to be freed by the caller.
   // In the DAMAGE case, the VideoFrameCapturerHelper already holds the list of
   // invalid rectangles from ProcessPendingXEvents().
   // 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.
-  CaptureData* CaptureScreen();
+  scoped_refptr<CaptureData> CaptureScreen();
 
   // Called when the screen configuration is changed. |root_window_size|
   // specifies size the most recent size of the root window.
   void ScreenConfigurationChanged(const SkISize& root_window_size);
 
   // 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).
@@ skipping 294 matching lines @@
   uint32* dst = reinterpret_cast<uint32*>(proto_data);
   uint32* dst_end = dst + (width * height);
   while (dst < dst_end) {
     *dst++ = static_cast<uint32>(*src++);
   }
   XFree(img);
 
   delegate_->OnCursorShapeChanged(cursor_proto.Pass());
 }
 
-CaptureData* VideoFrameCapturerLinux::CaptureScreen() {
+scoped_refptr<CaptureData> VideoFrameCapturerLinux::CaptureScreen() {
   VideoFrame* current = queue_.current_frame();
   DataPlanes planes;
   planes.data[0] = current->pixels();
   planes.strides[0] = current->bytes_per_row();
 
-  CaptureData* capture_data = new CaptureData(planes, current->dimensions(),
-                                              media::VideoFrame::RGB32);
+  scoped_refptr<CaptureData> capture_data(
+      new CaptureData(planes, current->dimensions(), media::VideoFrame::RGB32));
 
   // 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(capture_data->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.
   if (use_damage_ && queue_.previous_frame())
@@ skipping 212 matching lines @@
   NOTIMPLEMENTED();
   return scoped_ptr<VideoFrameCapturer>();
 }
 
 // static
 void VideoFrameCapturer::EnableXDamage(bool enable) {
   g_should_use_x_damage = enable;
 }
 
 }  // namespace remoting