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 "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
@@ skipping 150 matching lines @@
 void DirectCompositionSurfaceWin::ReleaseCurrentSurface() {
   ReleaseDrawTexture(true);
   dcomp_surface_.Release();
   swap_chain_.Release();
 }
 
 void DirectCompositionSurfaceWin::InitializeSurface() {
   DCHECK(!dcomp_surface_);
   DCHECK(!swap_chain_);
   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(), DXGI_FORMAT_B8G8R8A8_UNORM,
         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 = DXGI_FORMAT_B8G8R8A8_UNORM;
     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_)

[sunnyps, 2017/03/28 22:33:37]

Shouldn't this be " && 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 151 matching lines @@
       transform(transform),
       image(image),
       bounds_rect(bounds_rect),
       crop_rect(crop_rect) {}
 
 DirectCompositionSurfaceWin::Overlay::Overlay(const Overlay& overlay) = default;
 
 DirectCompositionSurfaceWin::Overlay::~Overlay() {}
 
 }  // namespace gpu