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

webrtc/modules/desktop_capture/window_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 18 matching lines @@
 #include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 
 namespace {
 
 // Convenience wrapper for XGetWindowProperty() results.
 template <class PropertyType>
 class XWindowProperty {
  public:
-  XWindowProperty(Display* display, Window window, Atom property)
-      : is_valid_(false),
-        size_(0),
-        data_(NULL) {
+  XWindowProperty(Display* display, Window window, Atom property) {
     const int kBitsPerByte = 8;
     Atom actual_type;
     int actual_format;
     unsigned long bytes_after;  // NOLINT: type required by XGetWindowProperty
     int status = XGetWindowProperty(display, window, property, 0L, ~0L, False,
                                     AnyPropertyType, &actual_type,
                                     &actual_format, &size_,
                                     &bytes_after, &data_);
     if (status != Success) {
-      data_ = NULL;
+      data_ = nullptr;
       return;
     }
     if (sizeof(PropertyType) * kBitsPerByte != actual_format) {
       size_ = 0;
       return;
     }
 
     is_valid_ = true;
   }
 
   ~XWindowProperty() {
     if (data_)
       XFree(data_);
   }
 
   // True if we got properly value successfully.
   bool is_valid() const { return is_valid_; }
 
   // Size and value of the property.
   size_t size() const { return size_; }
   const PropertyType* data() const {
     return reinterpret_cast<PropertyType*>(data_);
   }
   PropertyType* data() {
     return reinterpret_cast<PropertyType*>(data_);
   }
 
  private:
-  bool is_valid_;
-  unsigned long size_;  // NOLINT: type required by XGetWindowProperty
-  unsigned char* data_;
+  bool is_valid_ = false;
+  unsigned long size_ = 0;  // NOLINT: type required by XGetWindowProperty
+  unsigned char* data_ = nullptr;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(XWindowProperty);
 };
 
 class WindowCapturerLinux : public WindowCapturer,
                             public SharedXDisplay::XEventHandler {
  public:
   WindowCapturerLinux(const DesktopCaptureOptions& options);
   virtual ~WindowCapturerLinux();
 
@@ skipping 16 matching lines @@
   // that has WM_STATE property set to NormalState.
   // See http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.3.1 .
   ::Window GetApplicationWindow(::Window window);
 
   // Returns true if the |window| is a desktop element.
   bool IsDesktopElement(::Window window);
 
   // Returns window title for the specified X |window|.
   bool GetWindowTitle(::Window window, std::string* title);
 
-  Callback* callback_;
+  Callback* callback_ = nullptr;
 
   rtc::scoped_refptr<SharedXDisplay> x_display_;
 
   Atom wm_state_atom_;
   Atom window_type_atom_;
   Atom normal_window_type_atom_;
-  bool has_composite_extension_;
+  bool has_composite_extension_ = false;
 
-  ::Window selected_window_;
+  ::Window selected_window_ = 0;
   XServerPixelBuffer x_server_pixel_buffer_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerLinux);
 };
 
 WindowCapturerLinux::WindowCapturerLinux(const DesktopCaptureOptions& options)
-    : callback_(NULL),
-      x_display_(options.x_display()),
-      has_composite_extension_(false),
-      selected_window_(0) {
+    : x_display_(options.x_display()) {
   // Create Atoms so we don't need to do it every time they are used.
   wm_state_atom_ = XInternAtom(display(), "WM_STATE", True);
   window_type_atom_ = XInternAtom(display(), "_NET_WM_WINDOW_TYPE", True);
   normal_window_type_atom_ = XInternAtom(
       display(), "_NET_WM_WINDOW_TYPE_NORMAL", True);
 
   int event_base, error_base, major_version, minor_version;
   if (XCompositeQueryExtension(display(), &event_base, &error_base) &&
       XCompositeQueryVersion(display(), &major_version, &minor_version) &&
       // XCompositeNameWindowPixmap() requires version 0.2
@@ skipping 123 matching lines @@
 void WindowCapturerLinux::Start(Callback* callback) {
   assert(!callback_);
   assert(callback);
 
   callback_ = callback;
 }
 
 void WindowCapturerLinux::Capture(const DesktopRegion& region) {
   if (!x_server_pixel_buffer_.IsWindowValid()) {
     LOG(LS_INFO) << "The window is no longer valid.";
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureCompleted(std::unique_ptr<DesktopFrame>());

[Wez, 2016/05/18 01:29:51]

Why not using nullptr here?

[Sergey Ulanov, 2016/05/31 12:02:49]

same here. Replaced with OnCaptureResult(nullptr)

     return;
   }
 
   x_display_->ProcessPendingXEvents();
 
   if (!has_composite_extension_) {
     // Without the Xcomposite extension we capture when the whole window is
     // visible on screen and not covered by any other window. This is not
     // something we want so instead, just bail out.
     LOG(LS_INFO) << "No Xcomposite extension detected.";
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureCompleted(std::unique_ptr<DesktopFrame>());
     return;
   }
 
-  DesktopFrame* frame =
-      new BasicDesktopFrame(x_server_pixel_buffer_.window_size());
+  std::unique_ptr<DesktopFrame> frame(
+      new BasicDesktopFrame(x_server_pixel_buffer_.window_size()));
 
   x_server_pixel_buffer_.Synchronize();
   x_server_pixel_buffer_.CaptureRect(DesktopRect::MakeSize(frame->size()),
-                                     frame);
+                                     frame.get());
 
   frame->mutable_updated_region()->SetRect(
       DesktopRect::MakeSize(frame->size()));
 
-  callback_->OnCaptureCompleted(frame);
+  callback_->OnCaptureCompleted(std::move(frame));
 }
 
 bool WindowCapturerLinux::HandleXEvent(const XEvent& event) {
   if (event.type == ConfigureNotify) {
     XConfigureEvent xce = event.xconfigure;
     if (!DesktopSize(xce.width, xce.height).equals(
             x_server_pixel_buffer_.window_size())) {
       if (!x_server_pixel_buffer_.Init(display(), selected_window_)) {
         LOG(LS_ERROR) << "Failed to initialize pixel buffer after resizing.";
       }
@@ skipping 73 matching lines @@
   }
   XFree(class_hint.res_name);
   XFree(class_hint.res_class);
   return result;
 }
 
 bool WindowCapturerLinux::GetWindowTitle(::Window window, std::string* title) {
   int status;
   bool result = false;
   XTextProperty window_name;
-  window_name.value = NULL;
+  window_name.value = nullptr;
   if (window) {
     status = XGetWMName(display(), window, &window_name);
     if (status && window_name.value && window_name.nitems) {
       int cnt;
-      char **list = NULL;
+      char **list = nullptr;
       status = Xutf8TextPropertyToTextList(display(), &window_name, &list,
                                            &cnt);
       if (status >= Success && cnt && *list) {
         if (cnt > 1) {
           LOG(LS_INFO) << "Window has " << cnt
                        << " text properties, only using the first one.";
         }
         *title = *list;
         result = true;
       }
       if (list)
         XFreeStringList(list);
     }
     if (window_name.value)
       XFree(window_name.value);
   }
   return result;
 }
 
 }  // namespace
 
 // static
 WindowCapturer* WindowCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.x_display())
-    return NULL;
+    return nullptr;
   return new WindowCapturerLinux(options);
 }
 
 }  // namespace webrtc