Add BACKGROUND dump mode to various GPU/CC MemoryDumpProviders

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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 "cc/tiles/software_image_decode_controller.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 10 matching lines @@
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/raster/tile_task.h"
 #include "cc/resources/resource_format_utils.h"
 #include "cc/tiles/mipmap_util.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkPixmap.h"
 #include "ui/gfx/skia_util.h"
 
+using base::trace_event::MemoryAllocatorDump;
+using base::trace_event::MemoryDumpLevelOfDetail;
+
 namespace cc {
 namespace {
 
 // The largest single high quality image to try and process. Images above this
 // size will drop down to medium quality.
 const size_t kMaxHighQualityImageSizeBytes = 64 * 1024 * 1024;
 
 // The number of entries to keep around in the cache. This limit can be breached
 // if more items are locked. That is, locked items ignore this limit.
 // Depending on the memory state of the system, we limit the amount of items
@@ skipping 729 matching lines @@
 void SoftwareImageDecodeController::RemovePendingTask(const ImageKey& key) {
   base::AutoLock lock(lock_);
   pending_image_tasks_.erase(key);
 }
 
 bool SoftwareImageDecodeController::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
-  // Dump each of our caches.
-  DumpImageMemoryForCache(decoded_images_, "cached", pmd);
-  DumpImageMemoryForCache(at_raster_decoded_images_, "at_raster", pmd);
+  if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
+    std::string dump_name =
+        base::StringPrintf("cc/image_memory/controller_0x%" PRIXPTR,
+                           reinterpret_cast<uintptr_t>(this));
+    MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
+                    locked_images_budget_.GetCurrentUsageSafe());
+  } else {
+    // Dump each of our caches.
+    DumpImageMemoryForCache(decoded_images_, "cached", pmd);
+    DumpImageMemoryForCache(at_raster_decoded_images_, "at_raster", pmd);
+  }
 
   // Memory dump can't fail, always return true.
   return true;
 }
 
 void SoftwareImageDecodeController::DumpImageMemoryForCache(
     const ImageMRUCache& cache,
     const char* cache_name,
     base::trace_event::ProcessMemoryDump* pmd) const {
   lock_.AssertAcquired();
 
   for (const auto& image_pair : cache) {
-    std::string dump_name = base::StringPrintf(
-        "cc/image_memory/controller_0x%" PRIXPTR "/%s/image_%" PRIu64 "_id_%d",
-        reinterpret_cast<uintptr_t>(this), cache_name,
-        image_pair.second->tracing_id(), image_pair.first.image_id());
-    base::trace_event::MemoryAllocatorDump* dump =
-        image_pair.second->memory()->CreateMemoryAllocatorDump(
-            dump_name.c_str(), pmd);
-    DCHECK(dump);
     if (image_pair.second->is_locked()) {
-      dump->AddScalar("locked_size",
-                      base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+      std::string dump_name = base::StringPrintf(
+          "cc/image_memory/controller_0x%" PRIXPTR "/%s/image_%" PRIu64
+          "_id_%d",
+          reinterpret_cast<uintptr_t>(this), cache_name,
+          image_pair.second->tracing_id(), image_pair.first.image_id());
+      MemoryAllocatorDump* dump =
+          image_pair.second->memory()->CreateMemoryAllocatorDump(
+              dump_name.c_str(), pmd);
+      DCHECK(dump);
+      dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
                       image_pair.first.locked_bytes());
     }
   }
 }
 
 void SoftwareImageDecodeController::SanityCheckState(int line,
                                                      bool lock_acquired) {
 #if DCHECK_IS_ON()
   if (!lock_acquired) {
     base::AutoLock lock(lock_);
@@ skipping 293 matching lines @@
         break;
       case base::MemoryState::UNKNOWN:
         NOTREACHED();
         return;
     }
   }
   ReduceCacheUsage();
 }
 
 }  // namespace cc