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

webrtc/modules/desktop_capture/win/screen_capturer_win_directx.cc

 /*
  *  Copyright (c) 2016 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 395 matching lines @@
   rtc::CritScope lock(&g_container->duplication_lock);
   // Make sure nobody is using current instance.
   rtc::CritScope lock2(&g_container->acquire_lock);
   if (g_container->duplication) {
     return true;
   }
 
   _com_error error = g_container->output1->DuplicateOutput(
       static_cast<IUnknown*>(g_container->device),
       g_container->duplication.GetAddressOf());
-  if (error.Error() == S_OK && g_container->duplication) {
-    memset(&g_container->duplication_desc, 0, sizeof(DXGI_OUTDUPL_DESC));
-    g_container->duplication->GetDesc(&g_container->duplication_desc);
-    if (g_container->duplication_desc.ModeDesc.Format !=
-        DXGI_FORMAT_B8G8R8A8_UNORM) {
-      g_container->duplication.Reset();
-      LOG(LS_ERROR) << "IDXGIDuplicateOutput does not use RGBA (8 bit) "
-                       "format, which is required by downstream components, "
-                       "format is "
-                    << g_container->duplication_desc.ModeDesc.Format;
-      return false;
-    }
-    return true;
-  } else {
-    // Make sure we have correct signal and duplicate the output next time.
+  if (error.Error() != S_OK || !g_container->duplication) {
     g_container->duplication.Reset();
     LOG(LS_WARNING) << "Failed to duplicate output from IDXGIOutput1, error "
                     << error.ErrorMessage() << ", with code "
                     << error.Error();
+    return false;
   }
 
-  return false;
+  memset(&g_container->duplication_desc, 0, sizeof(DXGI_OUTDUPL_DESC));
+  g_container->duplication->GetDesc(&g_container->duplication_desc);
+  if (g_container->duplication_desc.ModeDesc.Format !=
+      DXGI_FORMAT_B8G8R8A8_UNORM) {
+    g_container->duplication.Reset();
+    LOG(LS_ERROR) << "IDXGIDuplicateOutput does not use RGBA (8 bit) "
+                     "format, which is required by downstream components, "
+                     "format is "
+                  << g_container->duplication_desc.ModeDesc.Format;
+    return false;
+  }
+
+  return true;
 }
 
 bool ScreenCapturerWinDirectx::ForceDuplicateOutput() {
   // We are updating the instance.
   rtc::CritScope lock(&g_container->duplication_lock);
   // Make sure nobody is using current instance.
   rtc::CritScope lock2(&g_container->acquire_lock);
 
   if (g_container->duplication) {
     g_container->duplication->ReleaseFrame();
     g_container->duplication.Reset();
   }
 
   return DuplicateOutput();
 }
 
 ScreenCapturerWinDirectx::ScreenCapturerWinDirectx(
     const DesktopCaptureOptions& options)
     : callback_(nullptr), set_thread_execution_state_failed_(false) {
   RTC_DCHECK(g_container && g_container->initialize_result);
 
   // Texture instance won't change forever.
   while (!surfaces_.current_frame()) {
-    surfaces_.ReplaceCurrentFrame(
-        new rtc::scoped_refptr<Texture>(new Texture()));
+    surfaces_.ReplaceCurrentFrame(std::unique_ptr<rtc::scoped_refptr<Texture>>(
+        new rtc::scoped_refptr<Texture>(new Texture())));
     surfaces_.MoveToNextFrame();
   }
 }
 
 ScreenCapturerWinDirectx::~ScreenCapturerWinDirectx() {}
 
 void ScreenCapturerWinDirectx::Start(Callback* callback) {
   RTC_DCHECK(!callback_);
   RTC_DCHECK(callback);
 
@@ skipping 113 matching lines @@
       // Current frame does not have a same size as last captured surface.
       std::unique_ptr<DesktopFrame> new_frame =
           SharedMemoryDesktopFrame::Create(
               surfaces_.current_frame()->get()->size(),
               shared_memory_factory_.get());
       if (!new_frame) {
         LOG(LS_ERROR) << "Failed to allocate a new SharedMemoryDesktopFrame";
         return std::unique_ptr<DesktopFrame>();
       }
       frames_.ReplaceCurrentFrame(
-          SharedDesktopFrame::Wrap(new_frame.release()));
+          SharedDesktopFrame::Wrap(std::move(new_frame)));
     }
-    result.reset(frames_.current_frame()->Share());
+    result = frames_.current_frame()->Share();
 
     std::unique_ptr<DesktopFrame> frame(
         new DxgiDesktopFrame(*surfaces_.current_frame()));
     // Copy data into SharedMemory.
     for (DesktopRegion::Iterator it(
              surfaces_.current_frame()->get()->copied_region());
          !it.IsAtEnd();
          it.Advance()) {
       result->CopyPixelsFrom(*frame, it.rect().top_left(), it.rect());
     }
     result->set_dpi(frame->dpi());
   } else {
     result.reset(new DxgiDesktopFrame(*surfaces_.current_frame()));
   }
   RTC_DCHECK(result);
   *result->mutable_updated_region() =
       surfaces_.current_frame()->get()->updated_region();
   return result;
 }
 
 void ScreenCapturerWinDirectx::Capture(const DesktopRegion& region) {
   RTC_DCHECK(callback_);
 
   if (!g_container->duplication && !DuplicateOutput()) {
-    // Receive a capture request when application is shutting down, or between
-    // mode change.
-    callback_->OnCaptureCompleted(nullptr);
+    // Failed to initialize desktop duplication.
+    callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
     return;
   }
 
   RTC_DCHECK(g_container->duplication);
   int64_t capture_start_time_nanos = rtc::TimeNanos();
 
   if (!SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED)) {
     if (!set_thread_execution_state_failed_) {
       set_thread_execution_state_failed_ = true;
       LOG(LS_WARNING) << "Failed to make system & display power assertion: "
@@ skipping 13 matching lines @@
     EmitCurrentFrame();
     return;
   }
 
   if (error.Error() != S_OK) {
     LOG(LS_ERROR) << "Failed to capture frame, error " << error.ErrorMessage()
                   << ", code " << error.Error();
     if (ForceDuplicateOutput()) {
       EmitCurrentFrame();
     } else {
-      callback_->OnCaptureCompleted(nullptr);
+      callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     }
     return;
   }
 
   if (frame_info.AccumulatedFrames == 0) {
     g_container->duplication->ReleaseFrame();
     EmitCurrentFrame();
     return;
   }
 
   // Everything looks good so far, build next frame.
   std::unique_ptr<DesktopFrame> result =
       ProcessFrame(frame_info, resource.Get());
   // DetectUpdatedRegion may release last g_container->duplication. But
   // ForctDuplicateOutput function will always release last frame, so there is
   // no potential leak.
   if (g_container->duplication) {
     g_container->duplication->ReleaseFrame();
   }
   if (!result) {
-    callback_->OnCaptureCompleted(nullptr);
+    callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     return;
   }
 
   result->set_capture_time_ms(
       (rtc::TimeNanos() - capture_start_time_nanos) /
       rtc::kNumNanosecsPerMillisec);
-  callback_->OnCaptureCompleted(result.release());
+  callback_->OnCaptureResult(Result::SUCCESS, std::move(result));
 }
 
 bool ScreenCapturerWinDirectx::GetScreenList(ScreenList* screens) {
   return true;
 }
 
 bool ScreenCapturerWinDirectx::SelectScreen(ScreenId id) {
   // Only full desktop capture is supported.
   return id == kFullDesktopScreenId;
 }
 
 void ScreenCapturerWinDirectx::EmitCurrentFrame() {
   if (!surfaces_.current_frame()->get()->bits()) {
     // At the very begining, we have not captured any frames.
-    callback_->OnCaptureCompleted(nullptr);
+    callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     return;
   }
 
   if (shared_memory_factory_) {
     // If shared_memory_factory_ is provided, last frame is stored in frames_
     // queue. If there is not an existing frame (at the very begining), we can
     // only return a nullptr.
     if (frames_.current_frame()) {
-      std::unique_ptr<SharedDesktopFrame> frame(
-          frames_.current_frame()->Share());
+      std::unique_ptr<SharedDesktopFrame> frame =
+          frames_.current_frame()->Share();
       frame->mutable_updated_region()->Clear();
-      callback_->OnCaptureCompleted(frame.release());
+      callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
     } else {
-      callback_->OnCaptureCompleted(nullptr);
+      callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
     }
     return;
   }
 
   // If there is no shared_memory_factory_, last frame is stored in surfaces_
   // queue.
   std::unique_ptr<DesktopFrame> frame(
       new DxgiDesktopFrame(*surfaces_.current_frame()));
-  callback_->OnCaptureCompleted(frame.release());
+  callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
 }
 
 }  // namespace webrtc