Use SharedImageInterface for gpu and OOP raster

This wires up SharedImageInterface all the way to cc, and uses it for OOP and GPU raster.
This also adds memory accounting in SharedImageFactory/SharedImageStub.

Bug: 870116
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
Change-Id: I37eba221bc2aeb4d03b7d4d93bde772482dc681b
Reviewed-on: https://chromium-review.googlesource.com/1178977
Commit-Queue: Antoine Labour <piman@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Cr-Commit-Position: refs/heads/master@{#592419}

android_webview/browser/aw_render_thread_context_provider.cc

@@ -149,6 +149,11 @@ class GrContext* AwRenderThreadContextProvider::GrContext() {
   return gr_context_.get();
 }
 
+gpu::SharedImageInterface*
+AwRenderThreadContextProvider::SharedImageInterface() {
+  return context_->GetSharedImageInterface();
+}
+
 viz::ContextCacheController* AwRenderThreadContextProvider::CacheController() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   return cache_controller_.get();

android_webview/browser/aw_render_thread_context_provider.h

@@ -51,6 +51,7 @@ class AwRenderThreadContextProvider
   gpu::gles2::GLES2Interface* ContextGL() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
+  gpu::SharedImageInterface* SharedImageInterface() override;
   viz::ContextCacheController* CacheController() override;
   base::Lock* GetLock() override;
   void AddObserver(viz::ContextLostObserver* obs) override;

cc/DEPS

@@ -8,6 +8,8 @@ include_rules = [
   "+gpu/command_buffer/client/gles2_interface_stub.h", # for tests
   "+gpu/command_buffer/client/gpu_memory_buffer_manager.h",
   "+gpu/command_buffer/client/raster_implementation_gles.h",
+  "+gpu/command_buffer/client/raster_interface.h",
+  "+gpu/command_buffer/client/shared_image_interface.h",
   "+gpu/command_buffer/common/capabilities.h",
   "+gpu/command_buffer/common/discardable_handle.h",
   "+gpu/command_buffer/common/gl2_types.h",
@@ -15,7 +17,8 @@ include_rules = [
   "+gpu/command_buffer/common/gpu_memory_buffer_support.h",
   "+gpu/command_buffer/common/mailbox.h",
   "+gpu/command_buffer/common/mailbox_holder.h",
-  "+gpu/command_buffer/client/raster_interface.h",
+  "+gpu/command_buffer/common/shared_image_trace_utils.h",
+  "+gpu/command_buffer/common/shared_image_usage.h",
   "+gpu/command_buffer/common/sync_token.h",
   "+gpu/command_buffer/common/texture_in_use_response.h",
   "+gpu/config/gpu_feature_info.h",

cc/raster/gpu_raster_buffer_provider.h

@@ -49,10 +49,9 @@ class CC_EXPORT GpuRasterBufferProvider : public RasterBufferProvider {
   void Shutdown() override;
 
   gpu::SyncToken PlaybackOnWorkerThread(
-      const gpu::Mailbox& mailbox,
+      gpu::Mailbox* mailbox,
       GLenum texture_target,
       bool texture_is_overlay_candidate,
-      bool texture_storage_allocated,
       const gpu::SyncToken& sync_token,
       const gfx::Size& resource_size,
       viz::ResourceFormat resource_format,
@@ -97,11 +96,10 @@ class CC_EXPORT GpuRasterBufferProvider : public RasterBufferProvider {
     const gfx::ColorSpace color_space_;
     const bool resource_has_previous_content_;
     const gpu::SyncToken before_raster_sync_token_;
-    const gpu::Mailbox mailbox_;
     const GLenum texture_target_;
     const bool texture_is_overlay_candidate_;
-    // Set to true once allocation is done in the worker thread.
-    bool texture_storage_allocated_;
+
+    gpu::Mailbox mailbox_;
     // A SyncToken to be returned from the worker thread, and waited on before
     // using the rastered resource.
     gpu::SyncToken after_raster_sync_token_;

cc/raster/raster_buffer_provider_perftest.cc

@@ -117,6 +117,12 @@ class PerfContextProvider
     }
     return test_context_provider_->GrContext();
   }
+  gpu::SharedImageInterface* SharedImageInterface() override {
+    if (!test_context_provider_) {
+      test_context_provider_ = viz::TestContextProvider::Create();
+    }
+    return test_context_provider_->SharedImageInterface();
+  }
   viz::ContextCacheController* CacheController() override {
     return &cache_controller_;
   }

cc/test/test_in_process_context_provider.cc

@@ -162,6 +162,15 @@ class GrContext* TestInProcessContextProvider::GrContext() {
   return gr_context_->get();
 }
 
+gpu::SharedImageInterface*
+TestInProcessContextProvider::SharedImageInterface() {
+  if (gles2_context_) {
+    return gles2_context_->GetSharedImageInterface();
+  } else {
+    return raster_context_->GetSharedImageInterface();
+  }
+}
+
 viz::ContextCacheController* TestInProcessContextProvider::CacheController() {
   return cache_controller_.get();
 }

cc/test/test_in_process_context_provider.h

@@ -56,6 +56,7 @@ class TestInProcessContextProvider
   gpu::raster::RasterInterface* RasterInterface() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
+  gpu::SharedImageInterface* SharedImageInterface() override;
   viz::ContextCacheController* CacheController() override;
   base::Lock* GetLock() override;
   const gpu::Capabilities& ContextCapabilities() const override;

components/viz/common/gl_scaler_unittest.cc

@@ -69,6 +69,10 @@ class MockContextProvider : public ContextProvider {
     NOTREACHED();
     return nullptr;
   }
+  gpu::SharedImageInterface* SharedImageInterface() final {
+    NOTREACHED();
+    return nullptr;
+  }
   const gpu::GpuFeatureInfo& GetGpuFeatureInfo() const final {
     NOTREACHED();
     return *reinterpret_cast<gpu::GpuFeatureInfo*>(0xdeadbeef);

components/viz/common/gpu/context_provider.h

@@ -26,6 +26,7 @@ class Lock;
 namespace gpu {
 class ContextSupport;
 struct GpuFeatureInfo;
+class SharedImageInterface;
 
 namespace gles2 {
 class GLES2Interface;
@@ -92,6 +93,8 @@ class VIZ_COMMON_EXPORT ContextProvider {
   // nullptr if a GrContext fails to initialize on this context.
   virtual class GrContext* GrContext() = 0;
 
+  virtual gpu::SharedImageInterface* SharedImageInterface() = 0;
+
   // Returns the capabilities of the currently bound 3d context.  The context
   // provider must have been successfully bound to a thread before calling this.
   virtual const gpu::Capabilities& ContextCapabilities() const = 0;

components/viz/common/gpu/raster_context_provider.h

@@ -26,6 +26,7 @@ class Lock;
 namespace gpu {
 class ContextSupport;
 struct GpuFeatureInfo;
+class SharedImageInterface;
 
 namespace gles2 {
 class GLES2Interface;
@@ -99,6 +100,8 @@ class VIZ_COMMON_EXPORT RasterContextProvider {
   // nullptr if a GrContext fails to initialize on this context.
   virtual class GrContext* GrContext() = 0;
 
+  virtual gpu::SharedImageInterface* SharedImageInterface() = 0;
+
   // Returns the capabilities of the currently bound 3d context.  The context
   // provider must have been successfully bound to a thread before calling this.
   virtual const gpu::Capabilities& ContextCapabilities() const = 0;

components/viz/service/display_embedder/viz_process_context_provider.cc

@@ -154,6 +154,10 @@ class GrContext* VizProcessContextProvider::GrContext() {
   return gr_context_->get();
 }
 
+gpu::SharedImageInterface* VizProcessContextProvider::SharedImageInterface() {
+  return command_buffer_->GetSharedImageInterface();
+}
+
 ContextCacheController* VizProcessContextProvider::CacheController() {
   return cache_controller_.get();
 }

components/viz/service/display_embedder/viz_process_context_provider.h

@@ -62,6 +62,7 @@ class VIZ_SERVICE_EXPORT VizProcessContextProvider
   gpu::gles2::GLES2Interface* ContextGL() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
+  gpu::SharedImageInterface* SharedImageInterface() override;
   ContextCacheController* CacheController() override;
   base::Lock* GetLock() override;
   const gpu::Capabilities& ContextCapabilities() const override;

components/viz/test/DEPS

@@ -6,6 +6,7 @@ include_rules = [
   "+gpu/command_buffer/client/context_support.h",
   "+gpu/command_buffer/client/gles2_interface_stub.h",
   "+gpu/command_buffer/client/raster_implementation_gles.h",
+  "+gpu/command_buffer/client/shared_image_interface.h",
   "+gpu/command_buffer/common/capabilities.h",
   "+gpu/command_buffer/common/skia_utils.h",
   "+gpu/command_buffer/common/sync_token.h",

components/viz/test/test_context_provider.cc

@@ -18,6 +18,7 @@
 #include "components/viz/common/gpu/context_cache_controller.h"
 #include "components/viz/test/test_gles2_interface.h"
 #include "gpu/command_buffer/client/raster_implementation_gles.h"
+#include "gpu/command_buffer/client/shared_image_interface.h"
 #include "gpu/command_buffer/common/skia_utils.h"
 #include "gpu/skia_bindings/grcontext_for_gles2_interface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ -110,6 +111,29 @@ class TestGLES2InterfaceForContextProvider : public TestGLES2Interface {
   DISALLOW_COPY_AND_ASSIGN(TestGLES2InterfaceForContextProvider);
 };
 
+class TestSharedImageInterface : public gpu::SharedImageInterface {
+ public:
+  ~TestSharedImageInterface() override = default;
+
+  gpu::Mailbox CreateSharedImage(ResourceFormat format,
+                                 const gfx::Size& size,
+                                 const gfx::ColorSpace& color_space,
+                                 uint32_t usage) override {
+    return gpu::Mailbox::Generate();
+  }
+
+  void DestroySharedImage(const gpu::SyncToken& sync_token,
+                          const gpu::Mailbox& mailbox) override {}
+
+  gpu::SyncToken GenUnverifiedSyncToken() override {
+    return gpu::SyncToken(gpu::CommandBufferNamespace::GPU_IO,
+                          gpu::CommandBufferId(), ++release_id_);
+  }
+
+ private:
+  uint64_t release_id_ = 0;
+};
+
 }  // namespace
 
 // static
@@ -179,6 +203,7 @@ TestContextProvider::TestContextProvider(
     bool support_locking)
     : support_(std::move(support)),
       context_gl_(std::move(gl)),
+      shared_image_interface_(std::make_unique<TestSharedImageInterface>()),
       support_locking_(support_locking),
       weak_ptr_factory_(this) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ -271,6 +296,10 @@ class GrContext* TestContextProvider::GrContext() {
   return gr_context_->get();
 }
 
+gpu::SharedImageInterface* TestContextProvider::SharedImageInterface() {
+  return shared_image_interface_.get();
+}
+
 ContextCacheController* TestContextProvider::CacheController() {
   CheckValidThreadOrLockAcquired();
   return cache_controller_.get();

components/viz/test/test_context_provider.h

@@ -62,6 +62,7 @@ class TestContextProvider
   gpu::raster::RasterInterface* RasterInterface() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
+  gpu::SharedImageInterface* SharedImageInterface() override;
   ContextCacheController* CacheController() override;
   base::Lock* GetLock() override;
   void AddObserver(ContextLostObserver* obs) override;
@@ -96,6 +97,7 @@ class TestContextProvider
   std::unique_ptr<gpu::raster::RasterInterface> raster_context_;
   std::unique_ptr<skia_bindings::GrContextForGLES2Interface> gr_context_;
   std::unique_ptr<ContextCacheController> cache_controller_;
+  std::unique_ptr<gpu::SharedImageInterface> shared_image_interface_;
   const bool support_locking_ ALLOW_UNUSED_TYPE;
   bool bound_ = false;
 

gpu/command_buffer/common/BUILD.gn

@@ -87,6 +87,8 @@ jumbo_source_set("common_sources") {
     "mailbox_holder.h",
     "scheduling_priority.cc",
     "scheduling_priority.h",
+    "shared_image_trace_utils.cc",
+    "shared_image_trace_utils.h",
     "shared_image_usage.h",
     "swap_buffers_complete_params.cc",
     "swap_buffers_complete_params.h",

gpu/command_buffer/common/shared_image_trace_utils.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 "gpu/command_buffer/common/shared_image_trace_utils.h"
+
+#include "base/strings/stringprintf.h"
+#include "gpu/command_buffer/common/mailbox.h"
+
+namespace gpu {
+
+base::trace_event::MemoryAllocatorDumpGuid GetSharedImageGUIDForTracing(
+    const Mailbox& mailbox) {
+  return base::trace_event::MemoryAllocatorDumpGuid(base::StringPrintf(
+      "gpu-shared-image/%s", mailbox.ToDebugString().c_str()));
+}
+
+}  // namespace gpu

gpu/command_buffer/common/shared_image_trace_utils.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 GPU_COMMAND_BUFFER_COMMON_SHARED_IMAGE_TRACE_UTILS_H_
+#define GPU_COMMAND_BUFFER_COMMON_SHARED_IMAGE_TRACE_UTILS_H_
+
+#include "base/trace_event/memory_allocator_dump.h"
+#include "gpu/gpu_export.h"
+
+namespace gpu {
+
+struct Mailbox;
+
+GPU_EXPORT base::trace_event::MemoryAllocatorDumpGuid
+GetSharedImageGUIDForTracing(const Mailbox& mailbox);
+
+}  // namespace gpu
+
+#endif  // GPU_COMMAND_BUFFER_COMMON_SHARED_IMAGE_TRACE_UTILS_H_

gpu/command_buffer/service/shared_image_factory.cc

@@ -4,8 +4,13 @@
 
 #include "gpu/command_buffer/service/shared_image_factory.h"
 
+#include <inttypes.h>
+
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "components/viz/common/resources/resource_format_utils.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
+#include "gpu/command_buffer/common/shared_image_trace_utils.h"
 #include "gpu/command_buffer/common/shared_image_usage.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/image_factory.h"
@@ -16,6 +21,7 @@
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_bindings.h"
+#include "ui/gl/trace_util.h"
 
 namespace gpu {
 
@@ -149,7 +155,7 @@ bool SharedImageFactory::CreateSharedImage(const Mailbox& mailbox,
     return false;
   }
 
-  GLenum target = use_buffer ? GL_TEXTURE_2D : format_info.target_for_scanout;
+  GLenum target = use_buffer ? format_info.target_for_scanout : GL_TEXTURE_2D;
 
   GLenum get_target = GL_TEXTURE_BINDING_2D;
   switch (target) {
@@ -237,7 +243,10 @@ bool SharedImageFactory::CreateSharedImage(const Mailbox& mailbox,
     gles2::Texture* texture = new gles2::Texture(service_id);
     texture->SetLightweightRef(memory_tracker_.get());
     texture->SetTarget(target, 1);
-    texture->SetLevelInfo(target, 0, internal_format, size.width(),
+    // TODO(piman): We pretend the texture was created in an ES2 context, so
+    // that it can be used in other ES2 contexts, and so we have to pass
+    // gl_format as the internal format. https://crbug.com/628064
+    texture->SetLevelInfo(target, 0, format_info.gl_format, size.width(),
                           size.height(), 1, 0, format_info.gl_format,
                           format_info.gl_type, cleared_rect);
     if (format_info.swizzle)
@@ -294,6 +303,52 @@ void SharedImageFactory::DestroyAllSharedImages(bool have_context) {
   mailboxes_.clear();
 }
 
+bool SharedImageFactory::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd,
+    int client_id,
+    uint64_t client_tracing_id) {
+  if (use_passthrough_)
+    return false;
+  for (const auto& mailbox : mailboxes_) {
+    auto* texture =
+        static_cast<gles2::Texture*>(mailbox_manager_->ConsumeTexture(mailbox));
+    DCHECK(texture);
+
+    // Unique name in the process.
+    std::string dump_name =
+        base::StringPrintf("gpu/shared-images/client_0x%" PRIX32 "/mailbox_%s",
+                           client_id, mailbox.ToDebugString().c_str());
+
+    base::trace_event::MemoryAllocatorDump* dump =
+        pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                    base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                    static_cast<uint64_t>(texture->estimated_size()));
+    // Add a mailbox guid which expresses shared ownership with the client
+    // process.
+    // This must match the client-side.
+    auto client_guid = GetSharedImageGUIDForTracing(mailbox);
+    pmd->CreateSharedGlobalAllocatorDump(client_guid);
+    pmd->AddOwnershipEdge(dump->guid(), client_guid);
+    // Add a |service_guid| which expresses shared ownership between the various
+    // GPU dumps.
+    auto service_guid =
+        gl::GetGLTextureServiceGUIDForTracing(texture->service_id());
+    pmd->CreateSharedGlobalAllocatorDump(service_guid);
+    // TODO(piman): coalesce constant with TextureManager::DumpTextureRef.
+    int importance = 2;  // This client always owns the ref.
+
+    pmd->AddOwnershipEdge(client_guid, service_guid, importance);
+
+    // Dump all sub-levels held by the texture. They will appear below the main
+    // gl/textures/client_X/mailbox_Y dump.
+    texture->DumpLevelMemory(pmd, client_tracing_id, dump_name);
+  }
+
+  return true;
+}
+
 SharedImageFactory::FormatInfo::FormatInfo() = default;
 SharedImageFactory::FormatInfo::~FormatInfo() = default;
 

gpu/command_buffer/service/shared_image_factory.h

@@ -54,6 +54,10 @@ class GPU_GLES2_EXPORT SharedImageFactory {
   bool DestroySharedImage(const Mailbox& mailbox);
   bool HasImages() const { return !mailboxes_.empty(); }
   void DestroyAllSharedImages(bool have_context);
+  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
+                    base::trace_event::ProcessMemoryDump* pmd,
+                    int client_id,
+                    uint64_t client_tracing_id);
 
  private:
   struct FormatInfo {

gpu/command_buffer/service/texture_manager.cc

@@ -3550,7 +3550,8 @@ void TextureManager::DumpTextureRef(base::trace_event::ProcessMemoryDump* pmd,
   int importance = 0;  // Default importance.
   // The link to the memory tracking |client_id| is given a higher importance
   // than other refs.
-  if (ref == ref->texture()->memory_tracking_ref_)
+  if (!ref->texture()->lightweight_ref_ &&
+      (ref == ref->texture()->memory_tracking_ref_))
     importance = 2;
 
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);

gpu/ipc/client/gpu_channel_host.cc

@@ -40,7 +40,11 @@ GpuChannelHost::GpuChannelHost(int channel_id,
       gpu_info_(gpu_info),
       gpu_feature_info_(gpu_feature_info),
       listener_(new Listener(std::move(handle), io_thread_),
-                base::OnTaskRunnerDeleter(io_thread_)) {
+                base::OnTaskRunnerDeleter(io_thread_)),
+      shared_image_interface_(
+          this,
+          static_cast<int32_t>(
+              GpuChannelReservedRoutes::kSharedImageInterface)) {
   next_image_id_.GetNext();
   for (int32_t i = 0;
        i <= static_cast<int32_t>(GpuChannelReservedRoutes::kMaxValue); ++i)

gpu/ipc/client/gpu_channel_host.h

@@ -24,6 +24,7 @@
 #include "gpu/config/gpu_feature_info.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/gpu_export.h"
+#include "gpu/ipc/client/shared_image_interface_proxy.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/message_filter.h"
 #include "ipc/message_router.h"
@@ -145,6 +146,10 @@ class GPU_EXPORT GpuChannelHost
   // otherwise ignored.
   void CrashGpuProcessForTesting();
 
+  SharedImageInterface* shared_image_interface() {
+    return &shared_image_interface_;
+  }
+
  protected:
   friend class base::RefCountedThreadSafe<GpuChannelHost>;
   ~GpuChannelHost() override;
@@ -246,6 +251,8 @@ class GPU_EXPORT GpuChannelHost
   // with base::Unretained(listener_).
   std::unique_ptr<Listener, base::OnTaskRunnerDeleter> listener_;
 
+  SharedImageInterfaceProxy shared_image_interface_;
+
   // Image IDs are allocated in sequence.
   base::AtomicSequenceNumber next_image_id_;
 

gpu/ipc/gl_in_process_context.cc

@@ -48,6 +48,10 @@ gles2::GLES2Implementation* GLInProcessContext::GetImplementation() {
   return gles2_implementation_.get();
 }
 
+SharedImageInterface* GLInProcessContext::GetSharedImageInterface() {
+  return command_buffer_->GetSharedImageInterface();
+}
+
 ContextResult GLInProcessContext::Initialize(
     scoped_refptr<CommandBufferTaskExecutor> task_executor,
     scoped_refptr<gl::GLSurface> surface,

gpu/ipc/gl_in_process_context.h

@@ -16,6 +16,7 @@
 #include "ui/gl/gl_surface.h"
 
 namespace gpu {
+class SharedImageInterface;
 class TransferBuffer;
 struct GpuFeatureInfo;
 struct SharedMemoryLimits;
@@ -58,6 +59,8 @@ class GL_IN_PROCESS_CONTEXT_EXPORT GLInProcessContext {
   // can be used without making it current.
   gles2::GLES2Implementation* GetImplementation();
 
+  SharedImageInterface* GetSharedImageInterface();
+
  private:
   // The destruction order is important, don't reorder these member variables.
   std::unique_ptr<InProcessCommandBuffer> command_buffer_;

gpu/ipc/service/shared_image_stub.cc

@@ -4,6 +4,9 @@
 
 #include "gpu/ipc/service/shared_image_stub.h"
 
+#include <inttypes.h>
+
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/scheduler.h"
 #include "gpu/command_buffer/service/shared_image_factory.h"
@@ -24,7 +27,10 @@ SharedImageStub::SharedImageStub(GpuChannel* channel, int32_t route_id)
               CommandBufferNamespace::GPU_IO,
               CommandBufferIdFromChannelAndRoute(channel->client_id(),
                                                  route_id),
-              sequence_)) {}
+              sequence_)) {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, "gpu::SharedImageStub", channel_->task_runner());
+}
 
 SharedImageStub::~SharedImageStub() {
   channel_->scheduler()->DestroySequence(sequence_);
@@ -33,6 +39,8 @@ SharedImageStub::~SharedImageStub() {
     bool have_context = MakeContextCurrentAndCreateFactory();
     factory_->DestroyAllSharedImages(have_context);
   }
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 bool SharedImageStub::OnMessageReceived(const IPC::Message& msg) {
@@ -86,7 +94,11 @@ bool SharedImageStub::MakeContextCurrentAndCreateFactory() {
     }
     DCHECK(context_state_);
     DCHECK(!context_state_->context_lost);
-    DCHECK(context_state_->context->IsCurrent(nullptr));
+    if (!context_state_->context->MakeCurrent(context_state_->surface.get())) {
+      LOG(ERROR) << "SharedImageStub: MakeCurrent failed";
+      OnError();
+      return false;
+    }
     gpu::GpuMemoryBufferFactory* gmb_factory =
         channel_manager->gpu_memory_buffer_factory();
     factory_ = std::make_unique<SharedImageFactory>(
@@ -136,4 +148,26 @@ uint64_t SharedImageStub::ContextGroupTracingId() const {
   return sync_point_client_state_->command_buffer_id().GetUnsafeValue();
 }
 
+bool SharedImageStub::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (!factory_)
+    return true;
+
+  if (args.level_of_detail ==
+      base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
+    std::string dump_name =
+        base::StringPrintf("gpu/gl/textures/client_0x%" PRIX32, ClientId());
+    base::trace_event::MemoryAllocatorDump* dump =
+        pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                    base::trace_event::MemoryAllocatorDump::kUnitsBytes, size_);
+
+    // Early out, no need for more detail in a BACKGROUND dump.
+    return true;
+  }
+
+  return factory_->OnMemoryDump(args, pmd, ClientId(), ClientTracingId());
+}
+
 }  // namespace gpu

gpu/ipc/service/shared_image_stub.h

@@ -5,6 +5,7 @@
 #ifndef GPU_IPC_SERVICE_SHARED_IMAGE_STUB_H_
 #define GPU_IPC_SERVICE_SHARED_IMAGE_STUB_H_
 
+#include "base/trace_event/memory_dump_provider.h"
 #include "components/viz/common/resources/resource_format.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
@@ -21,7 +22,9 @@ namespace raster {
 struct RasterDecoderContextState;
 }
 
-class SharedImageStub : public IPC::Listener, public gles2::MemoryTracker {
+class SharedImageStub : public IPC::Listener,
+                        public gles2::MemoryTracker,
+                        public base::trace_event::MemoryDumpProvider {
  public:
   SharedImageStub(GpuChannel* channel, int32_t route_id);
   ~SharedImageStub() override;
@@ -29,13 +32,17 @@ class SharedImageStub : public IPC::Listener, public gles2::MemoryTracker {
   // IPC::Listener implementation:
   bool OnMessageReceived(const IPC::Message& msg) override;
 
-  // gles2::MemoryTracker implementation;
+  // gles2::MemoryTracker implementation:
   void TrackMemoryAllocatedChange(uint64_t delta) override;
   uint64_t GetSize() const override;
   uint64_t ClientTracingId() const override;
   int ClientId() const override;
   uint64_t ContextGroupTracingId() const override;
 
+  // base::trace_event::MemoryDumpProvider implementation:
+  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
+                    base::trace_event::ProcessMemoryDump* pmd) override;
+
   SequenceId sequence() const { return sequence_; }
 
  private:

services/ws/public/cpp/gpu/context_provider_command_buffer.cc

@@ -396,6 +396,11 @@ class GrContext* ContextProviderCommandBuffer::GrContext() {
   return gr_context_->get();
 }
 
+gpu::SharedImageInterface*
+ContextProviderCommandBuffer::SharedImageInterface() {
+  return command_buffer_->channel()->shared_image_interface();
+}
+
 viz::ContextCacheController* ContextProviderCommandBuffer::CacheController() {
   CheckValidThreadOrLockAcquired();
   return cache_controller_.get();

services/ws/public/cpp/gpu/context_provider_command_buffer.h

@@ -90,6 +90,7 @@ class ContextProviderCommandBuffer
   gpu::raster::RasterInterface* RasterInterface() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
+  gpu::SharedImageInterface* SharedImageInterface() override;
   viz::ContextCacheController* CacheController() override;
   base::Lock* GetLock() override;
   const gpu::Capabilities& ContextCapabilities() const override;

ui/compositor/test/in_process_context_provider.cc

@@ -168,6 +168,10 @@ class GrContext* InProcessContextProvider::GrContext() {
   return gr_context_->get();
 }
 
+gpu::SharedImageInterface* InProcessContextProvider::SharedImageInterface() {
+  return context_->GetSharedImageInterface();
+}
+
 viz::ContextCacheController* InProcessContextProvider::CacheController() {
   CheckValidThreadOrLockAcquired();
   return cache_controller_.get();

ui/compositor/test/in_process_context_provider.h

@@ -60,6 +60,7 @@ class InProcessContextProvider
   gpu::raster::RasterInterface* RasterInterface() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
+  gpu::SharedImageInterface* SharedImageInterface() override;
   viz::ContextCacheController* CacheController() override;
   base::Lock* GetLock() override;
   void AddObserver(viz::ContextLostObserver* obs) override;