Emit CanvasResourceProvider.SkSurface memory usage to UKM.

Added CanvasMemoryDumpProvider, made CanvasResourceProvider the provider's client, and implemented OnMemoryDump.
Since SkSurface has no interface to provide its memory usage, use SkImageInfo::computeBytesSize when allocating memory(not gpu) SkSurface.

Change-Id: I51cc40ab472403bb4a1e22fcae3fc6944a5f5a37
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2143178
Commit-Queue: Takashi Sakamoto <tasak@google.com>
Reviewed-by: Brian White <bcwhite@chromium.org>
Reviewed-by: Steven Holte <holte@chromium.org>
Reviewed-by: ssid <ssid@chromium.org>
Reviewed-by: Erik Chen <erikchen@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#771577}

base/trace_event/memory_infra_background_allowlist.cc

@@ -26,6 +26,7 @@ const char* const kDumpProviderAllowlist[] = {
     "BlinkGC",
     "BlinkObjectCounters",
     "BlobStorageContext",
+    "Canvas",
     "ClientDiscardableSharedMemoryManager",
     "DevTools",
     "DiscardableSharedMemoryManager",
@@ -95,6 +96,8 @@ const char* const kAllocatorDumpNameAllowlist[] = {
     "blink_objects/WorkerGlobalScope",
     "blink_objects/UACSSResource",
     "blink_objects/ResourceFetcher",
+    "canvas/ResourceProvider/SkSurface",
+    "canvas/ResourceProvider/SkSurface/0x?",
     "components/download/controller_0x?",
     "devtools/file_watcher_0x?",
     "discardable",

chrome/browser/metrics/process_memory_metrics_emitter.cc

@@ -161,6 +161,9 @@ const Metric kAllocatorDumpNamesForMetrics[] = {
     {"blink_objects/ResourceFetcher", "NumberOfResourceFetcher",
      MetricSize::kTiny, MemoryAllocatorDump::kNameObjectCount,
      EmitTo::kSizeInUmaOnly, nullptr},
+    {"canvas/ResourceProvider/SkSurface", "CanvasResourceProvider.SkSurface",
+     MetricSize::kSmall, kSize, EmitTo::kCountsInUkmOnly,
+     &Memory_Experimental::SetCanvasResourceProvider_SkSurface},
     {"components/download", "DownloadService", MetricSize::kSmall,
      kEffectiveSize, EmitTo::kSizeInUkmAndUma,
      &Memory_Experimental::SetDownloadService},

third_party/blink/renderer/platform/exported/platform.cc

@@ -48,6 +48,7 @@
 #include "third_party/blink/renderer/platform/fonts/font_cache_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/heap/blink_gc_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/heap/gc_task_runner.h"
+#include "third_party/blink/renderer/platform/instrumentation/canvas_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/instrumentation/instance_counters_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/instrumentation/memory_pressure_listener.h"
 #include "third_party/blink/renderer/platform/instrumentation/partition_alloc_memory_dump_provider.h"
@@ -237,6 +238,9 @@ void Platform::InitializeMainThreadCommon(Platform* platform,
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       ParkableStringManagerDumpProvider::Instance(), "ParkableStrings",
       base::ThreadTaskRunnerHandle::Get());
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      CanvasMemoryDumpProvider::Instance(), "Canvas",
+      base::ThreadTaskRunnerHandle::Get());
 
   RendererResourceCoordinator::MaybeInitialize();
   // Use a delayed idle task as this is low priority work that should stop when

third_party/blink/renderer/platform/graphics/canvas_resource_provider.cc

@@ -7,6 +7,8 @@
 #include "base/bind.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/stl_util.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "build/build_config.h"
 #include "cc/paint/decode_stashing_image_provider.h"
 #include "cc/paint/display_item_list.h"
@@ -24,6 +26,7 @@
 #include "third_party/blink/renderer/platform/graphics/gpu/shared_gpu_context.h"
 #include "third_party/blink/renderer/platform/graphics/memory_managed_paint_recorder.h"
 #include "third_party/blink/renderer/platform/graphics/unaccelerated_static_bitmap_image.h"
+#include "third_party/blink/renderer/platform/instrumentation/canvas_memory_dump_provider.h"
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
@@ -1179,6 +1182,7 @@ CanvasResourceProvider::CanvasResourceProvider(
       identifiability_paint_op_digest_(size_) {
   if (context_provider_wrapper_)
     context_provider_wrapper_->AddObserver(this);
+  CanvasMemoryDumpProvider::Instance()->RegisterClient(this);
 }
 
 CanvasResourceProvider::~CanvasResourceProvider() {
@@ -1186,6 +1190,7 @@ CanvasResourceProvider::~CanvasResourceProvider() {
                              max_inflight_resources_, 20);
   if (context_provider_wrapper_)
     context_provider_wrapper_->RemoveObserver(this);
+  CanvasMemoryDumpProvider::Instance()->UnregisterClient(this);
 }
 
 SkSurface* CanvasResourceProvider::GetSkSurface() const {
@@ -1522,4 +1527,41 @@ void CanvasResourceProvider::TearDownSkSurface() {
   surface_ = nullptr;
 }
 
+size_t CanvasResourceProvider::ComputeSurfaceSize() const {
+  if (!surface_)
+    return 0;
+
+  SkImageInfo info = surface_->imageInfo();
+  return info.computeByteSize(info.minRowBytes());
+}
+
+void CanvasResourceProvider::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (!surface_)
+    return;
+
+  std::string dump_name =
+      base::StringPrintf("canvas/ResourceProvider/SkSurface/0x%" PRIXPTR,
+                         reinterpret_cast<uintptr_t>(surface_.get()));
+  auto* dump = pmd->CreateAllocatorDump(dump_name);
+
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  ComputeSurfaceSize());
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameObjectCount,
+                  base::trace_event::MemoryAllocatorDump::kUnitsObjects, 1);
+
+  // SkiaMemoryDumpProvider reports only sk_glyph_cache and sk_resource_cache.
+  // So the SkSurface is suballocation of malloc, not SkiaDumpProvider.
+  if (const char* system_allocator_name =
+          base::trace_event::MemoryDumpManager::GetInstance()
+              ->system_allocator_pool_name()) {
+    pmd->AddSuballocation(dump->guid(), system_allocator_name);
+  }
+}
+
+size_t CanvasResourceProvider::GetSize() const {
+  return ComputeSurfaceSize();
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/graphics/canvas_resource_provider.h

@@ -12,6 +12,7 @@
 #include "third_party/blink/renderer/platform/graphics/identifiability_paint_op_digest.h"
 #include "third_party/blink/renderer/platform/graphics/image_orientation.h"
 #include "third_party/blink/renderer/platform/graphics/paint/paint_recorder.h"
+#include "third_party/blink/renderer/platform/instrumentation/canvas_memory_dump_provider.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 class GrContext;
@@ -56,7 +57,8 @@ class WebGraphicsContext3DProviderWrapper;
 //   3) Call Snapshot() to acquire a bitmap with the rendered image in it.
 
 class PLATFORM_EXPORT CanvasResourceProvider
-    : public WebGraphicsContext3DProviderWrapper::DestructionObserver {
+    : public WebGraphicsContext3DProviderWrapper::DestructionObserver,
+      public CanvasMemoryDumpClient {
  public:
   // These values are persisted to logs. Entries should not be renumbered and
   // numeric values should never be reused.
@@ -302,6 +304,10 @@ class PLATFORM_EXPORT CanvasResourceProvider
   // provider.
   virtual void WillDraw() {}
 
+  size_t ComputeSurfaceSize() const;
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump*) override;
+  size_t GetSize() const override;
+
   cc::ImageDecodeCache* ImageDecodeCacheRGBA8();
   cc::ImageDecodeCache* ImageDecodeCacheF16();
   void EnsureSkiaCanvas();

third_party/blink/renderer/platform/instrumentation/BUILD.gn

@@ -13,6 +13,8 @@ blink_platform_sources("instrumentation") {
   ]
 
   sources = [
+    "canvas_memory_dump_provider.cc",
+    "canvas_memory_dump_provider.h",
     "histogram.cc",
     "histogram.h",
     "instance_counters.cc",

third_party/blink/renderer/platform/instrumentation/canvas_memory_dump_provider.cc

+// Copyright 2020 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 "third_party/blink/renderer/platform/instrumentation/canvas_memory_dump_provider.h"
+
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
+#include "third_party/blink/renderer/platform/instrumentation/instance_counters.h"
+#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
+
+namespace blink {
+
+CanvasMemoryDumpProvider* CanvasMemoryDumpProvider::Instance() {
+  DEFINE_STATIC_LOCAL(CanvasMemoryDumpProvider, instance, ());
+  return &instance;
+}
+
+bool CanvasMemoryDumpProvider::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* memory_dump) {
+  if (args.level_of_detail ==
+      base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
+    for (auto* it : clients_)
+      it->OnMemoryDump(memory_dump);
+    return true;
+  }
+
+  size_t total_size = 0;
+  for (auto* it : clients_)
+    total_size += it->GetSize();
+
+  auto* dump =
+      memory_dump->CreateAllocatorDump("canvas/ResourceProvider/SkSurface");
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  total_size);
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameObjectCount,
+                  base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+                  clients_.size());
+
+  // SkiaMemoryDumpProvider reports only sk_glyph_cache and sk_resource_cache.
+  // So the SkSurface is suballocation of malloc, not SkiaDumpProvider.
+  if (const char* system_allocator_name =
+          base::trace_event::MemoryDumpManager::GetInstance()
+              ->system_allocator_pool_name()) {
+    memory_dump->AddSuballocation(dump->guid(), system_allocator_name);
+  }
+  return true;
+}
+
+void CanvasMemoryDumpProvider::RegisterClient(CanvasMemoryDumpClient* client) {
+  clients_.insert(client);
+}
+
+void CanvasMemoryDumpProvider::UnregisterClient(
+    CanvasMemoryDumpClient* client) {
+  DCHECK(clients_.Contains(client));
+  clients_.erase(client);
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/instrumentation/canvas_memory_dump_provider.h

+// Copyright 2020 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 THIRD_PARTY_BLINK_RENDERER_PLATFORM_INSTRUMENTATION_CANVAS_MEMORY_DUMP_PROVIDER_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_INSTRUMENTATION_CANVAS_MEMORY_DUMP_PROVIDER_H_
+
+#include "base/macros.h"
+#include "base/trace_event/memory_dump_provider.h"
+#include "third_party/blink/renderer/platform/platform_export.h"
+#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
+#include "third_party/blink/renderer/platform/wtf/hash_set.h"
+
+namespace blink {
+
+class PLATFORM_EXPORT CanvasMemoryDumpClient {
+ public:
+  virtual void OnMemoryDump(base::trace_event::ProcessMemoryDump*) = 0;
+  virtual size_t GetSize() const = 0;
+
+  ~CanvasMemoryDumpClient() = default;
+};
+
+class PLATFORM_EXPORT CanvasMemoryDumpProvider final
+    : public base::trace_event::MemoryDumpProvider {
+  USING_FAST_MALLOC(CanvasMemoryDumpProvider);
+
+ public:
+  static CanvasMemoryDumpProvider* Instance();
+  ~CanvasMemoryDumpProvider() override = default;
+
+  // MemoryDumpProvider implementation.
+  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs&,
+                    base::trace_event::ProcessMemoryDump*) override;
+
+  void RegisterClient(CanvasMemoryDumpClient*);
+  void UnregisterClient(CanvasMemoryDumpClient*);
+
+ private:
+  CanvasMemoryDumpProvider() = default;
+
+  WTF::HashSet<CanvasMemoryDumpClient*> clients_;
+
+  DISALLOW_COPY_AND_ASSIGN(CanvasMemoryDumpProvider);
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_INSTRUMENTATION_CANVAS_MEMORY_DUMP_PROVIDER_H_

tools/metrics/ukm/ukm.xml

@@ -6124,6 +6124,11 @@ be describing additional metrics about the same event.
       Measure of memory consumed by live allocations made from Oilpan.
     </summary>
   </metric>
+  <metric name="CanvasResourceProvider.SkSurface">
+    <summary>
+      Measure of memory used due to CanvasResourceProvider's SkSurface.
+    </summary>
+  </metric>
   <metric name="CommandBuffer">
     <summary>
       Measure of memory consumed by GL command buffer.