Allow switching DirectCompositionSurfaceWin between drawing modes.

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"
 #include "gpu/ipc/service/switches.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_angle_util_win.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_make_current.h"
 
@@ skipping 129 matching lines @@
   pbuffer_attribs.push_back(EGL_WIDTH);
   pbuffer_attribs.push_back(1);
   pbuffer_attribs.push_back(EGL_HEIGHT);
   pbuffer_attribs.push_back(1);
 
   pbuffer_attribs.push_back(EGL_NONE);
   default_surface_ =
       eglCreatePbufferSurface(display, GetConfig(), &pbuffer_attribs[0]);
   CHECK(!!default_surface_);
 
-  InitializeSurface();
-
   return true;
 }
 
-void DirectCompositionSurfaceWin::InitializeSurface() {
-  ScopedReleaseCurrent release_current(this);
-  ReleaseDrawTexture();
+void DirectCompositionSurfaceWin::ReleaseCurrentSurface() {
+  ReleaseDrawTexture(true);
   dcomp_surface_.Release();
-  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));
+  swap_chain_.Release();
 }
 
-void DirectCompositionSurfaceWin::ReleaseDrawTexture() {
+void DirectCompositionSurfaceWin::InitializeSurface() {
+  DCHECK(!dcomp_surface_);
+  DCHECK(!swap_chain_);
+  if (enable_dc_layers_) {
+    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 {
+    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.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) {
   if (real_surface_) {
     eglDestroySurface(GetDisplay(), real_surface_);
     real_surface_ = nullptr;
   }
   if (draw_texture_) {
     draw_texture_.Release();
-    HRESULT hr = dcomp_surface_->EndDraw();
-    CHECK(SUCCEEDED(hr));
+    if (dcomp_surface_) {
+      HRESULT hr = dcomp_surface_->EndDraw();
+      CHECK(SUCCEEDED(hr));
+    } else if (!will_discard) {
+      DXGI_PRESENT_PARAMETERS params = {};
+      RECT dirty_rect = swap_rect_.ToRECT();
+      params.DirtyRectsCount = 1;
+      params.pDirtyRects = &dirty_rect;
+      swap_chain_->Present1(first_swap_ ? 0 : 1, 0, &params);
+      if (first_swap_) {
+        // Wait for the GPU to finish executing its commands before
+        // committing the DirectComposition tree, or else the swapchain
+        // may flicker black when it's first presented.
+        base::win::ScopedComPtr<IDXGIDevice2> dxgi_device2;
+        HRESULT hr = d3d11_device_.QueryInterface(dxgi_device2.Receive());
+        DCHECK(SUCCEEDED(hr));
+        base::WaitableEvent event(
+            base::WaitableEvent::ResetPolicy::AUTOMATIC,
+            base::WaitableEvent::InitialState::NOT_SIGNALED);
+        dxgi_device2->EnqueueSetEvent(event.handle());
+        event.Wait();
+        first_swap_ = false;
+      }
+    }
   }
   if (dcomp_surface_ == g_current_surface)
     g_current_surface = nullptr;
 }
 
 void DirectCompositionSurfaceWin::Destroy() {
   if (default_surface_) {
     if (!eglDestroySurface(GetDisplay(), default_surface_)) {
       DLOG(ERROR) << "eglDestroySurface failed with error "
                   << ui::GetLastEGLErrorString();
     }
     default_surface_ = nullptr;
   }
   if (real_surface_) {
     if (!eglDestroySurface(GetDisplay(), real_surface_)) {
       DLOG(ERROR) << "eglDestroySurface failed with error "
                   << ui::GetLastEGLErrorString();
     }
     real_surface_ = nullptr;
   }
-  if (dcomp_surface_ == g_current_surface)
+  if (dcomp_surface_ && (dcomp_surface_ == g_current_surface)) {
+    HRESULT hr = dcomp_surface_->EndDraw();
+    CHECK(SUCCEEDED(hr));
     g_current_surface = nullptr;
+  }
   draw_texture_.Release();
   dcomp_surface_.Release();
 }
 
 gfx::Size DirectCompositionSurfaceWin::GetSize() {
   return size_;
 }
 
 bool DirectCompositionSurfaceWin::IsOffscreen() {
   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())
     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;
-  InitializeSurface();
+  ScopedReleaseCurrent release_current(this);
+  // New surface will be initialized in SetDrawRectangle.
+  ReleaseCurrentSurface();
 
   return true;
 }
 
 gfx::SwapResult DirectCompositionSurfaceWin::SwapBuffers() {
   {
     ScopedReleaseCurrent release_current(this);
-    ReleaseDrawTexture();
-    visual_->SetContent(dcomp_surface_.get());
+    ReleaseDrawTexture(false);
+    DCHECK(dcomp_surface_ || swap_chain_);
+    if (dcomp_surface_)
+      visual_->SetContent(dcomp_surface_.get());
+    else
+      visual_->SetContent(swap_chain_.get());
 
     CommitAndClearPendingOverlays();
     dcomp_device_->Commit();
   }
-  // Force the driver to finish drawing before clearing the contents to
-  // transparent, to reduce or eliminate the period of time where the contents
-  // have flashed black.
-  if (first_swap_) {
-    glFinish();
-    first_swap_ = false;
-  }
   child_window_.ClearInvalidContents();
   return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::SwapResult DirectCompositionSurfaceWin::PostSubBuffer(int x,
                                                            int y,
                                                            int width,
                                                            int height) {
-  ScopedReleaseCurrent release_current(this);
-  ReleaseDrawTexture();
-  visual_->SetContent(dcomp_surface_.get());
-  CommitAndClearPendingOverlays();
-  dcomp_device_->Commit();
-  child_window_.ClearInvalidContents();
-  return gfx::SwapResult::SWAP_ACK;
+  // The arguments are ignored because SetDrawRectangle specified the area to
+  // be swapped.
+  return SwapBuffers();
 }
 
 gfx::VSyncProvider* DirectCompositionSurfaceWin::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 bool DirectCompositionSurfaceWin::ScheduleOverlayPlane(
     int z_order,
     gfx::OverlayTransform transform,
     gl::GLImage* image,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
   pending_overlays_.push_back(
       Overlay(z_order, transform, image, bounds_rect, crop_rect));
   return true;
 }
 
+bool DirectCompositionSurfaceWin::SetEnableDCLayers(bool enable) {
+  enable_dc_layers_ = enable;
+  return true;
+}
+
 bool DirectCompositionSurfaceWin::CommitAndClearPendingOverlays() {
   pending_overlays_.clear();
   return true;
 }
 
 bool DirectCompositionSurfaceWin::FlipsVertically() const {
   return true;
 }
 
 bool DirectCompositionSurfaceWin::SupportsPostSubBuffer() {
   return true;
 }
 
 bool DirectCompositionSurfaceWin::OnMakeCurrent(gl::GLContext* context) {
   if (g_current_surface != dcomp_surface_) {
     if (g_current_surface) {
       HRESULT hr = g_current_surface->SuspendDraw();
       CHECK(SUCCEEDED(hr));
       g_current_surface = nullptr;
     }
     if (draw_texture_) {
       HRESULT hr = dcomp_surface_->ResumeDraw();
       CHECK(SUCCEEDED(hr));
       g_current_surface = dcomp_surface_.get();
     }
   }
   return true;
 }
 
-bool DirectCompositionSurfaceWin::SupportsSetDrawRectangle() const {
+bool DirectCompositionSurfaceWin::SupportsDCLayers() const {
   return true;
 }
 
 bool DirectCompositionSurfaceWin::SetDrawRectangle(const gfx::Rect& rectangle) {
   if (draw_texture_)
     return false;
+
+  DCHECK(!real_surface_);
+  ScopedReleaseCurrent release_current(this);
+
+  if ((enable_dc_layers_ && !dcomp_surface_) ||
+      (!enable_dc_layers_ && !swap_chain_)) {
+    ReleaseCurrentSurface();
+    InitializeSurface();
+  }
+
   if (!gfx::Rect(size_).Contains(rectangle)) {
     DLOG(ERROR) << "Draw rectangle must be contained within size of surface";
     return false;
   }
   if (gfx::Rect(size_) != rectangle && !has_been_rendered_to_) {
     DLOG(ERROR) << "First draw to surface must draw to everything";
     return false;
   }
 
-  DCHECK(!real_surface_);
   CHECK(!g_current_surface);
-  ScopedReleaseCurrent release_current(this);
 
   RECT rect = rectangle.ToRECT();
-  POINT update_offset;
-
-  HRESULT hr = dcomp_surface_->BeginDraw(
-      &rect, IID_PPV_ARGS(draw_texture_.Receive()), &update_offset);
-  CHECK(SUCCEEDED(hr));
+  if (dcomp_surface_) {
+    POINT update_offset;
+    HRESULT hr = dcomp_surface_->BeginDraw(
+        &rect, IID_PPV_ARGS(draw_texture_.Receive()), &update_offset);
+    draw_offset_ = gfx::Point(update_offset) - gfx::Rect(rect).origin();
+    CHECK(SUCCEEDED(hr));
+  } else {
+    HRESULT hr =
+        swap_chain_->GetBuffer(0, IID_PPV_ARGS(draw_texture_.Receive()));
+    swap_rect_ = rectangle;
+    draw_offset_ = gfx::Vector2d();
+    CHECK(SUCCEEDED(hr));
+  }
   has_been_rendered_to_ = true;
 
-  draw_offset_ = gfx::Point(update_offset) - gfx::Rect(rect).origin();
-
   g_current_surface = dcomp_surface_.get();
 
   std::vector<EGLint> pbuffer_attribs{
       EGL_WIDTH,
       size_.width(),
       EGL_HEIGHT,
       size_.height(),
       EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE,
       EGL_TRUE,
       EGL_NONE};
@@ skipping 25 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