Add reference counter of DxgiDuplicatorController to unload DXGI components

webrtc/modules/desktop_capture/win/dxgi_duplicator_controller.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_DESKTOP_CAPTURE_WIN_DXGI_DUPLICATOR_CONTROLLER_H_
 #define WEBRTC_MODULES_DESKTOP_CAPTURE_WIN_DXGI_DUPLICATOR_CONTROLLER_H_
 
 #include <D3DCommon.h>
 
+#include <atomic>
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "webrtc/modules/desktop_capture/resolution_change_detector.h"
 #include "webrtc/modules/desktop_capture/shared_desktop_frame.h"
 #include "webrtc/modules/desktop_capture/win/d3d_device.h"
 #include "webrtc/modules/desktop_capture/win/dxgi_adapter_duplicator.h"
 #include "webrtc/modules/desktop_capture/win/dxgi_context.h"
 #include "webrtc/modules/desktop_capture/win/dxgi_frame.h"
 
 namespace webrtc {
 
 // A controller for all the objects we need to call Windows DirectX capture APIs
 // It's a singleton because only one IDXGIOutputDuplication instance per monitor
 // is allowed per application.
 //
 // Consumers should create a DxgiDuplicatorController::Context and keep it
 // throughout their lifetime, and pass it when calling Duplicate(). Consumers
 // can also call IsSupported() to determine whether the system supports DXGI
 // duplicator or not. If a previous IsSupported() function call returns true,
 // but a later Duplicate() returns false, this usually means the display mode is
 // changing. Consumers should retry after a while. (Typically 50 milliseconds,
 // but according to hardware performance, this time may vary.)
 class DxgiDuplicatorController {
+ private:
+  struct ReferenceReleaser final {
+    void operator()(DxgiDuplicatorController* instance) const;
+  };
+
  public:
   using Context = DxgiFrameContext;
+  using Reference =
+      std::unique_ptr<DxgiDuplicatorController, ReferenceReleaser>;

[Do not use (sergeyu), 2017/06/15 19:25:19]

Do we really need this instead of scoped_refptr<>?

[Hzj_jie, 2017/06/15 20:32:02]

I can imagine three solutions by using scoped_refptr.
1. scoped_refptr<DxgiDuplicatorController>, while DxgiDuplicatorController
inherits rtc::RefCountedObject.
That seems not right: there is at most one DxgiDuplicatorController instance, so
deleting this singleton instance or creating another one are both not right.

2. scoped_refptr<DxgiDuplicatorControllerUnloader>. In the destructor of
DxgiDuplicatorControllerUnloader, we will call the Unload() function.
The problem is that consumers need to access DxgiDuplicatorController from
DxgiDuplicatorControllerUnloader, i.e. DxgiDuplicatorControllerUnloader needs to
have operator-> or operator*, which has been implemented by std::unique_ptr
already.

3. scoped_refptr<DxgiDuplicatorController>, and let DxgiDuplicatorController
implement rtc::RefCountInterface itself.
I have not seen a significant difference, except for the ReferenceReleaser
functor. (I need to write several more lines of code.)

If you are talking about the third solution, I have no objective to use it. But
I prefer stl over scoped_refptr.

[Sergey Ulanov, 2017/06/16 05:59:58]

I was thinking about (3), but I think (1) may work as well if you keep the
constructor private and make the destructor reset a global reference kept
internally (i.e. you always have either 0 or 1 instance of the class). 
The problem with the current solution is that unique_ptr<> is used for an object
that is not owned. It looks to the consumer as if it gets its own instance of
the controller, which is not true. Also scoped_refptr<> is the common solution
for any ref-counted object, so it seems to make sense to use it here.

Another alternative that I would prefer over the current solution is to have
Reference as a class with a move semantics similar to unique_ptr<>. 

 
   // A collection of D3d information we are interested on, which may impact
   // capturer performance or reliability.
   struct D3dInfo {
     // Each video adapter has its own D3D_FEATURE_LEVEL, so this structure
     // contains the minimum and maximium D3D_FEATURE_LEVELs current system
     // supports.
     // Both fields can be 0, which is the default value to indicate no valid
     // D3D_FEATURE_LEVEL has been retrieved from underlying OS APIs.
     D3D_FEATURE_LEVEL min_feature_level;
     D3D_FEATURE_LEVEL max_feature_level;
 
     // TODO(zijiehe): Add more fields, such as manufacturer name, mode, driver
     // version.
   };
 
   enum class Result {
     SUCCEEDED,
     FRAME_PREPARE_FAILED,
     INITIALIZATION_FAILED,
     DUPLICATION_FAILED,
     INVALID_MONITOR_ID,
   };
 
+  // Deprecated: use "GetRefence()" instead.
   // Returns the singleton instance of DxgiDuplicatorController.
   static DxgiDuplicatorController* Instance();
 
-  // Destructs current instance. We need to make sure COM components and their
-  // containers are destructed in correct order. This function calls
-  // Deinitialize() to do the real work.
-  ~DxgiDuplicatorController();
-
+  static Reference GetReference();
   // All the following public functions implicitly call Initialize() function.
 
   // Detects whether the system supports DXGI based capturer.
   bool IsSupported();
 
   // Returns a copy of D3dInfo composed by last Initialize() function call.
   bool RetrieveD3dInfo(D3dInfo* info);
 
   // Captures current screen and writes into |frame|.
   // TODO(zijiehe): Windows cannot guarantee the frames returned by each
@@ skipping 15 matching lines @@
   // by an integer in the range of [0, ScreenCount()). If system does not
   // support DXGI based capturer, this function returns 0.
   int ScreenCount();
 
  private:
   // DxgiFrameContext calls private Unregister(Context*) function during
   // destructing.
   friend DxgiFrameContext::~DxgiFrameContext();
 
   // A private constructor to ensure consumers to use
-  // DxgiDuplicatorController::Instance().
+  // DxgiDuplicatorController::GetReference().
   DxgiDuplicatorController();
 
+  // Not implemented: The singleton DxgiDuplicatorController instance should not
+  // be deleted.
+  ~DxgiDuplicatorController();
+
   // Does the real duplication work. Setting |monitor_id| < 0 to capture entire
   // screen. This function calls Initialize(). And if the duplication failed,
   // this function calls Deinitialize() to ensure the Dxgi components can be
   // reinitialized next time.
   Result DoDuplicate(DxgiFrame* frame, int monitor_id);
 
+  // Unload all the DXGI components and releases the resources. This function
+  // wraps Deinitialize() with |lock_|.
+  void Unload();
+
   // Unregisters Context from this instance and all DxgiAdapterDuplicator(s)
   // it owns.
   void Unregister(const Context* const context);
 
   // All functions below should be called in |lock_| locked scope and should be
   // after a successful Initialize().
 
   // If current instance has not been initialized, executes DoInitialize()
   // function, and returns initialize result. Otherwise directly returns true.
   // This function may calls Deinitialize() if initialization failed.
@@ skipping 48 matching lines @@
   // According to http://crbug.com/682112, dxgi capturer returns a black frame
   // during first several capture attempts.
   bool EnsureFrameCaptured(Context* context, SharedDesktopFrame* target);
 
   // Moves |desktop_rect_| and all underlying |duplicators_|, putting top left
   // corner of the desktop at (0, 0). This is necessary because DXGI_OUTPUT_DESC
   // may return negative coordinates. Called from DoInitialize() after all
   // DxgiAdapterDuplicator and DxgiOutputDuplicator instances are initialized.
   void TranslateRect();
 
+  // The count of references which are now "living".
+  static std::atomic_int refcount_;
+
   // This lock must be locked whenever accessing any of the following objects.
   rtc::CriticalSection lock_;
 
   // A self-incremented integer to compare with the one in Context. It ensures
   // a Context instance is always initialized after DxgiDuplicatorController.
   int identity_ = 0;
   DesktopRect desktop_rect_;
   DesktopVector dpi_;
   std::vector<DxgiAdapterDuplicator> duplicators_;
   D3dInfo d3d_info_;
   ResolutionChangeDetector resolution_change_detector_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_DESKTOP_CAPTURE_WIN_DXGI_DUPLICATOR_CONTROLLER_H_