Add SkiaOutputDeviceGL

This CL moves some platform specific logic out of
SkiaOutputSurfaceImplOnGpu and into SkiaOutputDeviceGL. I also added the
hooks to support partial swaps and tested on an i7 gLinux laptop.

Bug: 920344
Change-Id: I77b86442fef2340094de9fa93057f1fa2af2f50b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1539792
Commit-Queue: Jonathan Backer <backer@chromium.org>
Reviewed-by: Peng Huang <penghuang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#645059}

components/viz/service/BUILD.gn

@@ -311,6 +311,8 @@ viz_source_set("gpu_service_dependencies") {
   sources = [
     "display_embedder/skia_output_device.cc",
     "display_embedder/skia_output_device.h",
+    "display_embedder/skia_output_device_gl.cc",
+    "display_embedder/skia_output_device_gl.h",
     "display_embedder/skia_output_device_offscreen.cc",
     "display_embedder/skia_output_device_offscreen.h",
     "display_embedder/skia_output_surface_impl.cc",

components/viz/service/display_embedder/skia_output_device.cc

@@ -4,9 +4,16 @@
 
 #include "components/viz/service/display_embedder/skia_output_device.h"
 
+#include <utility>
+
+#include "third_party/skia/include/core/SkSurface.h"
+#include "ui/gfx/presentation_feedback.h"
+
 namespace viz {
 
-SkiaOutputDevice::SkiaOutputDevice() = default;
+SkiaOutputDevice::SkiaOutputDevice(
+    DidSwapBufferCompleteCallback did_swap_buffer_complete_callback)
+    : did_swap_buffer_complete_callback_(did_swap_buffer_complete_callback) {}
 
 SkiaOutputDevice::~SkiaOutputDevice() = default;
 
@@ -14,9 +21,45 @@ bool SkiaOutputDevice::SupportPostSubBuffer() {
   return false;
 }
 
-gfx::SwapResult SkiaOutputDevice::PostSubBuffer(const gfx::Rect& rect) {
+gfx::SwapResponse SkiaOutputDevice::PostSubBuffer(
+    const gfx::Rect& rect,
+    BufferPresentedCallback feedback) {
   NOTREACHED();
-  return gfx::SwapResult::SWAP_FAILED;
+  StartSwapBuffers(std::move(feedback));
+  return FinishSwapBuffers(gfx::SwapResult::SWAP_FAILED);
+}
+
+void SkiaOutputDevice::StartSwapBuffers(
+    base::Optional<BufferPresentedCallback> feedback) {
+  DCHECK(!feedback_);
+  DCHECK(!params_);
+
+  feedback_ = std::move(feedback);
+  params_.emplace();
+  params_->swap_response.swap_id = ++swap_id_;
+  params_->swap_response.swap_start = base::TimeTicks::Now();
+}
+
+gfx::SwapResponse SkiaOutputDevice::FinishSwapBuffers(gfx::SwapResult result) {
+  DCHECK(params_);
+
+  params_->swap_response.result = result;
+  params_->swap_response.swap_end = base::TimeTicks::Now();
+  if (feedback_) {
+    std::move(*feedback_)
+        .Run(gfx::PresentationFeedback(
+            params_->swap_response.swap_start, base::TimeDelta() /* interval */,
+            params_->swap_response.result == gfx::SwapResult::SWAP_ACK
+                ? 0
+                : gfx::PresentationFeedback::Flags::kFailure));
+  }
+  did_swap_buffer_complete_callback_.Run(
+      *params_, gfx::Size(draw_surface_->width(), draw_surface_->height()));
+
+  feedback_.reset();
+  auto response = params_->swap_response;
+  params_.reset();
+  return response;
 }
 
 }  // namespace viz

components/viz/service/display_embedder/skia_output_device.h

@@ -5,35 +5,66 @@
 #ifndef COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_H_
 #define COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_H_
 
+#include "base/callback.h"
 #include "base/macros.h"
+#include "base/optional.h"
+#include "gpu/command_buffer/common/swap_buffers_complete_params.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
-#include "ui/gfx/geometry/rect.h"
-#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/swap_result.h"
 
 class SkSurface;
 
+namespace gfx {
+class ColorSpace;
+class Rect;
+class Size;
+struct PresentationFeedback;
+}  // namespace gfx
+
 namespace viz {
 
 class SkiaOutputDevice {
  public:
-  SkiaOutputDevice();
+  using BufferPresentedCallback =
+      base::OnceCallback<void(const gfx::PresentationFeedback& feedback)>;
+  using DidSwapBufferCompleteCallback =
+      base::RepeatingCallback<void(gpu::SwapBuffersCompleteParams,
+                                   const gfx::Size& pixel_size)>;
+  explicit SkiaOutputDevice(
+      DidSwapBufferCompleteCallback did_swap_buffer_complete_callback);
   virtual ~SkiaOutputDevice();
 
   // SkSurface that can be drawn to.
-  virtual sk_sp<SkSurface> DrawSurface() = 0;
+  sk_sp<SkSurface> DrawSurface() { return draw_surface_; }
 
   // Changes the size of draw surface and invalidates it's contents.
-  virtual void Reshape(const gfx::Size& size) = 0;
+  virtual void Reshape(const gfx::Size& size,
+                       float device_scale_factor,
+                       const gfx::ColorSpace& color_space,
+                       bool has_alpha) = 0;
 
   // Presents DrawSurface.
-  virtual gfx::SwapResult SwapBuffers() = 0;
+  virtual gfx::SwapResponse SwapBuffers(BufferPresentedCallback feedback) = 0;
 
   virtual bool SupportPostSubBuffer();
 
-  virtual gfx::SwapResult PostSubBuffer(const gfx::Rect& rect);
+  virtual gfx::SwapResponse PostSubBuffer(const gfx::Rect& rect,
+                                          BufferPresentedCallback feedback);
+
+ protected:
+  void StartSwapBuffers(base::Optional<BufferPresentedCallback> feedback);
+  gfx::SwapResponse FinishSwapBuffers(gfx::SwapResult result);
+
+  sk_sp<SkSurface> draw_surface_;
 
  private:
+  uint64_t swap_id_ = 0;
+  DidSwapBufferCompleteCallback did_swap_buffer_complete_callback_;
+
+  // Only valid between StartSwapBuffers and FinishSwapBuffers.
+  base::Optional<BufferPresentedCallback> feedback_;
+  base::Optional<gpu::SwapBuffersCompleteParams> params_;
+
   DISALLOW_COPY_AND_ASSIGN(SkiaOutputDevice);
 };
 

components/viz/service/display_embedder/skia_output_device_gl.cc

+// Copyright 2019 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 "components/viz/service/display_embedder/skia_output_device_gl.h"
+
+#include <utility>
+
+#include "gpu/command_buffer/common/swap_buffers_complete_params.h"
+#include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/ipc/service/image_transport_surface.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/core/SkSurfaceProps.h"
+#include "third_party/skia/include/gpu/GrBackendSurface.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLTypes.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_surface.h"
+#include "ui/gl/gl_version_info.h"
+
+namespace viz {
+
+SkiaOutputDeviceGL::SkiaOutputDeviceGL(
+    gpu::SurfaceHandle surface_handle,
+    scoped_refptr<gpu::gles2::FeatureInfo> feature_info,
+    const DidSwapBufferCompleteCallback& did_swap_buffer_complete_callback)
+    : SkiaOutputDevice(did_swap_buffer_complete_callback),
+      surface_handle_(surface_handle),
+      feature_info_(feature_info) {
+  DCHECK(surface_handle_);
+  gl_surface_ = gpu::ImageTransportSurface::CreateNativeSurface(
+      nullptr, surface_handle_, gl::GLSurfaceFormat());
+}
+
+void SkiaOutputDeviceGL::Initialize(GrContext* gr_context,
+                                    gl::GLContext* gl_context) {
+  DCHECK(gr_context);
+  DCHECK(gl_context);
+  gr_context_ = gr_context;
+
+  gl::CurrentGL* current_gl = gl_context->GetCurrentGL();
+  DCHECK(current_gl);
+
+  // Get alpha and stencil bits from the default frame buffer.
+  glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+  gr_context_->resetContext(kRenderTarget_GrGLBackendState);
+  const auto* version = current_gl->Version;
+  GLint stencil_bits = 0;
+  GLint alpha_bits = 0;
+  if (version->is_desktop_core_profile) {
+    glGetFramebufferAttachmentParameterivEXT(
+        GL_FRAMEBUFFER, GL_STENCIL, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
+        &stencil_bits);
+    glGetFramebufferAttachmentParameterivEXT(
+        GL_FRAMEBUFFER, GL_BACK_LEFT, GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
+        &alpha_bits);
+  } else {
+    glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
+    glGetIntegerv(GL_ALPHA_BITS, &alpha_bits);
+  }
+  CHECK_GL_ERROR();
+  supports_stencil_ = stencil_bits > 0;
+  supports_alpha_ = alpha_bits > 0;
+
+  supports_post_sub_buffer_ = gl_surface_->SupportsPostSubBuffer();
+  if (feature_info_->workarounds()
+          .disable_post_sub_buffers_for_onscreen_surfaces)
+    supports_post_sub_buffer_ = false;
+}
+
+SkiaOutputDeviceGL::~SkiaOutputDeviceGL() {}
+
+scoped_refptr<gl::GLSurface> SkiaOutputDeviceGL::gl_surface() {
+  return gl_surface_;
+}
+
+void SkiaOutputDeviceGL::Reshape(const gfx::Size& size,
+                                 float device_scale_factor,
+                                 const gfx::ColorSpace& color_space,
+                                 bool has_alpha) {
+  // Conversion to GLSurface's color space follows the same logic as in
+  // gl::GetGLColorSpace().
+  gl::GLSurface::ColorSpace surface_color_space =
+      color_space.IsHDR() ? gl::GLSurface::ColorSpace::SCRGB_LINEAR
+                          : gl::GLSurface::ColorSpace::UNSPECIFIED;
+  if (!gl_surface_->Resize(size, device_scale_factor, surface_color_space,
+                           has_alpha)) {
+    LOG(FATAL) << "Failed to resize.";
+    // TODO(penghuang): Handle the failure.
+  }
+  SkSurfaceProps surface_props =
+      SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType);
+
+  GrGLFramebufferInfo framebuffer_info;
+  framebuffer_info.fFBOID = gl_surface_->GetBackingFramebufferObject();
+  framebuffer_info.fFormat = supports_alpha_ ? GL_RGBA8 : GL_RGB8_OES;
+  GrBackendRenderTarget render_target(size.width(), size.height(), 0, 8,
+                                      framebuffer_info);
+  auto origin = gl_surface_->FlipsVertically() ? kTopLeft_GrSurfaceOrigin
+                                               : kBottomLeft_GrSurfaceOrigin;
+  auto color_type =
+      supports_alpha_ ? kRGBA_8888_SkColorType : kRGB_888x_SkColorType;
+  draw_surface_ = SkSurface::MakeFromBackendRenderTarget(
+      gr_context_, render_target, origin, color_type,
+      color_space.ToSkColorSpace(), &surface_props);
+  DCHECK(draw_surface_);
+}
+
+gfx::SwapResponse SkiaOutputDeviceGL::SwapBuffers(
+    BufferPresentedCallback feedback) {
+  // TODO(backer): Support SwapBuffersAsync
+  StartSwapBuffers({});
+  return FinishSwapBuffers(gl_surface_->SwapBuffers(std::move(feedback)));
+}
+
+bool SkiaOutputDeviceGL::SupportPostSubBuffer() {
+  return supports_post_sub_buffer_;
+}
+
+gfx::SwapResponse SkiaOutputDeviceGL::PostSubBuffer(
+    const gfx::Rect& rect,
+    BufferPresentedCallback feedback) {
+  // TODO(backer): Support PostSubBufferAsync
+  StartSwapBuffers({});
+  return FinishSwapBuffers(gl_surface_->PostSubBuffer(
+      rect.x(), rect.y(), rect.width(), rect.height(), std::move(feedback)));
+}
+
+}  // namespace viz

components/viz/service/display_embedder/skia_output_device_gl.h

+// Copyright 2019 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.
+
+#ifndef COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_GL_H_
+#define COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_GL_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "components/viz/service/display_embedder/skia_output_device.h"
+#include "gpu/config/gpu_preferences.h"
+#include "gpu/ipc/common/surface_handle.h"
+
+class GrContext;
+
+namespace gl {
+class GLContext;
+class GLSurface;
+}  // namespace gl
+
+namespace gpu {
+namespace gles2 {
+class FeatureInfo;
+}  // namespace gles2
+}  // namespace gpu
+
+namespace viz {
+
+class SkiaOutputDeviceGL final : public SkiaOutputDevice {
+ public:
+  SkiaOutputDeviceGL(
+      gpu::SurfaceHandle surface_handle,
+      scoped_refptr<gpu::gles2::FeatureInfo> feature_info,
+      const DidSwapBufferCompleteCallback& did_swap_buffer_complete_callback);
+  ~SkiaOutputDeviceGL() override;
+
+  scoped_refptr<gl::GLSurface> gl_surface();
+  void Initialize(GrContext* gr_context, gl::GLContext* gl_context);
+  bool supports_alpha() {
+    DCHECK(gr_context_);
+    return supports_alpha_;
+  }
+  bool supports_stencil() {
+    DCHECK(gr_context_);
+    return supports_stencil_;
+  }
+
+  // SkiaOutputDevice implementation:
+  void Reshape(const gfx::Size& size,
+               float device_scale_factor,
+               const gfx::ColorSpace& color_space,
+               bool has_alpha) override;
+  gfx::SwapResponse SwapBuffers(BufferPresentedCallback feedback) override;
+  bool SupportPostSubBuffer() override;
+  gfx::SwapResponse PostSubBuffer(const gfx::Rect& rect,
+                                  BufferPresentedCallback feedback) override;
+
+ private:
+  const gpu::SurfaceHandle surface_handle_;
+  scoped_refptr<gpu::gles2::FeatureInfo> feature_info_;
+  gpu::GpuPreferences gpu_preferences_;
+
+  GrContext* gr_context_ = nullptr;
+  scoped_refptr<gl::GLSurface> gl_surface_;
+  sk_sp<SkSurface> sk_surface_;
+
+  bool supports_alpha_ = false;
+  bool supports_stencil_ = false;
+  bool supports_post_sub_buffer_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(SkiaOutputDeviceGL);
+};
+
+}  // namespace viz
+
+#endif  // COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_DEVICE_GL_H_

components/viz/service/display_embedder/skia_output_device_offscreen.cc

@@ -4,22 +4,28 @@
 
 #include "components/viz/service/display_embedder/skia_output_device_offscreen.h"
 
+#include <utility>
+
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace viz {
 
-SkiaOutputDeviceOffscreen::SkiaOutputDeviceOffscreen(GrContext* gr_context,
-                                                     bool flipped,
-                                                     bool has_alpha)
-    : gr_context_(gr_context), flipped_(flipped), has_alpha_(has_alpha) {}
+SkiaOutputDeviceOffscreen::SkiaOutputDeviceOffscreen(
+    GrContext* gr_context,
+    bool flipped,
+    bool has_alpha,
+    DidSwapBufferCompleteCallback did_swap_buffer_complete_callback)
+    : SkiaOutputDevice(did_swap_buffer_complete_callback),
+      gr_context_(gr_context),
+      flipped_(flipped),
+      has_alpha_(has_alpha) {}
 
 SkiaOutputDeviceOffscreen::~SkiaOutputDeviceOffscreen() = default;
 
-sk_sp<SkSurface> SkiaOutputDeviceOffscreen::DrawSurface() {
-  return draw_surface_;
-}
-
-void SkiaOutputDeviceOffscreen::Reshape(const gfx::Size& size) {
+void SkiaOutputDeviceOffscreen::Reshape(const gfx::Size& size,
+                                        float device_scale_factor,
+                                        const gfx::ColorSpace& color_space,
+                                        bool has_alpha) {
   auto image_info = SkImageInfo::Make(
       size.width(), size.height(),
       has_alpha_ ? kRGBA_8888_SkColorType : kRGB_888x_SkColorType,
@@ -30,10 +36,13 @@ void SkiaOutputDeviceOffscreen::Reshape(const gfx::Size& size) {
       nullptr /* surfaceProps */);
 }
 
-gfx::SwapResult SkiaOutputDeviceOffscreen::SwapBuffers() {
+gfx::SwapResponse SkiaOutputDeviceOffscreen::SwapBuffers(
+    BufferPresentedCallback feedback) {
   // Reshape should have been called first.
   DCHECK(draw_surface_);
-  return gfx::SwapResult::SWAP_ACK;
+
+  StartSwapBuffers(std::move(feedback));
+  return FinishSwapBuffers(gfx::SwapResult::SWAP_ACK);
 }
 
 }  // namespace viz

components/viz/service/display_embedder/skia_output_device_offscreen.h

@@ -14,18 +14,22 @@ namespace viz {
 
 class SkiaOutputDeviceOffscreen : public SkiaOutputDevice {
  public:
-  SkiaOutputDeviceOffscreen(GrContext* gr_context,
-                            bool flipped,
-                            bool has_alpha);
+  SkiaOutputDeviceOffscreen(
+      GrContext* gr_context,
+      bool flipped,
+      bool has_alpha,
+      DidSwapBufferCompleteCallback did_swap_buffer_complete_callback);
   ~SkiaOutputDeviceOffscreen() override;
 
-  sk_sp<SkSurface> DrawSurface() override;
-  void Reshape(const gfx::Size& size) override;
-  gfx::SwapResult SwapBuffers() override;
+  // SkiaOutputDevice implementation:
+  void Reshape(const gfx::Size& size,
+               float device_scale_factor,
+               const gfx::ColorSpace& color_space,
+               bool has_alpha) override;
+  gfx::SwapResponse SwapBuffers(BufferPresentedCallback feedback) override;
 
  protected:
   GrContext* const gr_context_;
-  sk_sp<SkSurface> draw_surface_;
   const bool flipped_;
   const bool has_alpha_;
 

components/viz/service/display_embedder/skia_output_device_vulkan.cc

@@ -4,6 +4,8 @@
 
 #include "components/viz/service/display_embedder/skia_output_device_vulkan.h"
 
+#include <utility>
+
 #include "build/build_config.h"
 #include "components/viz/common/gpu/vulkan_context_provider.h"
 #include "gpu/ipc/common/gpu_surface_lookup.h"
@@ -17,19 +19,21 @@ namespace viz {
 
 SkiaOutputDeviceVulkan::SkiaOutputDeviceVulkan(
     VulkanContextProvider* context_provider,
-    gpu::SurfaceHandle surface_handle)
-    : context_provider_(context_provider), surface_handle_(surface_handle) {}
+    gpu::SurfaceHandle surface_handle,
+    DidSwapBufferCompleteCallback did_swap_buffer_complete_callback)
+    : SkiaOutputDevice(did_swap_buffer_complete_callback),
+      context_provider_(context_provider),
+      surface_handle_(surface_handle) {}
 
 SkiaOutputDeviceVulkan::~SkiaOutputDeviceVulkan() {
   if (vulkan_surface_)
     vulkan_surface_->Destroy();
 }
 
-sk_sp<SkSurface> SkiaOutputDeviceVulkan::DrawSurface() {
-  return draw_surface_;
-}
-
-void SkiaOutputDeviceVulkan::Reshape(const gfx::Size& size) {
+void SkiaOutputDeviceVulkan::Reshape(const gfx::Size& size,
+                                     float device_scale_factor,
+                                     const gfx::ColorSpace& color_space,
+                                     bool has_alpha) {
   if (!vulkan_surface_)
     CreateVulkanSurface();
 
@@ -45,11 +49,13 @@ void SkiaOutputDeviceVulkan::Reshape(const gfx::Size& size) {
   UpdateDrawSurface();
 }
 
-gfx::SwapResult SkiaOutputDeviceVulkan::SwapBuffers() {
+gfx::SwapResponse SkiaOutputDeviceVulkan::SwapBuffers(
+    BufferPresentedCallback feedback) {
   // Reshape should have been called first.
   DCHECK(vulkan_surface_);
   DCHECK(draw_surface_);
 
+  StartSwapBuffers(std::move(feedback));
   auto backend = draw_surface_->getBackendRenderTarget(
       SkSurface::kFlushRead_BackendHandleAccess);
   GrVkImageInfo vk_image_info;
@@ -57,11 +63,11 @@ gfx::SwapResult SkiaOutputDeviceVulkan::SwapBuffers() {
     NOTREACHED() << "Failed to get the image info.";
   vulkan_surface_->GetSwapChain()->SetCurrentImageLayout(
       vk_image_info.fImageLayout);
-  auto result = vulkan_surface_->SwapBuffers();
+  auto response = FinishSwapBuffers(vulkan_surface_->SwapBuffers());
 
   UpdateDrawSurface();
 
-  return result;
+  return response;
 }
 
 void SkiaOutputDeviceVulkan::CreateVulkanSurface() {

components/viz/service/display_embedder/skia_output_device_vulkan.h

@@ -20,15 +20,20 @@ namespace viz {
 
 class VulkanContextProvider;
 
-class SkiaOutputDeviceVulkan : public SkiaOutputDevice {
+class SkiaOutputDeviceVulkan final : public SkiaOutputDevice {
  public:
-  SkiaOutputDeviceVulkan(VulkanContextProvider* context_provider,
-                         gpu::SurfaceHandle surface_handle);
+  SkiaOutputDeviceVulkan(
+      VulkanContextProvider* context_provider,
+      gpu::SurfaceHandle surface_handle,
+      DidSwapBufferCompleteCallback did_swap_buffer_complete_callback);
   ~SkiaOutputDeviceVulkan() override;
 
-  sk_sp<SkSurface> DrawSurface() override;
-  void Reshape(const gfx::Size& size) override;
-  gfx::SwapResult SwapBuffers() override;
+  // SkiaOutputDevice implementation:
+  void Reshape(const gfx::Size& size,
+               float device_scale_factor,
+               const gfx::ColorSpace& color_space,
+               bool has_alpha) override;
+  gfx::SwapResponse SwapBuffers(BufferPresentedCallback feedback) override;
 
  private:
   void CreateVulkanSurface();
@@ -42,9 +47,6 @@ class SkiaOutputDeviceVulkan : public SkiaOutputDevice {
   // SkSurfaces for swap chain images.
   std::vector<sk_sp<SkSurface>> sk_surfaces_;
 
-  // SkSurface to be drawn to. Updated after Reshape and SwapBuffers.
-  sk_sp<SkSurface> draw_surface_;
-
   DISALLOW_COPY_AND_ASSIGN(SkiaOutputDeviceVulkan);
 };
 

components/viz/service/display_embedder/skia_output_device_x11.cc

@@ -4,6 +4,8 @@
 
 #include "components/viz/service/display_embedder/skia_output_device_x11.h"
 
+#include <utility>
+
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrBackendSurface.h"
 #include "third_party/skia/include/gpu/vk/GrVkTypes.h"
@@ -13,11 +15,14 @@
 
 namespace viz {
 
-SkiaOutputDeviceX11::SkiaOutputDeviceX11(GrContext* gr_context,
-                                         gfx::AcceleratedWidget widget)
+SkiaOutputDeviceX11::SkiaOutputDeviceX11(
+    GrContext* gr_context,
+    gfx::AcceleratedWidget widget,
+    DidSwapBufferCompleteCallback did_swap_buffer_complete_callback)
     : SkiaOutputDeviceOffscreen(gr_context,
                                 false /* flipped */,
-                                true /* has_alpha */),
+                                true /* has_alpha */,
+                                did_swap_buffer_complete_callback),
       display_(gfx::GetXDisplay()),
       widget_(widget),
       gc_(XCreateGC(display_, widget_, 0, nullptr)) {
@@ -32,23 +37,33 @@ SkiaOutputDeviceX11::~SkiaOutputDeviceX11() {
   XFreeGC(display_, gc_);
 }
 
-void SkiaOutputDeviceX11::Reshape(const gfx::Size& size) {
-  SkiaOutputDeviceOffscreen::Reshape(size);
+void SkiaOutputDeviceX11::Reshape(const gfx::Size& size,
+                                  float device_scale_factor,
+                                  const gfx::ColorSpace& color_space,
+                                  bool has_alpha) {
+  SkiaOutputDeviceOffscreen::Reshape(size, device_scale_factor, color_space,
+                                     has_alpha);
   auto ii =
       SkImageInfo::MakeN32(size.width(), size.height(), kOpaque_SkAlphaType);
   pixels_.reserve(ii.computeMinByteSize());
 }
 
-gfx::SwapResult SkiaOutputDeviceX11::SwapBuffers() {
+gfx::SwapResponse SkiaOutputDeviceX11::SwapBuffers(
+    BufferPresentedCallback feedback) {
   return PostSubBuffer(
-      gfx::Rect(0, 0, draw_surface_->width(), draw_surface_->height()));
+      gfx::Rect(0, 0, draw_surface_->width(), draw_surface_->height()),
+      std::move(feedback));
 }
 
 bool SkiaOutputDeviceX11::SupportPostSubBuffer() {
   return true;
 }
 
-gfx::SwapResult SkiaOutputDeviceX11::PostSubBuffer(const gfx::Rect& rect) {
+gfx::SwapResponse SkiaOutputDeviceX11::PostSubBuffer(
+    const gfx::Rect& rect,
+    BufferPresentedCallback feedback) {
+  StartSwapBuffers(std::move(feedback));
+
   auto ii =
       SkImageInfo::MakeN32(rect.width(), rect.height(), kOpaque_SkAlphaType);
   DCHECK_GE(pixels_.capacity(), ii.computeMinByteSize());
@@ -114,7 +129,7 @@ gfx::SwapResult SkiaOutputDeviceX11::PostSubBuffer(const gfx::Rect& rect) {
     NOTIMPLEMENTED();
   }
   XFlush(display_);
-  return gfx::SwapResult::SWAP_ACK;
+  return FinishSwapBuffers(gfx::SwapResult::SWAP_ACK);
 }
 
 }  // namespace viz

components/viz/service/display_embedder/skia_output_device_x11.h

@@ -17,13 +17,20 @@ namespace viz {
 
 class SkiaOutputDeviceX11 final : public SkiaOutputDeviceOffscreen {
  public:
-  SkiaOutputDeviceX11(GrContext* gr_context, gfx::AcceleratedWidget widget);
+  SkiaOutputDeviceX11(
+      GrContext* gr_context,
+      gfx::AcceleratedWidget widget,
+      DidSwapBufferCompleteCallback did_swap_buffer_complete_callback);
   ~SkiaOutputDeviceX11() override;
 
-  void Reshape(const gfx::Size& size) override;
-  gfx::SwapResult SwapBuffers() override;
+  void Reshape(const gfx::Size& size,
+               float device_scale_factor,
+               const gfx::ColorSpace& color_space,
+               bool has_alpha) override;
+  gfx::SwapResponse SwapBuffers(BufferPresentedCallback feedback) override;
   bool SupportPostSubBuffer() override;
-  gfx::SwapResult PostSubBuffer(const gfx::Rect& rect) override;
+  gfx::SwapResponse PostSubBuffer(const gfx::Rect& rect,
+                                  BufferPresentedCallback feedback) override;
 
  private:
   XDisplay* const display_;

components/viz/service/display_embedder/skia_output_surface_impl_on_gpu.h

@@ -69,7 +69,7 @@ struct RenderPassGeometry;
 
 // The SkiaOutputSurface implementation running on the GPU thread. This class
 // should be created, used and destroyed on the GPU thread.
-class SkiaOutputSurfaceImplOnGpu : public gpu::ImageTransportSurfaceDelegate {
+class SkiaOutputSurfaceImplOnGpu {
  public:
   using DidSwapBufferCompleteCallback =
       base::RepeatingCallback<void(gpu::SwapBuffersCompleteParams,
@@ -98,7 +98,7 @@ class SkiaOutputSurfaceImplOnGpu : public gpu::ImageTransportSurfaceDelegate {
       const BufferPresentedCallback& buffer_presented_callback,
       const ContextLostCallback& context_lost_callback);
 
-  ~SkiaOutputSurfaceImplOnGpu() override;
+  ~SkiaOutputSurfaceImplOnGpu();
 
   gpu::CommandBufferId command_buffer_id() const {
     return sync_point_client_state_->command_buffer_id();
@@ -160,33 +160,11 @@ class SkiaOutputSurfaceImplOnGpu : public gpu::ImageTransportSurfaceDelegate {
       const OutputSurface::Capabilities& capabilities);
 
  private:
-// gpu::ImageTransportSurfaceDelegate implementation:
-#if defined(OS_WIN)
-  void DidCreateAcceleratedSurfaceChildWindow(
-      gpu::SurfaceHandle parent_window,
-      gpu::SurfaceHandle child_window) override;
-#endif
-  void DidSwapBuffersComplete(gpu::SwapBuffersCompleteParams params) override;
-  const gpu::gles2::FeatureInfo* GetFeatureInfo() const override;
-  const gpu::GpuPreferences& GetGpuPreferences() const override;
-  void BufferPresented(const gfx::PresentationFeedback& feedback) override;
-  void AddFilter(IPC::MessageFilter* message_filter) override;
-  int32_t GetRouteID() const override;
-
-  void InitializeForGL();
   void InitializeForGLWithGpuService(GpuServiceImpl* gpu_service);
-  void InitializeForGLWithTaskExecutor(
-      gpu::CommandBufferTaskExecutor* task_executor,
-      scoped_refptr<gl::GLSurface> gl_surface);
   void InitializeForVulkan(GpuServiceImpl* gpu_service);
 
   void BindOrCopyTextureIfNecessary(gpu::TextureBase* texture_base);
 
-  // Generage the next swap ID and push it to our pending swap ID queues.
-  void OnSwapBuffers();
-
-  void CreateSkSurfaceForGL();
-
   // Make context current for GL, and return false if the context is lost.
   // It will do nothing when Vulkan is used.
   bool MakeCurrent(bool need_fbo0);
@@ -253,12 +231,6 @@ class SkiaOutputSurfaceImplOnGpu : public gpu::ImageTransportSurfaceDelegate {
   };
   base::flat_map<RenderPassId, OffscreenSurface> offscreen_surfaces_;
 
-  // Params are pushed each time we begin a swap, and popped each time we
-  // present or complete a swap.
-  base::circular_deque<std::pair<uint64_t, gfx::Size>>
-      pending_swap_completed_params_;
-  uint64_t swap_id_ = 0;
-
   ui::LatencyTracker latency_tracker_;
 
   scoped_refptr<base::SingleThreadTaskRunner> context_current_task_runner_;