SkiaRenderer: Add SkiaOutputSurface to allow SkiaRenderer to use SkDDL

This CL adds a new interface viz::SkiaOutputSurface which extends
viz::OutputSurface for SkiaRenderer to support compositing with SkDDL
(skia deferred display list). SkiaRenderer draws quads into a DDL SkCanvas,
and draw operations will be recorded into a DDL.
In OutputSurface::SwapBuffers(), a GPU task will be scheduled with
gpu::Schduler. The task will be executed on the GPU thread when all resource
sync tokes are satisfied. The task will play the DDL back on a GrContext
which is backed by a native platform GL context.

We have a goal to use SkiaRenderer everywhere, and remove GLRenderer and
Software Compositor. The new viz::SkiaOutputSurface interface and
viz::OutputSurface interface will be merged into one interface when DirectRenderer
subclasses are removed. The new interface is for making development
faster because when we change methods in viz::SkiaOutputSurface, we will not break
all other existing OutputSurface implementations.

Bug: 824382
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: I776a76dc8496d40f88950856867596f5c44f735f
Reviewed-on: https://chromium-review.googlesource.com/978366
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Cr-Commit-Position: refs/heads/master@{#553815}

components/viz/service/BUILD.gn

@@ -69,6 +69,8 @@ viz_component("service") {
     "display/scoped_render_pass_texture.h",
     "display/shader.cc",
     "display/shader.h",
+    "display/skia_output_surface.cc",
+    "display/skia_output_surface.h",
     "display/skia_renderer.cc",
     "display/skia_renderer.h",
     "display/software_output_device.cc",
@@ -101,6 +103,8 @@ viz_component("service") {
     "display_embedder/in_process_gpu_memory_buffer_manager.h",
     "display_embedder/server_shared_bitmap_manager.cc",
     "display_embedder/server_shared_bitmap_manager.h",
+    "display_embedder/skia_output_surface_impl.cc",
+    "display_embedder/skia_output_surface_impl.h",
     "display_embedder/software_output_surface.cc",
     "display_embedder/software_output_surface.h",
     "display_embedder/viz_process_context_provider.cc",

components/viz/service/display/display.cc

@@ -24,6 +24,7 @@
 #include "components/viz/service/display/display_scheduler.h"
 #include "components/viz/service/display/gl_renderer.h"
 #include "components/viz/service/display/output_surface.h"
+#include "components/viz/service/display/skia_output_surface.h"
 #include "components/viz/service/display/skia_renderer.h"
 #include "components/viz/service/display/software_renderer.h"
 #include "components/viz/service/display/surface_aggregator.h"
@@ -44,10 +45,12 @@ Display::Display(
     const FrameSinkId& frame_sink_id,
     std::unique_ptr<OutputSurface> output_surface,
     std::unique_ptr<DisplayScheduler> scheduler,
-    scoped_refptr<base::SingleThreadTaskRunner> current_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> current_task_runner,
+    SkiaOutputSurface* skia_output_surface)
     : bitmap_manager_(bitmap_manager),
       settings_(settings),
       frame_sink_id_(frame_sink_id),
+      skia_output_surface_(skia_output_surface),
       output_surface_(std::move(output_surface)),
       scheduler_(std::move(scheduler)),
       current_task_runner_(std::move(current_task_runner)) {
@@ -214,8 +217,10 @@ void Display::InitializeRenderer() {
           &settings_, output_surface_.get(), resource_provider_.get(),
           current_task_runner_);
     } else {
+      DCHECK(output_surface_);
       renderer_ = std::make_unique<SkiaRenderer>(
-          &settings_, output_surface_.get(), resource_provider_.get());
+          &settings_, output_surface_.get(), resource_provider_.get(),
+          skia_output_surface_);
     }
   } else if (output_surface_->vulkan_context_provider()) {
 #if BUILDFLAG(ENABLE_VULKAN)

components/viz/service/display/display.h

@@ -40,6 +40,7 @@ class DirectRenderer;
 class DisplayClient;
 class OutputSurface;
 class SharedBitmapManager;
+class SkiaOutputSurface;
 class SoftwareRenderer;
 
 class VIZ_SERVICE_EXPORT DisplayObserver {
@@ -61,12 +62,15 @@ class VIZ_SERVICE_EXPORT Display : public DisplaySchedulerClient,
   // case, DrawAndSwap must be called externally when needed.
   // The |current_task_runner| may be null if the Display is on a thread without
   // a MessageLoop.
+  // TODO(penghuang): Remove skia_output_surface when all DirectRenderer
+  // subclasses are replaced by SkiaRenderer.
   Display(SharedBitmapManager* bitmap_manager,
           const RendererSettings& settings,
           const FrameSinkId& frame_sink_id,
           std::unique_ptr<OutputSurface> output_surface,
           std::unique_ptr<DisplayScheduler> scheduler,
-          scoped_refptr<base::SingleThreadTaskRunner> current_task_runner);
+          scoped_refptr<base::SingleThreadTaskRunner> current_task_runner,
+          SkiaOutputSurface* skia_output_surface = nullptr);
 
   ~Display() override;
 
@@ -146,6 +150,7 @@ class VIZ_SERVICE_EXPORT Display : public DisplaySchedulerClient,
   bool swapped_since_resize_ = false;
   bool output_is_secure_ = false;
 
+  SkiaOutputSurface* skia_output_surface_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<DisplayScheduler> scheduler_;
   std::unique_ptr<cc::DisplayResourceProvider> resource_provider_;

components/viz/service/display/skia_output_surface.cc

+// Copyright 2018 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/skia_output_surface.h"
+
+namespace viz {
+
+SkiaOutputSurface::SkiaOutputSurface(
+    scoped_refptr<ContextProvider> context_provider)
+    : OutputSurface(std::move(context_provider)) {}
+
+SkiaOutputSurface::~SkiaOutputSurface() = default;
+
+}  // namespace viz

components/viz/service/display/skia_output_surface.h

+// Copyright 2018 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_SKIA_OUTPUT_SURFACE_H_
+#define COMPONENTS_VIZ_SERVICE_DISPLAY_SKIA_OUTPUT_SURFACE_H_
+
+#include "components/viz/service/display/output_surface.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
+
+class SkCanvas;
+class SkImage;
+
+namespace viz {
+
+struct ResourceMetadata;
+
+// This class extends the OutputSurface for SkiaRenderer needs. In future, the
+// SkiaRenderer will be the only renderer. When other renderers are removed,
+// we will replace OutputSurface with SkiaOutputSurface, and remove all
+// OutputSurface's methods which are not useful for SkiaRenderer.
+class VIZ_SERVICE_EXPORT SkiaOutputSurface : public OutputSurface {
+ public:
+  explicit SkiaOutputSurface(scoped_refptr<ContextProvider> context_provider);
+  ~SkiaOutputSurface() override;
+
+  // Get a SkCanvas for the current frame. The SkiaRenderer will use this
+  // SkCanvas to draw quads. This class retains the ownership of the SkCanvas,
+  // And this SkCanvas may become invalid, when the frame is swapped out.
+  virtual SkCanvas* GetSkCanvasForCurrentFrame() = 0;
+
+  // Make a SkImage from the given |metadata|. The SkiaRenderer can use the
+  // image with SkCanvas returned by |GetSkCanvasForCurrentFrame|, but Skia will
+  // not read the content of the resource until the sync token in the |metadata|
+  // is satisfied. The SwapBuffers should take care of this by scheduling a GPU
+  // task with all resource sync tokens recorded by MakePromiseSkImage for the
+  // current frame.
+  virtual sk_sp<SkImage> MakePromiseSkImage(ResourceMetadata metadata) = 0;
+
+  // Swaps the current backbuffer to the screen and return a sync token which
+  // can be waited on in a command buffer to ensure the frame is completed. This
+  // token is released when the GPU ops from drawing the frame have been seen
+  // and processed by the GPU main.
+  // TODO(penghuang): replace OutputSurface::SwapBuffers with this method when
+  // SkiaRenderer and DDL are used everywhere.
+  virtual gpu::SyncToken SkiaSwapBuffers(OutputSurfaceFrame frame) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SkiaOutputSurface);
+};
+
+}  // namespace viz
+
+#endif  // COMPONENTS_VIZ_SERVICE_DISPLAY_SKIA_OUTPUT_SURFACE_H_

components/viz/service/display/skia_renderer.h

@@ -15,11 +15,6 @@
 
 class SkNWayCanvas;
 
-namespace cc {
-class OutputSurface;
-class RenderPassDrawQuad;
-}  // namespace cc
-
 namespace gpu {
 struct Capabilities;
 }
@@ -27,16 +22,18 @@ struct Capabilities;
 namespace viz {
 class DebugBorderDrawQuad;
 class PictureDrawQuad;
+class SkiaOutputSurface;
 class SolidColorDrawQuad;
 class TextureDrawQuad;
 class TileDrawQuad;
 
 class VIZ_SERVICE_EXPORT SkiaRenderer : public DirectRenderer {
  public:
+  // TODO(penghuang): Remove skia_output_surface when DDL is used everywhere.
   SkiaRenderer(const RendererSettings* settings,
                OutputSurface* output_surface,
-               cc::DisplayResourceProvider* resource_provider);
-
+               cc::DisplayResourceProvider* resource_provider,
+               SkiaOutputSurface* skia_output_surface = nullptr);
   ~SkiaRenderer() override;
 
   void SwapBuffers(std::vector<ui::LatencyInfo> latency_info) override;
@@ -77,6 +74,7 @@ class VIZ_SERVICE_EXPORT SkiaRenderer : public DirectRenderer {
 
  private:
   struct DrawRenderPassDrawQuadParams;
+  class ScopedSkImageBuilder;
 
   void ClearCanvas(SkColor color);
   void ClearFramebuffer();
@@ -127,9 +125,10 @@ class VIZ_SERVICE_EXPORT SkiaRenderer : public DirectRenderer {
   };
   base::flat_map<RenderPassId, RenderPassBacking> render_pass_backings_;
 
+  SkiaOutputSurface* const skia_output_surface_ = nullptr;
   bool disable_picture_quad_image_filtering_ = false;
-
   bool is_scissor_enabled_ = false;
+
   gfx::Rect scissor_rect_;
 
   sk_sp<SkSurface> root_surface_;
@@ -148,6 +147,19 @@ class VIZ_SERVICE_EXPORT SkiaRenderer : public DirectRenderer {
   gfx::Rect swap_buffer_rect_;
   std::vector<gfx::Rect> swap_content_bounds_;
 
+  // Lock set for resources that are used for the current frame. All resources
+  // in this set will be unlocked with a sync token when the frame is done in
+  // the compositor thread. And the sync token will be released when the DDL
+  // for the current frame is replayed on the GPU thread.
+  // It is only used with DDL.
+  cc::DisplayResourceProvider::LockSetForExternalUse lock_set_for_external_use_;
+
+  // Promise images created from resources used in the current frame. This map
+  // will be cleared when the frame is done and before all resources in
+  // |lock_set_for_external_use_| are unlocked on the compositor thread.
+  // It is only used with DDL.
+  base::flat_map<ResourceId, sk_sp<SkImage>> promise_images_;
+
   DISALLOW_COPY_AND_ASSIGN(SkiaRenderer);
 };
 

components/viz/service/display_embedder/DEPS

@@ -10,8 +10,10 @@ include_rules = [
   "+components/viz/service/display/output_surface_frame.h",
   "+components/viz/service/display/output_surface.h",
   "+components/viz/service/display/overlay_candidate_validator.h",
+  "+components/viz/service/display/skia_output_surface.h",
   "+components/viz/service/display/software_output_device.h",
   "+gpu/config/gpu_feature_info.h",
+  "+components/viz/service/gl/gpu_service_impl.h",
   "+gpu/GLES2",
   "+gpu/command_buffer/client",
   "+gpu/command_buffer/common",

components/viz/service/display_embedder/gpu_display_provider.cc

@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/compiler_specific.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/base/switches.h"
 #include "components/viz/common/display/renderer_settings.h"
@@ -17,6 +18,7 @@
 #include "components/viz/service/display_embedder/gl_output_surface.h"
 #include "components/viz/service/display_embedder/in_process_gpu_memory_buffer_manager.h"
 #include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
+#include "components/viz/service/display_embedder/skia_output_surface_impl.h"
 #include "components/viz/service/display_embedder/software_output_surface.h"
 #include "components/viz/service/display_embedder/viz_process_context_provider.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
@@ -64,11 +66,13 @@ namespace viz {
 
 GpuDisplayProvider::GpuDisplayProvider(
     uint32_t restart_id,
+    GpuServiceImpl* gpu_service_impl,
     scoped_refptr<gpu::InProcessCommandBuffer::Service> gpu_service,
     gpu::GpuChannelManager* gpu_channel_manager,
     bool headless,
     bool wait_for_all_pipeline_stages_before_draw)
     : restart_id_(restart_id),
+      gpu_service_impl_(gpu_service_impl),
       gpu_service_(std::move(gpu_service)),
       gpu_channel_manager_delegate_(gpu_channel_manager->delegate()),
       gpu_memory_buffer_manager_(
@@ -103,11 +107,37 @@ std::unique_ptr<Display> GpuDisplayProvider::CreateDisplay(
     display_begin_frame_source = synthetic_begin_frame_source.get();
   }
 
+  // TODO(penghuang): Merge two output surfaces into one when GLRenderer and
+  // software compositor is removed.
   std::unique_ptr<OutputSurface> output_surface;
+  SkiaOutputSurface* skia_output_surface = nullptr;
 
   if (!gpu_compositing) {
     output_surface = std::make_unique<SoftwareOutputSurface>(
         CreateSoftwareOutputDeviceForPlatform(surface_handle), task_runner_);
+  } else if (renderer_settings.use_skia_renderer &&
+             renderer_settings.use_skia_deferred_display_list) {
+#if defined(OS_MACOSX) || defined(OS_WIN)
+    // TODO(penghuang): Support DDL for all platforms.
+    NOTIMPLEMENTED();
+    // Workaround compile error: private field 'gpu_service_impl_' is not used.
+    ALLOW_UNUSED_LOCAL(gpu_service_impl_);
+#else
+    // Create an offscreen context_provider for SkiaOutputSurfaceImpl, because
+    // SkiaRenderer still needs it to draw RenderPass into a texture.
+    // TODO(penghuang): remove this context when we figure out how to use DDL
+    // to draw RenderPass. https://crbug.com/825901
+    auto context_provider = base::MakeRefCounted<VizProcessContextProvider>(
+        gpu_service_, gpu::kNullSurfaceHandle, gpu_memory_buffer_manager_.get(),
+        image_factory_, gpu_channel_manager_delegate_,
+        gpu::SharedMemoryLimits());
+    auto result = context_provider->BindToCurrentThread();
+    CHECK_EQ(result, gpu::ContextResult::kSuccess);
+    output_surface = std::make_unique<SkiaOutputSurfaceImpl>(
+        gpu_service_impl_, surface_handle, std::move(context_provider),
+        synthetic_begin_frame_source.get());
+    skia_output_surface = static_cast<SkiaOutputSurface*>(output_surface.get());
+#endif
   } else {
     scoped_refptr<VizProcessContextProvider> context_provider;
 
@@ -166,7 +196,8 @@ std::unique_ptr<Display> GpuDisplayProvider::CreateDisplay(
 
   return std::make_unique<Display>(
       ServerSharedBitmapManager::current(), renderer_settings, frame_sink_id,
-      std::move(output_surface), std::move(scheduler), task_runner_);
+      std::move(output_surface), std::move(scheduler), task_runner_,
+      skia_output_surface);
 }
 
 std::unique_ptr<SoftwareOutputDevice>

components/viz/service/display_embedder/gpu_display_provider.h

@@ -27,6 +27,7 @@ class ImageFactory;
 namespace viz {
 class Display;
 class ExternalBeginFrameControllerImpl;
+class GpuServiceImpl;
 class OutputDeviceBacking;
 class SoftwareOutputDevice;
 
@@ -35,6 +36,7 @@ class VIZ_SERVICE_EXPORT GpuDisplayProvider : public DisplayProvider {
  public:
   GpuDisplayProvider(
       uint32_t restart_id,
+      GpuServiceImpl* gpu_service_impl,
       scoped_refptr<gpu::InProcessCommandBuffer::Service> gpu_service,
       gpu::GpuChannelManager* gpu_channel_manager,
       bool headless,
@@ -56,6 +58,7 @@ class VIZ_SERVICE_EXPORT GpuDisplayProvider : public DisplayProvider {
       gpu::SurfaceHandle surface_handle);
 
   const uint32_t restart_id_;
+  GpuServiceImpl* const gpu_service_impl_;
   scoped_refptr<gpu::InProcessCommandBuffer::Service> gpu_service_;
   gpu::GpuChannelManagerDelegate* const gpu_channel_manager_delegate_;
   std::unique_ptr<gpu::GpuMemoryBufferManager> gpu_memory_buffer_manager_;

components/viz/service/display_embedder/skia_output_surface_impl.h

+// Copyright 2018 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_SURFACE_IMPL_H_
+#define COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_SURFACE_IMPL_H_
+
+#include "base/macros.h"
+#include "base/threading/thread_checker.h"
+#include "components/viz/service/display/skia_output_surface.h"
+#include "gpu/command_buffer/common/sync_token.h"
+#include "gpu/ipc/common/surface_handle.h"
+#include "gpu/ipc/in_process_command_buffer.h"
+#include "gpu/ipc/service/image_transport_surface_delegate.h"
+#include "third_party/skia/include/core/SkDeferredDisplayListRecorder.h"
+#include "third_party/skia/include/core/SkSurface.h"
+
+namespace base {
+class WaitableEvent;
+}
+
+namespace gl {
+class GLSurface;
+}
+
+namespace gpu {
+class SyncPointClientState;
+}
+
+namespace viz {
+
+class GpuServiceImpl;
+class VizProcessContextProvider;
+class SyntheticBeginFrameSource;
+
+// The SkiaOutputSurface implementation. It is the output surface for
+// SkiaRenderer. It lives on the compositor thread, but it will post tasks
+// to the GPU thread for initializing, reshaping and swapping buffers, etc.
+// Currently, SkiaOutputSurfaceImpl sets up SkSurface from the default GL
+// framebuffer, creates SkDeferredDisplayListRecorder and SkCanvas for
+// SkiaRenderer to render into. In SwapBuffers, it detaches a
+// SkDeferredDisplayList from the recorder and plays it back on the framebuffer
+// SkSurface on the GPU thread.
+class SkiaOutputSurfaceImpl : public SkiaOutputSurface,
+                              public gpu::ImageTransportSurfaceDelegate {
+ public:
+  SkiaOutputSurfaceImpl(
+      GpuServiceImpl* gpu_service,
+      gpu::SurfaceHandle surface_handle,
+      scoped_refptr<VizProcessContextProvider> context_provider,
+      SyntheticBeginFrameSource* synthetic_begin_frame_source);
+  ~SkiaOutputSurfaceImpl() override;
+
+  // OutputSurface implementation:
+  void BindToClient(OutputSurfaceClient* client) override;
+  void EnsureBackbuffer() override;
+  void DiscardBackbuffer() override;
+  void BindFramebuffer() override;
+  void SetDrawRectangle(const gfx::Rect& draw_rectangle) override;
+  void Reshape(const gfx::Size& size,
+               float device_scale_factor,
+               const gfx::ColorSpace& color_space,
+               bool has_alpha,
+               bool use_stencil) override;
+  void SwapBuffers(OutputSurfaceFrame frame) override;
+  uint32_t GetFramebufferCopyTextureFormat() override;
+  OverlayCandidateValidator* GetOverlayCandidateValidator() const override;
+  bool IsDisplayedAsOverlayPlane() const override;
+  unsigned GetOverlayTextureId() const override;
+  gfx::BufferFormat GetOverlayBufferFormat() const override;
+  bool SurfaceIsSuspendForRecycle() const override;
+  bool HasExternalStencilTest() const override;
+  void ApplyExternalStencil() override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
+
+  // SkiaOutputSurface implementation:
+  SkCanvas* GetSkCanvasForCurrentFrame() override;
+  sk_sp<SkImage> MakePromiseSkImage(ResourceMetadata metadata) override;
+  gpu::SyncToken SkiaSwapBuffers(OutputSurfaceFrame frame) override;
+
+  // gpu::ImageTransportSurfaceDelegate implementation:
+  void DidSwapBuffersComplete(gpu::SwapBuffersCompleteParams params) override;
+  const gpu::gles2::FeatureInfo* GetFeatureInfo() const override;
+  const gpu::GpuPreferences& GetGpuPreferences() const override;
+
+  void SetSnapshotRequestedCallback(const base::Closure& callback) override;
+  void UpdateVSyncParameters(base::TimeTicks timebase,
+                             base::TimeDelta interval) override;
+  void BufferPresented(uint64_t swap_id,
+                       const gfx::PresentationFeedback& feedback) override;
+
+  void AddFilter(IPC::MessageFilter* message_filter) override;
+  int32_t GetRouteID() const override;
+
+ private:
+  void InitializeOnGpuThread(base::WaitableEvent* event);
+  void DestroyOnGpuThread(base::WaitableEvent* event);
+  void ReshapeOnGpuThread(const gfx::Size& size,
+                          float device_scale_factor,
+                          const gfx::ColorSpace& color_space,
+                          bool has_alpha,
+                          bool use_stencil,
+                          SkSurfaceCharacterization* characterization,
+                          base::WaitableEvent* event);
+  void SwapBuffersOnGpuThread(OutputSurfaceFrame frame,
+                              std::unique_ptr<SkDeferredDisplayList> ddl,
+                              uint64_t sync_fence_release);
+
+  void RecreateRecorder();
+  void DidSwapBuffersCompleteOnClientThread(
+      gpu::SwapBuffersCompleteParams params);
+  void UpdateVSyncParametersOnClientThread(base::TimeTicks timebase,
+                                           base::TimeDelta interval);
+  void BufferPresentedOnClientThread(uint64_t swap_id,
+                                     const gfx::PresentationFeedback& feedback);
+
+  struct PromiseTextureInfo;
+  static void PromiseTextureFullfillStub(void* texture_context,
+                                         GrBackendTexture* backend_texture);
+  static void PromiseTextureReleaseStub(void* texture_context);
+  static void PromiseTextureDoneStub(void* texture_context);
+  void OnPromiseTextureFullfill(const ResourceMetadata& metadata,
+                                GrBackendTexture* backend_texture);
+  void OnPromiseTextureRelease(const ResourceMetadata& metadata);
+
+  const gpu::CommandBufferId command_buffer_id_;
+  uint64_t sync_fence_release_ = 0;
+  GpuServiceImpl* const gpu_service_;
+  const gpu::SurfaceHandle surface_handle_;
+  SyntheticBeginFrameSource* const synthetic_begin_frame_source_;
+  OutputSurfaceClient* client_ = nullptr;
+
+  scoped_refptr<gpu::SyncPointClientState> sync_point_client_state_;
+
+  gpu::GpuPreferences gpu_preferences_;
+  scoped_refptr<gl::GLSurface> surface_;
+
+  sk_sp<SkSurface> sk_surface_;
+  SkSurfaceCharacterization characterization_;
+  std::unique_ptr<SkDeferredDisplayListRecorder> recorder_;
+
+  // Sync tokens for resources which are used for the current frame.
+  std::vector<gpu::SyncToken> resource_sync_tokens_;
+
+  scoped_refptr<base::SingleThreadTaskRunner> client_thread_task_runner_;
+
+  THREAD_CHECKER(client_thread_checker_);
+  THREAD_CHECKER(gpu_thread_checker_);
+
+  base::WeakPtr<SkiaOutputSurfaceImpl> client_thread_weak_ptr_;
+  base::WeakPtrFactory<SkiaOutputSurfaceImpl> gpu_thread_weak_ptr_factory_;
+  base::WeakPtrFactory<SkiaOutputSurfaceImpl> client_thread_weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SkiaOutputSurfaceImpl);
+};
+
+}  // namespace viz
+
+#endif  // COMPONENTS_VIZ_SERVICE_DISPLAY_EMBEDDER_SKIA_OUTPUT_SURFACE_IMPL_H_

components/viz/service/main/viz_main_impl.cc

@@ -280,7 +280,7 @@ void VizMainImpl::CreateFrameSinkManagerOnCompositorThread(
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   display_provider_ = std::make_unique<GpuDisplayProvider>(
-      params->restart_id, gpu_command_service_,
+      params->restart_id, gpu_service_.get(), gpu_command_service_,
       gpu_service_->gpu_channel_manager(),
       command_line->HasSwitch(switches::kHeadless),
       command_line->HasSwitch(switches::kRunAllCompositorStagesBeforeDraw));

gpu/command_buffer/common/constants.h

@@ -84,8 +84,7 @@ enum CommandBufferNamespace : int8_t {
 
   GPU_IO,
   IN_PROCESS,
-  MOJO,
-  MOJO_LOCAL,
+  VIZ_OUTPUT_SURFACE,
 
   NUM_COMMAND_BUFFER_NAMESPACES
 };