Add BACKGROUND dump mode to various GPU/CC MemoryDumpProviders

cc/tiles/gpu_image_decode_controller.cc

 // Copyright 2016 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/gpu_image_decode_controller.h"
 
 #include <inttypes.h>
 
 #include "base/debug/alias.h"
 #include "base/memory/discardable_memory_allocator.h"
@@ skipping 530 matching lines @@
     DeletePendingImages();
   } else {
     base::AutoLock lock(lock_);
     cached_bytes_limit_ = normal_max_gpu_image_bytes_;
   }
 }
 
 bool GpuImageDecodeController::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
+  using base::trace_event::MemoryAllocatorDump;
+  using base::trace_event::MemoryAllocatorDumpGuid;
+  using base::trace_event::MemoryDumpLevelOfDetail;
+
   TRACE_EVENT0("disabled-by-default-cc.debug",

[ssid, 2016/10/07 00:07:21]

Shouldn't this be using TRACE_DISABLED_BY_DEFAULT macro?

[ericrk, 2016/10/13 23:58:13]

sounds good - I put up a CL to update all of cc. crrev.com/2403523002

                "GpuImageDecodeController::OnMemoryDump");
-  for (const auto& image_pair : persistent_cache_) {
-    const ImageData* image_data = image_pair.second.get();
-    const uint32_t image_id = image_pair.first;
 
-    // If we have discardable decoded data, dump this here.
-    if (image_data->decode.data()) {
-      std::string discardable_dump_name = base::StringPrintf(
-          "cc/image_memory/controller_0x%" PRIXPTR "/discardable/image_%d",
-          reinterpret_cast<uintptr_t>(this), image_id);
-      base::trace_event::MemoryAllocatorDump* dump =
-          image_data->decode.data()->CreateMemoryAllocatorDump(
-              discardable_dump_name.c_str(), pmd);
-      // If our image is locked, dump the "locked_size" as an additional column.
-      // This lets us see the amount of discardable which is contributing to
-      // memory pressure.
-      if (image_data->decode.is_locked()) {
-        dump->AddScalar("locked_size",
-                        base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                        image_data->size);
+  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(MemoryAllocatorDump::kNameSize,
+                    MemoryAllocatorDump::kUnitsBytes, bytes_used_);

[ssid, 2016/10/07 00:07:21]

if you do return true; here and remove else, it reduces indent.

[ericrk, 2016/10/13 23:58:13]

Done.

+  } else {
+    for (const auto& image_pair : persistent_cache_) {
+      const ImageData* image_data = image_pair.second.get();
+      const uint32_t image_id = image_pair.first;
+
+      // If we have discardable decoded data, dump this here.
+      if (image_data->decode.data()) {
+        std::string discardable_dump_name = base::StringPrintf(
+            "cc/image_memory/controller_0x%" PRIXPTR "/discardable/image_%d",
+            reinterpret_cast<uintptr_t>(this), image_id);
+        MemoryAllocatorDump* dump =
+            image_data->decode.data()->CreateMemoryAllocatorDump(
+                discardable_dump_name.c_str(), pmd);
+        // If our image is locked, dump the "locked_size" as an additional
+        // column.
+        // This lets us see the amount of discardable which is contributing to
+        // memory pressure.
+        if (image_data->decode.is_locked()) {
+          dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
+                          image_data->size);
+        }
+      }
+
+      // If we have an uploaded image (that is actually on the GPU, not just a
+      // CPU
+      // wrapper), upload it here.
+      if (image_data->upload.image() &&
+          image_data->mode == DecodedDataMode::GPU) {
+        std::string gpu_dump_name = base::StringPrintf(
+            "cc/image_memory/controller_0x%" PRIXPTR "/gpu/image_%d",
+            reinterpret_cast<uintptr_t>(this), image_id);
+        MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(gpu_dump_name);
+        dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                        MemoryAllocatorDump::kUnitsBytes, image_data->size);
+
+        // Create a global shred GUID to associate this data with its GPU
+        // process
+        // counterpart.
+        GLuint gl_id = skia::GrBackendObjectToGrGLTextureInfo(
+                           image_data->upload.image()->getTextureHandle(
+                               false /* flushPendingGrContextIO */))
+                           ->fID;
+        MemoryAllocatorDumpGuid guid = gl::GetGLTextureClientGUIDForTracing(
+            context_->ContextSupport()->ShareGroupTracingGUID(), gl_id);
+
+        // kImportance is somewhat arbitrary - we chose 3 to be higher than the
+        // value used in the GPU process (1), and Skia (2), causing us to appear
+        // as the owner in memory traces.
+        const int kImportance = 3;
+        pmd->CreateSharedGlobalAllocatorDump(guid);
+        pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
       }
     }
-
-    // If we have an uploaded image (that is actually on the GPU, not just a CPU
-    // wrapper), upload it here.
-    if (image_data->upload.image() &&
-        image_data->mode == DecodedDataMode::GPU) {
-      std::string gpu_dump_name = base::StringPrintf(
-          "cc/image_memory/controller_0x%" PRIXPTR "/gpu/image_%d",
-          reinterpret_cast<uintptr_t>(this), image_id);
-      base::trace_event::MemoryAllocatorDump* dump =
-          pmd->CreateAllocatorDump(gpu_dump_name);
-      dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
-                      base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                      image_data->size);
-
-      // Create a global shred GUID to associate this data with its GPU process
-      // counterpart.
-      GLuint gl_id = skia::GrBackendObjectToGrGLTextureInfo(
-                         image_data->upload.image()->getTextureHandle(
-                             false /* flushPendingGrContextIO */))
-                         ->fID;
-      base::trace_event::MemoryAllocatorDumpGuid guid =
-          gl::GetGLTextureClientGUIDForTracing(
-              context_->ContextSupport()->ShareGroupTracingGUID(), gl_id);
-
-      // kImportance is somewhat arbitrary - we chose 3 to be higher than the
-      // value used in the GPU process (1), and Skia (2), causing us to appear
-      // as the owner in memory traces.
-      const int kImportance = 3;
-      pmd->CreateSharedGlobalAllocatorDump(guid);
-      pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
-    }
   }
-
   return true;
 }
 
 void GpuImageDecodeController::DecodeImage(const DrawImage& draw_image) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
                "GpuImageDecodeController::DecodeImage");
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(!image_data->is_at_raster);
@@ skipping 600 matching lines @@
       EnsureCapacity(0);
       break;
     }
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc