Add reference counter of DxgiDuplicatorController to unload DXGI components

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 18 matching lines @@
   return DxgiDuplicatorController::Instance()->IsSupported();
 }
 
 // static
 bool ScreenCapturerWinDirectx::RetrieveD3dInfo(D3dInfo* info) {
   // Forwards SupportedFeatureLevels() function call to
   // DxgiDuplicatorController.
   return DxgiDuplicatorController::Instance()->RetrieveD3dInfo(info);
 }
 
-ScreenCapturerWinDirectx::ScreenCapturerWinDirectx(
-    const DesktopCaptureOptions& options)
-    : callback_(nullptr) {}
+ScreenCapturerWinDirectx::ScreenCapturerWinDirectx()
+    : controller_(DxgiDuplicatorController::GetReference()) {}
 
-ScreenCapturerWinDirectx::~ScreenCapturerWinDirectx() {}
+ScreenCapturerWinDirectx::~ScreenCapturerWinDirectx() = default;
+
+bool ScreenCapturerWinDirectx::IsAvailable() const {
+  return controller_->IsSupported();
+}
+
+bool ScreenCapturerWinDirectx::GetD3dInfo(D3dInfo* info) const {
+  return controller_->RetrieveD3dInfo(info);
+}
 
 void ScreenCapturerWinDirectx::Start(Callback* callback) {
   RTC_DCHECK(!callback_);
   RTC_DCHECK(callback);
 
   callback_ = callback;
 }
 
 void ScreenCapturerWinDirectx::SetSharedMemoryFactory(
     std::unique_ptr<SharedMemoryFactory> shared_memory_factory) {
   shared_memory_factory_ = std::move(shared_memory_factory);
 }
 
 void ScreenCapturerWinDirectx::CaptureFrame() {
   RTC_DCHECK(callback_);
 
   int64_t capture_start_time_nanos = rtc::TimeNanos();
 
   frames_.MoveToNextFrame();
   if (!frames_.current_frame()) {
     frames_.ReplaceCurrentFrame(
         rtc::MakeUnique<DxgiFrame>(shared_memory_factory_.get()));
   }
 
   DxgiDuplicatorController::Result result;
   if (current_screen_id_ == kFullDesktopScreenId) {
-    result = DxgiDuplicatorController::Instance()->Duplicate(
-        frames_.current_frame());
+    result = controller_->Duplicate(frames_.current_frame());
   } else {
-    result = DxgiDuplicatorController::Instance()->DuplicateMonitor(
+    result = controller_->DuplicateMonitor(
         frames_.current_frame(), current_screen_id_);
   }
 
   using DuplicateResult = DxgiDuplicatorController::Result;
   switch (result) {
     case DuplicateResult::FRAME_PREPARE_FAILED: {
       LOG(LS_ERROR) << "Failed to allocate a new DesktopFrame.";
       // This usually means we do not have enough memory or SharedMemoryFactory
       // cannot work correctly.
       callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
@@ skipping 15 matching lines @@
           (rtc::TimeNanos() - capture_start_time_nanos) /
           rtc::kNumNanosecsPerMillisec);
       frame->set_capturer_id(DesktopCapturerId::kScreenCapturerWinDirectx);
       callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
       break;
     }
   }
 }
 
 bool ScreenCapturerWinDirectx::GetSourceList(SourceList* sources) {
-  int screen_count = DxgiDuplicatorController::Instance()->ScreenCount();
+  int screen_count = controller_->ScreenCount();
   for (int i = 0; i < screen_count; i++) {
     sources->push_back({i});
   }
   return true;
 }
 
 bool ScreenCapturerWinDirectx::SelectSource(SourceId id) {
   if (id == current_screen_id_) {
     return true;
   }
 
   if (id == kFullDesktopScreenId) {
     current_screen_id_ = id;
     return true;
   }
 
-  int screen_count = DxgiDuplicatorController::Instance()->ScreenCount();
+  int screen_count = controller_->ScreenCount();
   if (id >= 0 && id < screen_count) {
     current_screen_id_ = id;
     return true;
   }
   return false;
 }
 
 }  // namespace webrtc