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

webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.cc

 /*
  *  Copyright (c) 2014 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 21 matching lines @@
 // API. The other strings can be anything.
 static LPCTSTR kMagnifierHostClass = L"ScreenCapturerWinMagnifierHost";
 static LPCTSTR kHostWindowName = L"MagnifierHost";
 static LPCTSTR kMagnifierWindowClass = L"Magnifier";
 static LPCTSTR kMagnifierWindowName = L"MagnifierWindow";
 
 Atomic32 ScreenCapturerWinMagnifier::tls_index_(TLS_OUT_OF_INDEXES);
 
 ScreenCapturerWinMagnifier::ScreenCapturerWinMagnifier(
     std::unique_ptr<ScreenCapturer> fallback_capturer)
-    : fallback_capturer_(std::move(fallback_capturer)),
-      fallback_capturer_started_(false),
-      callback_(NULL),
-      current_screen_id_(kFullDesktopScreenId),
-      excluded_window_(NULL),
-      set_thread_execution_state_failed_(false),
-      desktop_dc_(NULL),
-      mag_lib_handle_(NULL),
-      mag_initialize_func_(NULL),
-      mag_uninitialize_func_(NULL),
-      set_window_source_func_(NULL),
-      set_window_filter_list_func_(NULL),
-      set_image_scaling_callback_func_(NULL),
-      host_window_(NULL),
-      magnifier_window_(NULL),
-      magnifier_initialized_(false),
-      magnifier_capture_succeeded_(true) {}
+    : fallback_capturer_(std::move(fallback_capturer)) {}
 
 ScreenCapturerWinMagnifier::~ScreenCapturerWinMagnifier() {
   // DestroyWindow must be called before MagUninitialize. magnifier_window_ is
   // destroyed automatically when host_window_ is destroyed.
   if (host_window_)
     DestroyWindow(host_window_);
 
   if (magnifier_initialized_)
     mag_uninitialize_func_();
 
@@ skipping 86 matching lines @@
     helper_.InvalidateRegion(region);
   } else {
     // No previous frame is available, or the screen is resized. Invalidate the
     // whole screen.
     helper_.InvalidateScreen(current_frame->size());
   }
 
   helper_.set_size_most_recent(current_frame->size());
 
   // Emit the current frame.
-  DesktopFrame* frame = queue_.current_frame()->Share();
+  std::unique_ptr<DesktopFrame> frame = queue_.current_frame()->Share();
   frame->set_dpi(DesktopVector(GetDeviceCaps(desktop_dc_, LOGPIXELSX),
                                GetDeviceCaps(desktop_dc_, LOGPIXELSY)));
   frame->mutable_updated_region()->Clear();
   helper_.TakeInvalidRegion(frame->mutable_updated_region());
-  frame->set_capture_time_ms(
-      (rtc::TimeNanos() - capture_start_time_nanos) /
-      rtc::kNumNanosecsPerMillisec);
-  callback_->OnCaptureCompleted(frame);
+  frame->set_capture_time_ms((rtc::TimeNanos() - capture_start_time_nanos) /
+                             rtc::kNumNanosecsPerMillisec);
+  callback_->OnCaptureCompleted(std::move(frame));
 }
 
 bool ScreenCapturerWinMagnifier::GetScreenList(ScreenList* screens) {
   return webrtc::GetScreenList(screens);
 }
 
 bool ScreenCapturerWinMagnifier::SelectScreen(ScreenId id) {
   bool valid = IsScreenValid(id, &current_device_key_);
 
   // Set current_screen_id_ even if the fallback capturer is being used, so we
@@ skipping 13 matching lines @@
     set_window_filter_list_func_(
         magnifier_window_, MW_FILTERMODE_EXCLUDE, 1, &excluded_window_);
   }
 }
 
 bool ScreenCapturerWinMagnifier::CaptureImage(const DesktopRect& rect) {
   assert(magnifier_initialized_);
 
   // Set the magnifier control to cover the captured rect. The content of the
   // magnifier control will be the captured image.
-  BOOL result = SetWindowPos(magnifier_window_,
-                             NULL,
-                             rect.left(), rect.top(),
-                             rect.width(), rect.height(),
-                             0);
+  BOOL result = SetWindowPos(magnifier_window_, nullptr, rect.left(),

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

nit: Technically should stay NULL.

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

Done.

+                             rect.top(), rect.width(), rect.height(), 0);
   if (!result) {
     LOG_F(LS_WARNING) << "Failed to call SetWindowPos: " << GetLastError()
                       << ". Rect = {" << rect.left() << ", " << rect.top()
                       << ", " << rect.right() << ", " << rect.bottom() << "}";
     return false;
   }
 
   magnifier_capture_succeeded_ = false;
 
   RECT native_rect = {rect.left(), rect.top(), rect.right(), rect.bottom()};
@@ skipping 28 matching lines @@
           TlsGetValue(tls_index_.Value()));
 
   owner->OnCaptured(srcdata, srcheader);
 
   return TRUE;
 }
 
 bool ScreenCapturerWinMagnifier::InitializeMagnifier() {
   assert(!magnifier_initialized_);
 
-  desktop_dc_ = GetDC(NULL);
+  desktop_dc_ = GetDC(nullptr);
 
   mag_lib_handle_ = LoadLibrary(L"Magnification.dll");
   if (!mag_lib_handle_)
     return false;
 
   // Initialize Magnification API function pointers.
   mag_initialize_func_ = reinterpret_cast<MagInitializeFunc>(
       GetProcAddress(mag_lib_handle_, "MagInitialize"));
   mag_uninitialize_func_ = reinterpret_cast<MagUninitializeFunc>(
       GetProcAddress(mag_lib_handle_, "MagUninitialize"));
@@ skipping 13 matching lines @@
     return false;
   }
 
   BOOL result = mag_initialize_func_();
   if (!result) {
     LOG_F(LS_WARNING) << "Failed to initialize ScreenCapturerWinMagnifier: "
                       << "error from MagInitialize " << GetLastError();
     return false;
   }
 
-  HMODULE hInstance = NULL;
+  HMODULE hInstance = nullptr;
   result = GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                                   GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                               reinterpret_cast<char*>(&DefWindowProc),
                               &hInstance);
   if (!result) {
     mag_uninitialize_func_();
     LOG_F(LS_WARNING) << "Failed to initialize ScreenCapturerWinMagnifier: "
                       << "error from GetModulehandleExA " << GetLastError();
     return false;
   }
 
   // Register the host window class. See the MSDN documentation of the
   // Magnification API for more infomation.
   WNDCLASSEX wcex = {};
   wcex.cbSize = sizeof(WNDCLASSEX);
   wcex.lpfnWndProc = &DefWindowProc;
   wcex.hInstance = hInstance;
-  wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
+  wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
   wcex.lpszClassName = kMagnifierHostClass;
 
   // Ignore the error which may happen when the class is already registered.
   RegisterClassEx(&wcex);
 
   // Create the host window.
-  host_window_ = CreateWindowEx(WS_EX_LAYERED,
-                                kMagnifierHostClass,
-                                kHostWindowName,
-                                0,
-                                0, 0, 0, 0,
-                                NULL,
-                                NULL,
-                                hInstance,
-                                NULL);
+  host_window_ =
+      CreateWindowEx(WS_EX_LAYERED, kMagnifierHostClass, kHostWindowName, 0, 0,
+                     0, 0, 0, nullptr, nullptr, hInstance, nullptr);
   if (!host_window_) {
     mag_uninitialize_func_();
     LOG_F(LS_WARNING) << "Failed to initialize ScreenCapturerWinMagnifier: "
                       << "error from creating host window " << GetLastError();
     return false;
   }
 
   // Create the magnifier control.
-  magnifier_window_ = CreateWindow(kMagnifierWindowClass,
-                                   kMagnifierWindowName,
-                                   WS_CHILD | WS_VISIBLE,
-                                   0, 0, 0, 0,
-                                   host_window_,
-                                   NULL,
-                                   hInstance,
-                                   NULL);
+  magnifier_window_ = CreateWindow(kMagnifierWindowClass, kMagnifierWindowName,
+                                   WS_CHILD | WS_VISIBLE, 0, 0, 0, 0,
+                                   host_window_, nullptr, hInstance, nullptr);
   if (!magnifier_window_) {
     mag_uninitialize_func_();
     LOG_F(LS_WARNING) << "Failed to initialize ScreenCapturerWinMagnifier: "
                       << "error from creating magnifier window "
                       << GetLastError();
     return false;
   }
 
   // Hide the host window.
   ShowWindow(host_window_, SW_HIDE);
@@ skipping 72 matching lines @@
     const DesktopSize& size) {
   // 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_.current_frame()->size().equals(size)) {
     std::unique_ptr<DesktopFrame> frame =
         shared_memory_factory_
             ? SharedMemoryDesktopFrame::Create(size,
                                                shared_memory_factory_.get())
             : std::unique_ptr<DesktopFrame>(new BasicDesktopFrame(size));
-    queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(frame.release()));
+    queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(std::move(frame)));
   }
 }
 
 void ScreenCapturerWinMagnifier::StartFallbackCapturer() {
   assert(fallback_capturer_);
   if (!fallback_capturer_started_) {
     fallback_capturer_started_ = true;
 
     fallback_capturer_->Start(callback_);
     fallback_capturer_->SelectScreen(current_screen_id_);
   }
 }
 
 }  // namespace webrtc