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

webrtc/modules/desktop_capture/win/screen_capturer_win_gdi.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 @@
 namespace {
 
 // Constants from dwmapi.h.
 const UINT DWM_EC_DISABLECOMPOSITION = 0;
 const UINT DWM_EC_ENABLECOMPOSITION = 1;
 
 const wchar_t kDwmapiLibraryName[] = L"dwmapi.dll";
 
 }  // namespace
 
-ScreenCapturerWinGdi::ScreenCapturerWinGdi(
-    const DesktopCaptureOptions& options) {
+ScreenCapturerWinGdi::ScreenCapturerWinGdi(const DesktopCaptureOptions& options)
+    : callback_(NULL),
+      current_screen_id_(kFullDesktopScreenId),
+      desktop_dc_(NULL),
+      memory_dc_(NULL),
+      dwmapi_library_(NULL),
+      composition_func_(NULL),
+      set_thread_execution_state_failed_(false) {
   if (options.disable_effects()) {
     // Load dwmapi.dll dynamically since it is not available on XP.
     if (!dwmapi_library_)
       dwmapi_library_ = LoadLibrary(kDwmapiLibraryName);
 
     if (dwmapi_library_) {
       composition_func_ = reinterpret_cast<DwmEnableCompositionFunc>(
           GetProcAddress(dwmapi_library_, "DwmEnableComposition"));
     }
   }
@@ skipping 30 matching lines @@
       set_thread_execution_state_failed_ = true;
       LOG_F(LS_WARNING) << "Failed to make system & display power assertion: "
                         << GetLastError();
     }
   }
 
   // Make sure the GDI capture resources are up-to-date.
   PrepareCaptureResources();
 
   if (!CaptureImage()) {
-    callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
+    callback_->OnCaptureCompleted(NULL);
     return;
   }
 
   const DesktopFrame* current_frame = queue_.current_frame();
   const DesktopFrame* last_frame = queue_.previous_frame();
   if (last_frame && last_frame->size().equals(current_frame->size())) {
     // Make sure the differencer is set up correctly for these previous and
     // current screens.
     if (!differ_.get() ||
         (differ_->width() != current_frame->size().width()) ||
@@ skipping 12 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.
-  std::unique_ptr<DesktopFrame> frame = queue_.current_frame()->Share();
+  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_->OnCaptureResult(Result::SUCCESS, std::move(frame));
+  callback_->OnCaptureCompleted(frame);
 }
 
 bool ScreenCapturerWinGdi::GetScreenList(ScreenList* screens) {
   return webrtc::GetScreenList(screens);
 }
 
 bool ScreenCapturerWinGdi::SelectScreen(ScreenId id) {
   bool valid = IsScreenValid(id, &current_device_key_);
   if (valid)
     current_screen_id_ = id;
@@ skipping 10 matching lines @@
   // will restore Aero automatically if the process exits. This has no effect
   // under Windows 8 or higher.  See crbug.com/124018.
   if (composition_func_)
     (*composition_func_)(DWM_EC_DISABLECOMPOSITION);
 }
 
 void ScreenCapturerWinGdi::PrepareCaptureResources() {
   // Switch to the desktop receiving user input if different from the current
   // one.
   std::unique_ptr<Desktop> input_desktop(Desktop::GetInputDesktop());
-  if (input_desktop && !desktop_.IsSame(*input_desktop)) {
+  if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // Release GDI resources otherwise SetThreadDesktop will fail.
     if (desktop_dc_) {
       ReleaseDC(NULL, desktop_dc_);
-      desktop_dc_ = nullptr;
+      desktop_dc_ = NULL;
     }
 
     if (memory_dc_) {
       DeleteDC(memory_dc_);
-      memory_dc_ = nullptr;
+      memory_dc_ = NULL;
     }
 
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
     // So we can continue capture screen bits, just from the wrong desktop.
     desktop_.SetThreadDesktop(input_desktop.release());
 
     // Re-assert our vote to disable Aero.
     // See crbug.com/124018 and crbug.com/129906.
-    if (composition_func_) {
+    if (composition_func_ != NULL) {
       (*composition_func_)(DWM_EC_DISABLECOMPOSITION);
     }
   }
 
   // If the display bounds have changed then recreate GDI resources.
   // TODO(wez): Also check for pixel format changes.
   DesktopRect screen_rect(DesktopRect::MakeXYWH(
       GetSystemMetrics(SM_XVIRTUALSCREEN),
       GetSystemMetrics(SM_YVIRTUALSCREEN),
       GetSystemMetrics(SM_CXVIRTUALSCREEN),
       GetSystemMetrics(SM_CYVIRTUALSCREEN)));
   if (!screen_rect.equals(desktop_dc_rect_)) {
     if (desktop_dc_) {
       ReleaseDC(NULL, desktop_dc_);
-      desktop_dc_ = nullptr;
+      desktop_dc_ = NULL;
     }
     if (memory_dc_) {
       DeleteDC(memory_dc_);
-      memory_dc_ = nullptr;
+      memory_dc_ = NULL;
     }
     desktop_dc_rect_ = DesktopRect();
   }
 
-  if (!desktop_dc_) {
-    assert(!memory_dc_);
+  if (desktop_dc_ == NULL) {
+    assert(memory_dc_ == NULL);
 
     // Create GDI device contexts to capture from the desktop into memory.
-    desktop_dc_ = GetDC(nullptr);
+    desktop_dc_ = GetDC(NULL);
     if (!desktop_dc_)
       abort();
     memory_dc_ = CreateCompatibleDC(desktop_dc_);
     if (!memory_dc_)
       abort();
 
     desktop_dc_rect_ = screen_rect;
 
     // Make sure the frame buffers will be reallocated.
     queue_.Reset();
 
     helper_.ClearInvalidRegion();
   }
 }
 
 bool ScreenCapturerWinGdi::CaptureImage() {
   DesktopRect screen_rect =
       GetScreenRect(current_screen_id_, current_device_key_);
   if (screen_rect.is_empty())
     return false;
 
   DesktopSize size = screen_rect.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(screen_rect.size())) {
-    assert(desktop_dc_);
-    assert(memory_dc_);
+    assert(desktop_dc_ != NULL);
+    assert(memory_dc_ != NULL);
 
-    std::unique_ptr<DesktopFrame> buffer = DesktopFrameWin::Create(
-        size, shared_memory_factory_.get(), desktop_dc_);
+    std::unique_ptr<DesktopFrame> buffer(DesktopFrameWin::Create(
+        size, shared_memory_factory_.get(), desktop_dc_));
     if (!buffer)
       return false;
-    queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(std::move(buffer)));
+    queue_.ReplaceCurrentFrame(SharedDesktopFrame::Wrap(buffer.release()));
   }
 
   // Select the target bitmap into the memory dc and copy the rect from desktop
   // to memory.
   DesktopFrameWin* current = static_cast<DesktopFrameWin*>(
       queue_.current_frame()->GetUnderlyingFrame());
   HGDIOBJ previous_object = SelectObject(memory_dc_, current->bitmap());
-  if (previous_object) {
-    BitBlt(memory_dc_, 0, 0, screen_rect.width(), screen_rect.height(),
-           desktop_dc_, screen_rect.left(), screen_rect.top(),
+  if (previous_object != NULL) {
+    BitBlt(memory_dc_,
+           0, 0, screen_rect.width(), screen_rect.height(),
+           desktop_dc_,
+           screen_rect.left(), screen_rect.top(),
            SRCCOPY | CAPTUREBLT);
 
     // Select back the previously selected object to that the device contect
     // could be destroyed independently of the bitmap if needed.
     SelectObject(memory_dc_, previous_object);
   }
   return true;
 }
 
 }  // namespace webrtc