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

webrtc/modules/desktop_capture/window_capturer_win.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 77 matching lines @@
   // WindowCapturer interface.
   bool GetWindowList(WindowList* windows) override;
   bool SelectWindow(WindowId id) override;
   bool BringSelectedWindowToFront() override;
 
   // DesktopCapturer interface.
   void Start(Callback* callback) override;
   void Capture(const DesktopRegion& region) override;
 
  private:
-  Callback* callback_;
+  Callback* callback_ = nullptr;
 
-  // HWND and HDC for the currently selected window or NULL if window is not
+  // HWND and HDC for the currently selected window or nullptr if window is not
   // selected.
-  HWND window_;
+  HWND window_ = nullptr;
 
   DesktopSize previous_size_;
 
   AeroChecker aero_checker_;
 
   // This map is used to avoid flickering for the case when SelectWindow() calls
   // are interleaved with Capture() calls.
   std::map<HWND, DesktopSize> window_size_map_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerWin);
 };
 
-WindowCapturerWin::WindowCapturerWin()
-    : callback_(NULL),
-      window_(NULL) {
-}
-
-WindowCapturerWin::~WindowCapturerWin() {
-}
+WindowCapturerWin::WindowCapturerWin() {}
+WindowCapturerWin::~WindowCapturerWin() {}
 
 bool WindowCapturerWin::GetWindowList(WindowList* windows) {
   WindowList result;
   LPARAM param = reinterpret_cast<LPARAM>(&result);
   if (!EnumWindows(&WindowsEnumerationHandler, param))
     return false;
   windows->swap(result);
 
   std::map<HWND, DesktopSize> new_map;
   for (const auto& item : *windows) {
@@ skipping 29 matching lines @@
 void WindowCapturerWin::Start(Callback* callback) {
   assert(!callback_);
   assert(callback);
 
   callback_ = callback;
 }
 
 void WindowCapturerWin::Capture(const DesktopRegion& region) {
   if (!window_) {
     LOG(LS_ERROR) << "Window hasn't been selected: " << GetLastError();
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   // Stop capturing if the window has been closed.
   if (!IsWindow(window_)) {
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   // Return a 1x1 black frame if the window is minimized or invisible, to match
   // behavior on mace. Window can be temporarily invisible during the
   // transition of full screen mode on/off.
   if (IsIconic(window_) || !IsWindowVisible(window_)) {
-    BasicDesktopFrame* frame = new BasicDesktopFrame(DesktopSize(1, 1));
+    std::unique_ptr<DesktopFrame> frame(
+        new BasicDesktopFrame(DesktopSize(1, 1)));
     memset(frame->data(), 0, frame->stride() * frame->size().height());
 
     previous_size_ = frame->size();
     window_size_map_[window_] = previous_size_;
-    callback_->OnCaptureCompleted(frame);
+    callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
     return;
   }
 
   DesktopRect original_rect;
   DesktopRect cropped_rect;
   if (!GetCroppedWindowRect(window_, &cropped_rect, &original_rect)) {
     LOG(LS_WARNING) << "Failed to get window info: " << GetLastError();
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     return;
   }
 
   HDC window_dc = GetWindowDC(window_);
   if (!window_dc) {
     LOG(LS_WARNING) << "Failed to get window DC: " << GetLastError();
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     return;
   }
 
   std::unique_ptr<DesktopFrameWin> frame(
-      DesktopFrameWin::Create(cropped_rect.size(), NULL, window_dc));
+      DesktopFrameWin::Create(cropped_rect.size(), nullptr, window_dc));
   if (!frame.get()) {
     ReleaseDC(window_, window_dc);
-    callback_->OnCaptureCompleted(NULL);
+    callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     return;
   }
 
   HDC mem_dc = CreateCompatibleDC(window_dc);
   HGDIOBJ previous_object = SelectObject(mem_dc, frame->bitmap());
   BOOL result = FALSE;
 
   // When desktop composition (Aero) is enabled each window is rendered to a
   // private buffer allowing BitBlt() to get the window content even if the
   // window is occluded. PrintWindow() is slower but lets rendering the window
@@ skipping 32 matching lines @@
   window_size_map_[window_] = previous_size_;
 
   frame->mutable_updated_region()->SetRect(
       DesktopRect::MakeSize(frame->size()));
 
   if (!result) {
     LOG(LS_ERROR) << "Both PrintWindow() and BitBlt() failed.";
     frame.reset();
   }
 
-  callback_->OnCaptureCompleted(frame.release());
+  callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
 }
 
 }  // namespace
 
 // static
 WindowCapturer* WindowCapturer::Create(const DesktopCaptureOptions& options) {
   return new WindowCapturerWin();
 }
 
 }  // namespace webrtc