Allow creating opaque swapchains in DirectCompositionSurfaceWin

gpu/ipc/service/direct_composition_surface_win.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/ipc/service/direct_composition_surface_win.h"
 
 #include <d3d11_1.h>
 #include <dcomptypes.h>
 
 #include "base/memory/ptr_util.h"
@@ skipping 704 matching lines @@
 void DirectCompositionSurfaceWin::InitializeSurface() {
   TRACE_EVENT1("gpu", "DirectCompositionSurfaceWin::InitializeSurface()",
                "enable_dc_layers_", enable_dc_layers_);
   DCHECK(!dcomp_surface_);
   DCHECK(!swap_chain_);
   DXGI_FORMAT output_format =
       base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableHDR)
           ? DXGI_FORMAT_R16G16B16A16_FLOAT
           : DXGI_FORMAT_B8G8R8A8_UNORM;
   if (enable_dc_layers_) {
+    // Always treat as premultiplied, because an underlay could cause it to
+    // become transparent.
     HRESULT hr = dcomp_device_->CreateSurface(
         size_.width(), size_.height(), output_format,
         DXGI_ALPHA_MODE_PREMULTIPLIED, dcomp_surface_.Receive());
     has_been_rendered_to_ = false;
     CHECK(SUCCEEDED(hr));
   } else {
+    DXGI_ALPHA_MODE alpha_mode =
+        has_alpha_ ? DXGI_ALPHA_MODE_PREMULTIPLIED : DXGI_ALPHA_MODE_IGNORE;
     base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
     d3d11_device_.QueryInterface(dxgi_device.Receive());
     base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
     dxgi_device->GetAdapter(dxgi_adapter.Receive());
     base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
     dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.Receive()));
 
     DXGI_SWAP_CHAIN_DESC1 desc = {};
     desc.Width = size_.width();
     desc.Height = size_.height();
     desc.Format = output_format;
     desc.Stereo = FALSE;
     desc.SampleDesc.Count = 1;
     desc.BufferCount = 2;
     desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
     desc.Scaling = DXGI_SCALING_STRETCH;
     desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
-    desc.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED;
+    desc.AlphaMode = alpha_mode;
     desc.Flags = 0;
     HRESULT hr = dxgi_factory->CreateSwapChainForComposition(
         d3d11_device_.get(), &desc, nullptr, swap_chain_.Receive());
     has_been_rendered_to_ = false;
     first_swap_ = true;
     CHECK(SUCCEEDED(hr));
   }
 }
 
 void DirectCompositionSurfaceWin::ReleaseDrawTexture(bool will_discard) {
@@ skipping 64 matching lines @@
   return false;
 }
 
 void* DirectCompositionSurfaceWin::GetHandle() {
   return real_surface_ ? real_surface_ : default_surface_;
 }
 
 bool DirectCompositionSurfaceWin::Resize(const gfx::Size& size,
                                          float scale_factor,
                                          bool has_alpha) {
-  if (size == GetSize())
+  if ((size == GetSize()) && (has_alpha == has_alpha_))
     return true;
 
   // Force a resize and redraw (but not a move, activate, etc.).
   if (!SetWindowPos(window_, nullptr, 0, 0, size.width(), size.height(),
                     SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS |
                         SWP_NOOWNERZORDER | SWP_NOZORDER)) {
     return false;
   }
   size_ = size;
+  has_alpha_ = has_alpha;
   ScopedReleaseCurrent release_current(this);
   // New surface will be initialized in SetDrawRectangle.
   ReleaseCurrentSurface();
 
   return true;
 }
 
 gfx::SwapResult DirectCompositionSurfaceWin::SwapBuffers() {
   {
     ScopedReleaseCurrent release_current(this);
@@ skipping 119 matching lines @@
 gfx::Vector2d DirectCompositionSurfaceWin::GetDrawOffset() const {
   return draw_offset_;
 }
 
 scoped_refptr<base::TaskRunner>
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 }  // namespace gpu