vr: Replace uses of ComPtr::GetAddressOf() with ComPtr::operator&

Microsoft::WRL::ComPtr<T>::GetAddressOf() is banned due to the ease
of causing memory leaks.

Also replace CopyTo(foo.GetAddressOf()) with As(&foo) since CopyTo(&foo)
does not work if we are copying to different interfaces.

ComPtr::ReleaseAndGetAddressOf() is safe but ComPtr::operator& is still
preferred.

Bug: 914910
Change-Id: Ifc70f64a9d584883b2162fafce6ef12d18647dbe
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2289440
Commit-Queue: Xiaohan Wang <xhwang@chromium.org>
Commit-Queue: Robert Liao <robliao@chromium.org>
Auto-Submit: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Robert Liao <robliao@chromium.org>
Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#786893}

device/vr/windows/d3d11_texture_helper.cc

@@ -138,8 +138,7 @@ bool D3D11TextureHelper::EnsureOverlayBlendState() {
     blenddesc.RenderTarget[0].RenderTargetWriteMask =
         D3D11_COLOR_WRITE_ENABLE_ALL;
     HRESULT hr = render_state_.d3d11_device_->CreateBlendState(
-        &blenddesc,
-        render_state_.overlay_blend_state_.ReleaseAndGetAddressOf());
+        &blenddesc, &(render_state_.overlay_blend_state_));
     if (FAILED(hr)) {
       TraceDXError(ErrorLocation::OverlayBlendState, hr);
       return false;
@@ -162,8 +161,7 @@ bool D3D11TextureHelper::EnsureContentBlendState() {
     blenddesc.RenderTarget[0].RenderTargetWriteMask =
         D3D11_COLOR_WRITE_ENABLE_ALL;
     HRESULT hr = render_state_.d3d11_device_->CreateBlendState(
-        &blenddesc,
-        render_state_.content_blend_state_.ReleaseAndGetAddressOf());
+        &blenddesc, &(render_state_.content_blend_state_));
     if (FAILED(hr)) {
       TraceDXError(ErrorLocation::ContentBlendState, hr);
       return false;
@@ -357,8 +355,8 @@ bool D3D11TextureHelper::EnsureSampler(LayerData& layer) {
     CD3D11_DEFAULT default_values;
     CD3D11_SAMPLER_DESC sampler_desc = CD3D11_SAMPLER_DESC(default_values);
     D3D11_SAMPLER_DESC sd = sampler_desc;
-    HRESULT hr = render_state_.d3d11_device_->CreateSamplerState(
-        &sd, layer.sampler_.GetAddressOf());
+    HRESULT hr =
+        render_state_.d3d11_device_->CreateSamplerState(&sd, &(layer.sampler_));
     if (FAILED(hr)) {
       TraceDXError(ErrorLocation::Sampler, hr);
       return false;
@@ -371,8 +369,10 @@ bool D3D11TextureHelper::BindTarget() {
   if (!EnsureRenderTargetView())
     return false;
 
+  ID3D11RenderTargetView* render_target_views[] = {
+      render_state_.render_target_view_.Get()};
   render_state_.d3d11_device_context_->OMSetRenderTargets(
-      1, render_state_.render_target_view_.GetAddressOf(), nullptr);
+      ARRAYSIZE(render_target_views), render_target_views, nullptr);
   return true;
 }
 
@@ -444,10 +444,12 @@ bool D3D11TextureHelper::CompositeLayer(LayerData& layer) {
 
   UINT stride = kSizeOfVertex;
   UINT offset = 0;
+  ID3D11Buffer* vertex_buffers[] = {render_state_.vertex_buffer_.Get()};
+  ID3D11SamplerState* samplers[] = {layer.sampler_.Get()};
   render_state_.d3d11_device_context_->IASetVertexBuffers(
-      0, 1, render_state_.vertex_buffer_.GetAddressOf(), &stride, &offset);
-  render_state_.d3d11_device_context_->PSSetSamplers(
-      0, 1, layer.sampler_.GetAddressOf());
+      0, ARRAYSIZE(vertex_buffers), vertex_buffers, &stride, &offset);
+  render_state_.d3d11_device_context_->PSSetSamplers(0, ARRAYSIZE(samplers),
+                                                     samplers);
 
   D3D11_SHADER_RESOURCE_VIEW_DESC shader_resource_view_desc;
   shader_resource_view_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
@@ -456,13 +458,15 @@ bool D3D11TextureHelper::CompositeLayer(LayerData& layer) {
   shader_resource_view_desc.Texture2D.MipLevels = 1;
   HRESULT hr = render_state_.d3d11_device_->CreateShaderResourceView(
       layer.source_texture_.Get(), &shader_resource_view_desc,
-      layer.shader_resource_.ReleaseAndGetAddressOf());
+      &layer.shader_resource_);
   if (FAILED(hr)) {
     TraceDXError(ErrorLocation::ShaderResource, hr);
     return false;
   }
+
+  ID3D11ShaderResourceView* shader_resources[] = {layer.shader_resource_.Get()};
   render_state_.d3d11_device_context_->PSSetShaderResources(
-      0, 1, layer.shader_resource_.GetAddressOf());
+      0, ARRAYSIZE(shader_resources), shader_resources);
 
   D3D11_TEXTURE2D_DESC desc;
   render_state_.target_texture_->GetDesc(&desc);
@@ -493,14 +497,13 @@ bool D3D11TextureHelper::SetSourceTexture(
     return false;
   HRESULT hr = render_state_.d3d11_device_->OpenSharedResource1(
       texture_handle.Get(),
-      IID_PPV_ARGS(
-          render_state_.source_.keyed_mutex_.ReleaseAndGetAddressOf()));
+      IID_PPV_ARGS(&(render_state_.source_.keyed_mutex_)));
   if (FAILED(hr)) {
     TraceDXError(ErrorLocation::OpenSource, hr);
     return false;
   }
-  hr = render_state_.source_.keyed_mutex_.CopyTo(
-      render_state_.source_.source_texture_.ReleaseAndGetAddressOf());
+  hr = render_state_.source_.keyed_mutex_.As(
+      &(render_state_.source_.source_texture_));
   if (FAILED(hr)) {
     render_state_.source_.keyed_mutex_ = nullptr;
     return false;
@@ -523,14 +526,13 @@ bool D3D11TextureHelper::SetOverlayTexture(
     return false;
   HRESULT hr = render_state_.d3d11_device_->OpenSharedResource1(
       texture_handle.Get(),
-      IID_PPV_ARGS(
-          render_state_.overlay_.keyed_mutex_.ReleaseAndGetAddressOf()));
+      IID_PPV_ARGS(&(render_state_.overlay_.keyed_mutex_)));
   if (FAILED(hr)) {
     TraceDXError(ErrorLocation::OpenOverlay, hr);
     return false;
   }
-  hr = render_state_.overlay_.keyed_mutex_.CopyTo(
-      render_state_.overlay_.source_texture_.ReleaseAndGetAddressOf());
+  hr = render_state_.overlay_.keyed_mutex_.As(
+      &(render_state_.overlay_.source_texture_));
   if (FAILED(hr)) {
     render_state_.overlay_.keyed_mutex_ = nullptr;
     return false;
@@ -615,8 +617,7 @@ void D3D11TextureHelper::AllocateBackBuffer() {
   if (!render_state_.target_texture_) {
     // Ignoring error - target_texture_ will be null on failure.
     render_state_.d3d11_device_->CreateTexture2D(
-        &desc_desired, nullptr,
-        render_state_.target_texture_.ReleaseAndGetAddressOf());
+        &desc_desired, nullptr, &(render_state_.target_texture_));
   }
 }
 
@@ -646,19 +647,18 @@ void D3D11TextureHelper::SetBackbuffer(
 Microsoft::WRL::ComPtr<IDXGIAdapter> D3D11TextureHelper::GetAdapter() {
   Microsoft::WRL::ComPtr<IDXGIFactory1> dxgi_factory;
   Microsoft::WRL::ComPtr<IDXGIAdapter> adapter;
-  HRESULT hr = CreateDXGIFactory1(IID_PPV_ARGS(dxgi_factory.GetAddressOf()));
+  HRESULT hr = CreateDXGIFactory1(IID_PPV_ARGS(&dxgi_factory));
   if (FAILED(hr))
     return nullptr;
   if (adapter_index_ >= 0) {
-    dxgi_factory->EnumAdapters(adapter_index_, adapter.GetAddressOf());
+    dxgi_factory->EnumAdapters(adapter_index_, &adapter);
   } else {
     // We don't have a valid adapter index, lets see if we have a valid LUID.
     Microsoft::WRL::ComPtr<IDXGIFactory4> dxgi_factory4;
     hr = dxgi_factory.As(&dxgi_factory4);
     if (FAILED(hr))
       return nullptr;
-    dxgi_factory4->EnumAdapterByLuid(adapter_luid_,
-                                     IID_PPV_ARGS(adapter.GetAddressOf()));
+    dxgi_factory4->EnumAdapterByLuid(adapter_luid_, IID_PPV_ARGS(&adapter));
   }
   return adapter;
 }
@@ -689,9 +689,8 @@ bool D3D11TextureHelper::EnsureInitialized() {
   Microsoft::WRL::ComPtr<ID3D11Device> d3d11_device;
   HRESULT hr = D3D11CreateDevice(
       adapter.Get(), D3D_DRIVER_TYPE_UNKNOWN, NULL, flags, feature_levels,
-      base::size(feature_levels), D3D11_SDK_VERSION,
-      d3d11_device.GetAddressOf(), &feature_level_out,
-      render_state_.d3d11_device_context_.GetAddressOf());
+      base::size(feature_levels), D3D11_SDK_VERSION, &d3d11_device,
+      &feature_level_out, &(render_state_.d3d11_device_context_));
   if (SUCCEEDED(hr)) {
     hr = d3d11_device.As(&render_state_.d3d11_device_);
     if (FAILED(hr)) {