Split DirectCompositionSurfaceWin into two parts.

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 <deque>
 
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/ipc/service/direct_composition_child_surface_win.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/display/display_switches.h"
 #include "ui/gfx/color_space_win.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/dc_renderer_layer_params.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_image_dxgi.h"
 #include "ui/gl/gl_image_memory.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_make_current.h"
 
 #ifndef EGL_ANGLE_flexible_surface_compatibility
 #define EGL_ANGLE_flexible_surface_compatibility 1
 #define EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE 0x33A6
 #endif /* EGL_ANGLE_flexible_surface_compatibility */
 
-#ifndef EGL_ANGLE_d3d_texture_client_buffer
-#define EGL_ANGLE_d3d_texture_client_buffer 1
-#define EGL_D3D_TEXTURE_ANGLE 0x33A3
-#endif /* EGL_ANGLE_d3d_texture_client_buffer */
-
 namespace gpu {
 namespace {
 
 // Some drivers fail to correctly handle BT.709 video in overlays. This flag
 // converts them to BT.601 in the video processor.
 const base::Feature kFallbackBT709VideoToBT601{
     "FallbackBT709VideoToBT601", base::FEATURE_DISABLED_BY_DEFAULT};
 
 // This class is used to make sure a specified surface isn't current, and upon
 // destruction it will make the surface current again if it had been before.
@@ skipping 110 matching lines @@
       g_overlay_monitor_size =
           gfx::Rect(monitor_desc.DesktopCoordinates).size();
       g_supports_scaled_overlays =
           !!(flags & DXGI_OVERLAY_SUPPORT_FLAG_SCALING);
       return true;
     }
   }
   return false;
 }
 
-// Only one DirectComposition surface can be rendered into at a time. Track
-// here which IDCompositionSurface is being rendered into. If another context
-// is made current, then this surface will be suspended.
-IDCompositionSurface* g_current_surface;
-
 }  // namespace
 
 class DCLayerTree {
  public:
   DCLayerTree(DirectCompositionSurfaceWin* surface,
               const base::win::ScopedComPtr<ID3D11Device>& d3d11_device,
               const base::win::ScopedComPtr<IDCompositionDevice2>& dcomp_device)
       : surface_(surface),
         d3d11_device_(d3d11_device),
         dcomp_device_(dcomp_device) {}
@@ skipping 858 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_);
 
-  return true;
-}
-
-void DirectCompositionSurfaceWin::ReleaseCurrentSurface() {
-  ReleaseDrawTexture(true);
-  dcomp_surface_.Reset();
-  swap_chain_.Reset();
-}
-
-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_.GetAddressOf());
-    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_.CopyTo(dxgi_device.GetAddressOf());
-    base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
-    dxgi_device->GetAdapter(dxgi_adapter.GetAddressOf());
-    base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
-    dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.GetAddressOf()));
-
-    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 = alpha_mode;
-    desc.Flags = 0;
-    HRESULT hr = dxgi_factory->CreateSwapChainForComposition(
-        d3d11_device_.Get(), &desc, nullptr, swap_chain_.GetAddressOf());
-    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_.Reset();
-    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_.CopyTo(dxgi_device2.GetAddressOf());
-        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;
+  return RecreateRootSurface();
 }
 
 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_ && (dcomp_surface_ == g_current_surface)) {
-    HRESULT hr = dcomp_surface_->EndDraw();
-    CHECK(SUCCEEDED(hr));
-    g_current_surface = nullptr;
-  }
-  draw_texture_.Reset();
-  dcomp_surface_.Reset();
+  if (root_surface_)
+    root_surface_->Destroy();
 }
 
 gfx::Size DirectCompositionSurfaceWin::GetSize() {
   return size_;
 }
 
 bool DirectCompositionSurfaceWin::IsOffscreen() {
   return false;
 }
 
 void* DirectCompositionSurfaceWin::GetHandle() {
-  return real_surface_ ? real_surface_ : default_surface_;
+  return root_surface_ ? root_surface_->GetHandle() : default_surface_;
 }
 
 bool DirectCompositionSurfaceWin::Resize(const gfx::Size& size,
                                          float scale_factor,
                                          bool has_alpha) {
   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;
+  return RecreateRootSurface();

[sunnyps, 2017/06/10 00:11:11]

nit: This seems like a change in behavior if multiple Resize calls happen.
Previously, we'd only recreate the root surface on the first draw after the
resize but now it's on every resize. Same with SetEnableDCLayers, though that
would probably be called far less frequently.

 }
 
 gfx::SwapResult DirectCompositionSurfaceWin::SwapBuffers() {
   {
     ScopedReleaseCurrent release_current(this);
-    ReleaseDrawTexture(false);
+    root_surface_->SwapBuffers();
 
     layer_tree_->CommitAndClearPendingOverlays();
   }
   child_window_.ClearInvalidContents();
   return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::SwapResult DirectCompositionSurfaceWin::PostSubBuffer(int x,
                                                            int y,
                                                            int width,
                                                            int height) {
   // The arguments are ignored because SetDrawRectangle specified the area to
   // be swapped.
   return SwapBuffers();
 }
 
 gfx::VSyncProvider* DirectCompositionSurfaceWin::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 bool DirectCompositionSurfaceWin::ScheduleDCLayer(
     const ui::DCRendererLayerParams& params) {
   return layer_tree_->ScheduleDCLayer(params);
 }
 
 bool DirectCompositionSurfaceWin::SetEnableDCLayers(bool enable) {
+  if (enable_dc_layers_ == enable)
+    return true;
+  ScopedReleaseCurrent release_current(this);
   enable_dc_layers_ = enable;
-  return true;
+  return RecreateRootSurface();
 }
 
 
 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();
-    }
-  }
+  if (root_surface_)
+    return root_surface_->OnMakeCurrent(context);
   return true;
 }
 
 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;
-  }
-
-  CHECK(!g_current_surface);
-
-  RECT rect = rectangle.ToRECT();
-  if (dcomp_surface_) {
-    POINT update_offset;
-    HRESULT hr = dcomp_surface_->BeginDraw(
-        &rect, IID_PPV_ARGS(draw_texture_.GetAddressOf()), &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_.GetAddressOf()));
-    swap_rect_ = rectangle;
-    draw_offset_ = gfx::Vector2d();
-    CHECK(SUCCEEDED(hr));
-  }
-  has_been_rendered_to_ = true;
-
-  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};
-
-  EGLClientBuffer buffer =
-      reinterpret_cast<EGLClientBuffer>(draw_texture_.Get());
-  real_surface_ = eglCreatePbufferFromClientBuffer(
-      GetDisplay(), EGL_D3D_TEXTURE_ANGLE, buffer, GetConfig(),
-      &pbuffer_attribs[0]);
-
-  return true;
+  if (root_surface_)
+    return root_surface_->SetDrawRectangle(rectangle);
+  return false;
 }
 
 gfx::Vector2d DirectCompositionSurfaceWin::GetDrawOffset() const {
-  return draw_offset_;
+  if (root_surface_)
+    return root_surface_->GetDrawOffset();
+  return gfx::Vector2d();
 }
 
 void DirectCompositionSurfaceWin::WaitForSnapshotRendering() {
   DCHECK(gl::GLContext::GetCurrent()->IsCurrent(this));
   glFinish();
 }
 
+bool DirectCompositionSurfaceWin::RecreateRootSurface() {
+  root_surface_ = new DirectCompositionChildSurfaceWin(size_, has_alpha_,
+                                                       enable_dc_layers_);
+  return root_surface_->Initialize();
+}
+
+const base::win::ScopedComPtr<IDCompositionSurface>
+DirectCompositionSurfaceWin::dcomp_surface() const {
+  return root_surface_ ? root_surface_->dcomp_surface() : nullptr;
+}
+
+const base::win::ScopedComPtr<IDXGISwapChain1>
+DirectCompositionSurfaceWin::swap_chain() const {
+  return root_surface_ ? root_surface_->swap_chain() : nullptr;
+}
+
 scoped_refptr<base::TaskRunner>
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu