Reland "Use Microsoft's ComPtr to wrap D3D12 objects."

This is a reland of 0ef0491

Original change's description:
> Use Microsoft's ComPtr to wrap D3D12 objects.
> 
> Change-Id: I4bd173428a2b65f0bc1994fb794ef9d4d68d5ba0
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/314957
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Commit-Queue: Jim Van Verth <jvanverth@google.com>

Change-Id: Id0199db4061c67ed53da35e74dc31a004744be95
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/315655
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Jim Van Verth <jvanverth@google.com>

Author: jvanverth

RELEASE_NOTES.txt

@@ -9,6 +9,9 @@ Milestone 87
 
   * <insert new release notes here>
 
+  * Switch to using Microsoft::WRL::ComPtr for wrapping D3D12 objects.
+    https://review.skia.org/314957
+
   * GPU backends now properly honor the SkFilterQuality when calling drawAtlas.
     https://review.skia.org/313081
 

include/gpu/d3d/GrD3DBackendContext.h

@@ -25,9 +25,9 @@
 // The BackendContext contains all of the base D3D objects needed by the GrD3DGpu. The assumption
 // is that the client will set these up and pass them to the GrD3DGpu constructor.
 struct SK_API GrD3DBackendContext {
-    gr_cp<IDXGIAdapter1> fAdapter;
-    gr_cp<ID3D12Device> fDevice;
-    gr_cp<ID3D12CommandQueue> fQueue;
+    ComPtr<IDXGIAdapter1> fAdapter;
+    ComPtr<ID3D12Device> fDevice;
+    ComPtr<ID3D12CommandQueue> fQueue;
     GrProtected fProtectedContext = GrProtected::kNo;
 };
 

include/gpu/d3d/GrD3DTypes.h

@@ -24,138 +24,15 @@
 #include "include/gpu/d3d/GrD3DTypesMinimal.h"
 #include <d3d12.h>
 #include <dxgi1_4.h>
+#include <wrl/client.h>
 
- /** Check if the argument is non-null, and if so, call obj->AddRef() and return obj.
-  */
-template <typename T> static inline T* GrSafeComAddRef(T* obj) {
-    if (obj) {
-        obj->AddRef();
-    }
-    return obj;
-}
-
-/** Check if the argument is non-null, and if so, call obj->Release()
- */
-template <typename T> static inline void GrSafeComRelease(T* obj) {
-    if (obj) {
-        obj->Release();
-    }
-}
-
-template <typename T> class gr_cp {
-public:
-    using element_type = T;
-
-    constexpr gr_cp() : fObject(nullptr) {}
-    constexpr gr_cp(std::nullptr_t) : fObject(nullptr) {}
-
-    /**
-     *  Shares the underlying object by calling AddRef(), so that both the argument and the newly
-     *  created gr_cp both have a reference to it.
-     */
-    gr_cp(const gr_cp<T>& that) : fObject(GrSafeComAddRef(that.get())) {}
-
-    /**
-     *  Move the underlying object from the argument to the newly created gr_cp. Afterwards only
-     *  the new gr_cp will have a reference to the object, and the argument will point to null.
-     *  No call to AddRef() or Release() will be made.
-     */
-    gr_cp(gr_cp<T>&& that) : fObject(that.release()) {}
-
-    /**
-     *  Adopt the bare object into the newly created gr_cp.
-     *  No call to AddRef() or Release() will be made.
-     */
-    explicit gr_cp(T* obj) {
-        fObject = obj;
-    }
-
-    /**
-     *  Calls Release() on the underlying object pointer.
-     */
-    ~gr_cp() {
-        GrSafeComRelease(fObject);
-        SkDEBUGCODE(fObject = nullptr);
-    }
-
-    /**
-     *  Shares the underlying object referenced by the argument by calling AddRef() on it. If this
-     *  gr_cp previously had a reference to an object (i.e. not null) it will call Release()
-     *  on that object.
-     */
-    gr_cp<T>& operator=(const gr_cp<T>& that) {
-        if (this != &that) {
-            this->reset(GrSafeComAddRef(that.get()));
-        }
-        return *this;
-    }
-
-    /**
-     *  Move the underlying object from the argument to the gr_cp. If the gr_cp
-     *  previously held a reference to another object, Release() will be called on that object.
-     *  No call to AddRef() will be made.
-     */
-    gr_cp<T>& operator=(gr_cp<T>&& that) {
-        this->reset(that.release());
-        return *this;
-    }
-
-    explicit operator bool() const { return this->get() != nullptr; }
-
-    T* get() const { return fObject; }
-    T* operator->() const { return fObject; }
-    T** operator&() { return &fObject; }
-
-    /**
-     *  Adopt the new object, and call Release() on any previously held object (if not null).
-     *  No call to AddRef() will be made.
-     */
-    void reset(T* object = nullptr) {
-        T* oldObject = fObject;
-        fObject = object;
-        GrSafeComRelease(oldObject);
-    }
-
-    /**
-     *  Shares the new object by calling AddRef() on it. If this gr_cp previously had a
-     *  reference to an object (i.e. not null) it will call Release() on that object.
-     */
-    void retain(T* object) {
-        if (this->fObject != object) {
-            this->reset(GrSafeComAddRef(object));
-        }
-    }
-
-    /**
-     *  Return the original object, and set the internal object to nullptr.
-     *  The caller must assume ownership of the object, and manage its reference count directly.
-     *  No call to Release() will be made.
-     */
-    T* SK_WARN_UNUSED_RESULT release() {
-        T* obj = fObject;
-        fObject = nullptr;
-        return obj;
-    }
-
-private:
-    T* fObject;
-};
-
-template <typename T> inline bool operator==(const gr_cp<T>& a,
-                                             const gr_cp<T>& b) {
-    return a.get() == b.get();
-}
-
-template <typename T> inline bool operator!=(const gr_cp<T>& a,
-                                             const gr_cp<T>& b) {
-    return a.get() != b.get();
-}
+using Microsoft::WRL::ComPtr;
 
 // Note: there is no notion of Borrowed or Adopted resources in the D3D backend,
 // so Ganesh will ref fResource once it's asked to wrap it.
 // Clients are responsible for releasing their own ref to avoid memory leaks.
 struct GrD3DTextureResourceInfo {
-    gr_cp<ID3D12Resource>    fResource;
+    ComPtr<ID3D12Resource>   fResource;
     D3D12_RESOURCE_STATES    fResourceState;
     DXGI_FORMAT              fFormat;
     uint32_t                 fLevelCount;
@@ -170,7 +47,7 @@ struct GrD3DTextureResourceInfo {
             , fSampleQualityPattern(DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN)
             , fProtected(GrProtected::kNo) {}
 
-    GrD3DTextureResourceInfo(ID3D12Resource* resource,
+    GrD3DTextureResourceInfo(const ComPtr<ID3D12Resource>& resource,
                              D3D12_RESOURCE_STATES resourceState,
                              DXGI_FORMAT format,
                              uint32_t levelCount,
@@ -207,8 +84,8 @@ struct GrD3DFenceInfo {
         , fValue(0) {
     }
 
-    gr_cp<ID3D12Fence> fFence;
-    uint64_t           fValue;  // signal value for the fence
+    ComPtr<ID3D12Fence> fFence;
+    uint64_t            fValue;  // signal value for the fence
 };
 
 #endif

src/gpu/d3d/GrD3DBuffer.cpp

@@ -16,7 +16,7 @@
 #define VALIDATE() do {} while(false)
 #endif
 
-static gr_cp<ID3D12Resource> make_d3d_buffer(GrD3DGpu* gpu,
+static ComPtr<ID3D12Resource> make_d3d_buffer(GrD3DGpu* gpu,
                                               size_t size,
                                               GrGpuBufferType intendedType,
                                               GrAccessPattern accessPattern,
@@ -61,7 +61,7 @@ static gr_cp<ID3D12Resource> make_d3d_buffer(GrD3DGpu* gpu,
     bufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
     bufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
 
-    ID3D12Resource* resource;
+    ComPtr<ID3D12Resource> resource;
     HRESULT hr = gpu->device()->CreateCommittedResource(
             &heapProperties,
             D3D12_HEAP_FLAG_NONE,
@@ -73,7 +73,7 @@ static gr_cp<ID3D12Resource> make_d3d_buffer(GrD3DGpu* gpu,
         return nullptr;
     }
 
-    return gr_cp<ID3D12Resource>(resource);
+    return resource;
 }
 
 sk_sp<GrD3DBuffer> GrD3DBuffer::Make(GrD3DGpu* gpu, size_t size, GrGpuBufferType intendedType,
@@ -82,8 +82,8 @@ sk_sp<GrD3DBuffer> GrD3DBuffer::Make(GrD3DGpu* gpu, size_t size, GrGpuBufferType
     D3D12_RESOURCE_STATES resourceState;
 
 
-    gr_cp<ID3D12Resource> resource = make_d3d_buffer(gpu, size, intendedType, accessPattern,
-                                                     &resourceState);
+    ComPtr<ID3D12Resource> resource = make_d3d_buffer(gpu, size, intendedType, accessPattern,
+                                                      &resourceState);
     if (!resource) {
         return nullptr;
     }
@@ -93,7 +93,7 @@ sk_sp<GrD3DBuffer> GrD3DBuffer::Make(GrD3DGpu* gpu, size_t size, GrGpuBufferType
 }
 
 GrD3DBuffer::GrD3DBuffer(GrD3DGpu* gpu, size_t size, GrGpuBufferType intendedType,
-                         GrAccessPattern accessPattern, gr_cp<ID3D12Resource> bufferResource,
+                         GrAccessPattern accessPattern, ComPtr<ID3D12Resource> bufferResource,
                          D3D12_RESOURCE_STATES resourceState)
     : INHERITED(gpu, size, intendedType, accessPattern)
     , fResourceState(resourceState)

src/gpu/d3d/GrD3DBuffer.h

@@ -23,13 +23,13 @@ class GrD3DBuffer : public GrGpuBuffer {
 
     ID3D12Resource* d3dResource() const {
         SkASSERT(fD3DResource);
-        return fD3DResource.get();
+        return fD3DResource.Get();
     }
 
     void setResourceState(const GrD3DGpu* gpu, D3D12_RESOURCE_STATES newResourceState);
 
 protected:
-    GrD3DBuffer(GrD3DGpu*, size_t size, GrGpuBufferType, GrAccessPattern, gr_cp<ID3D12Resource>,
+    GrD3DBuffer(GrD3DGpu*, size_t size, GrGpuBufferType, GrAccessPattern, ComPtr<ID3D12Resource>,
                 D3D12_RESOURCE_STATES);
 
     void onAbandon() override;
@@ -52,7 +52,7 @@ class GrD3DBuffer : public GrGpuBuffer {
         return reinterpret_cast<GrD3DGpu*>(this->getGpu());
     }
 
-    gr_cp<ID3D12Resource> fD3DResource;
+    ComPtr<ID3D12Resource> fD3DResource;
     ID3D12Resource* fStagingBuffer = nullptr;
     size_t fStagingOffset = 0;
 

src/gpu/d3d/GrD3DCommandList.cpp

@@ -18,8 +18,8 @@
 #include "src/gpu/d3d/GrD3DTextureResource.h"
 #include "src/gpu/d3d/GrD3DUtil.h"
 
-GrD3DCommandList::GrD3DCommandList(gr_cp<ID3D12CommandAllocator> allocator,
-                                   gr_cp<ID3D12GraphicsCommandList> commandList)
+GrD3DCommandList::GrD3DCommandList(ComPtr<ID3D12CommandAllocator> allocator,
+                                   ComPtr<ID3D12GraphicsCommandList> commandList)
     : fCommandList(std::move(commandList))
     , fAllocator(std::move(allocator)) {
 }
@@ -43,7 +43,7 @@ GrD3DCommandList::SubmitResult GrD3DCommandList::submit(ID3D12CommandQueue* queu
         return SubmitResult::kFailure;
     }
     SkASSERT(!fIsActive);
-    ID3D12CommandList* ppCommandLists[] = { fCommandList.get() };
+    ID3D12CommandList* ppCommandLists[] = { fCommandList.Get() };
     queue->ExecuteCommandLists(1, ppCommandLists);
 
     return SubmitResult::kSuccess;
@@ -52,7 +52,7 @@ GrD3DCommandList::SubmitResult GrD3DCommandList::submit(ID3D12CommandQueue* queu
 void GrD3DCommandList::reset() {
     SkASSERT(!fIsActive);
     GR_D3D_CALL_ERRCHECK(fAllocator->Reset());
-    GR_D3D_CALL_ERRCHECK(fCommandList->Reset(fAllocator.get(), nullptr));
+    GR_D3D_CALL_ERRCHECK(fCommandList->Reset(fAllocator.Get(), nullptr));
     this->onReset();
 
     this->releaseResources();
@@ -200,21 +200,21 @@ void GrD3DCommandList::addingWork() {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 std::unique_ptr<GrD3DDirectCommandList> GrD3DDirectCommandList::Make(ID3D12Device* device) {
-    gr_cp<ID3D12CommandAllocator> allocator;
+    ComPtr<ID3D12CommandAllocator> allocator;
     GR_D3D_CALL_ERRCHECK(device->CreateCommandAllocator(
                          D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&allocator)));
 
-    gr_cp<ID3D12GraphicsCommandList> commandList;
+    ComPtr<ID3D12GraphicsCommandList> commandList;
     GR_D3D_CALL_ERRCHECK(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT,
-                                                   allocator.get(), nullptr,
+                                                   allocator.Get(), nullptr,
                                                    IID_PPV_ARGS(&commandList)));
 
     auto grCL = new GrD3DDirectCommandList(std::move(allocator), std::move(commandList));
     return std::unique_ptr<GrD3DDirectCommandList>(grCL);
 }
 
-GrD3DDirectCommandList::GrD3DDirectCommandList(gr_cp<ID3D12CommandAllocator> allocator,
-                                               gr_cp<ID3D12GraphicsCommandList> commandList)
+GrD3DDirectCommandList::GrD3DDirectCommandList(ComPtr<ID3D12CommandAllocator> allocator,
+                                               ComPtr<ID3D12GraphicsCommandList> commandList)
     : GrD3DCommandList(std::move(allocator), std::move(commandList))
     , fCurrentPipelineState(nullptr)
     , fCurrentRootSignature(nullptr)
@@ -281,7 +281,7 @@ void GrD3DDirectCommandList::setViewports(unsigned int numViewports,
 
 void GrD3DDirectCommandList::setCenteredSamplePositions(unsigned int numSamples) {
     if (!fUsingCenteredSamples && numSamples > 1) {
-        gr_cp<ID3D12GraphicsCommandList1> commandList1;
+        ComPtr<ID3D12GraphicsCommandList1> commandList1;
         GR_D3D_CALL_ERRCHECK(fCommandList->QueryInterface(IID_PPV_ARGS(&commandList1)));
         static D3D12_SAMPLE_POSITION kCenteredSampleLocations[16] = {};
         commandList1->SetSamplePositions(numSamples, 1, kCenteredSampleLocations);
@@ -291,7 +291,7 @@ void GrD3DDirectCommandList::setCenteredSamplePositions(unsigned int numSamples)
 
 void GrD3DDirectCommandList::setDefaultSamplePositions() {
     if (fUsingCenteredSamples) {
-        gr_cp<ID3D12GraphicsCommandList1> commandList1;
+        ComPtr<ID3D12GraphicsCommandList1> commandList1;
         GR_D3D_CALL_ERRCHECK(fCommandList->QueryInterface(IID_PPV_ARGS(&commandList1)));
         commandList1->SetSamplePositions(0, 0, nullptr);
         fUsingCenteredSamples = false;
@@ -442,7 +442,7 @@ void GrD3DDirectCommandList::resolveSubresourceRegion(const GrD3DTextureResource
     this->addResource(dstTexture->resource());
     this->addResource(srcTexture->resource());
 
-    gr_cp<ID3D12GraphicsCommandList1> commandList1;
+    ComPtr<ID3D12GraphicsCommandList1> commandList1;
     HRESULT result = fCommandList->QueryInterface(IID_PPV_ARGS(&commandList1));
     if (SUCCEEDED(result)) {
         commandList1->ResolveSubresourceRegion(dstTexture->d3dResource(), 0, dstX, dstY,
@@ -503,18 +503,18 @@ void GrD3DDirectCommandList::addSampledTextureRef(GrD3DTexture* texture) {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 std::unique_ptr<GrD3DCopyCommandList> GrD3DCopyCommandList::Make(ID3D12Device* device) {
-    gr_cp<ID3D12CommandAllocator> allocator;
+    ComPtr<ID3D12CommandAllocator> allocator;
     GR_D3D_CALL_ERRCHECK(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
                                                         IID_PPV_ARGS(&allocator)));
 
-    gr_cp<ID3D12GraphicsCommandList> commandList;
-    GR_D3D_CALL_ERRCHECK(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, allocator.get(),
+    ComPtr<ID3D12GraphicsCommandList> commandList;
+    GR_D3D_CALL_ERRCHECK(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, allocator.Get(),
                                                    nullptr, IID_PPV_ARGS(&commandList)));
     auto grCL = new GrD3DCopyCommandList(std::move(allocator), std::move(commandList));
     return std::unique_ptr<GrD3DCopyCommandList>(grCL);
 }
 
-GrD3DCopyCommandList::GrD3DCopyCommandList(gr_cp<ID3D12CommandAllocator> allocator,
-                                           gr_cp<ID3D12GraphicsCommandList> commandList)
+GrD3DCopyCommandList::GrD3DCopyCommandList(ComPtr<ID3D12CommandAllocator> allocator,
+                                           ComPtr<ID3D12GraphicsCommandList> commandList)
     : GrD3DCommandList(std::move(allocator), std::move(commandList)) {
 }