Add BACKGROUND dump mode to various GPU/CC MemoryDumpProviders

cc/raster/staging_buffer_pool.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/raster/staging_buffer_pool.h"
 
 #include <memory>
 
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/base/container_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/gpu_memory_buffer_tracing.h"
 
+using base::trace_event::MemoryAllocatorDump;
+using base::trace_event::MemoryAllocatorDumpGuid;
+using base::trace_event::MemoryDumpLevelOfDetail;
+
 namespace cc {
 namespace {
 
 // Delay between checking for query result to be available.
 const int kCheckForQueryResultAvailableTickRateMs = 1;
 
 // Number of attempts to allow before we perform a check that will wait for
 // query to complete.
 const int kMaxCheckForQueryResultAvailableAttempts = 256;
 
@@ skipping 59 matching lines @@
 
 void StagingBuffer::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                  ResourceFormat format,
                                  bool in_free_list) const {
   if (!gpu_memory_buffer)
     return;
 
   gfx::GpuMemoryBufferId buffer_id = gpu_memory_buffer->GetId();
   std::string buffer_dump_name =
       base::StringPrintf("cc/one_copy/staging_memory/buffer_%d", buffer_id.id);
-  base::trace_event::MemoryAllocatorDump* buffer_dump =
-      pmd->CreateAllocatorDump(buffer_dump_name);
+  MemoryAllocatorDump* buffer_dump = pmd->CreateAllocatorDump(buffer_dump_name);
 
   uint64_t buffer_size_in_bytes =
       ResourceUtil::UncheckedSizeInBytes<uint64_t>(size, format);
-  buffer_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
-                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+  buffer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                         MemoryAllocatorDump::kUnitsBytes,
                          buffer_size_in_bytes);
-  buffer_dump->AddScalar("free_size",
-                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+  buffer_dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes,
                          in_free_list ? buffer_size_in_bytes : 0);
 
   // Emit an ownership edge towards a global allocator dump node.
   const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
-  base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid =
+  MemoryAllocatorDumpGuid shared_buffer_guid =
       gfx::GetGpuMemoryBufferGUIDForTracing(tracing_process_id, buffer_id);
   pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
 
   // By creating an edge with a higher |importance| (w.r.t. browser-side dumps)
   // the tracing UI will account the effective size of the buffer to the child.
   const int kImportance = 2;
   pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
 }
 
 StagingBufferPool::StagingBufferPool(base::SequencedTaskRunner* task_runner,
@@ skipping 54 matching lines @@
   busy_buffers_.push_back(std::move(staging_buffer));
 
   ScheduleReduceMemoryUsage();
 }
 
 bool StagingBufferPool::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
-  for (const auto* buffer : buffers_) {
-    auto in_free_buffers =
-        std::find_if(free_buffers_.begin(), free_buffers_.end(),
-                     [buffer](const std::unique_ptr<StagingBuffer>& b) {
-                       return b.get() == buffer;
-                     });
-    buffer->OnMemoryDump(pmd, buffer->format,
-                         in_free_buffers != free_buffers_.end());
+  if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
+    std::string dump_name("cc/one_copy/staging_memory");
+    MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                    MemoryAllocatorDump::kUnitsBytes,
+                    staging_buffer_usage_in_bytes_);
+  } else {
+    for (const auto* buffer : buffers_) {
+      auto in_free_buffers =
+          std::find_if(free_buffers_.begin(), free_buffers_.end(),
+                       [buffer](const std::unique_ptr<StagingBuffer>& b) {
+                         return b.get() == buffer;
+                       });
+      buffer->OnMemoryDump(pmd, buffer->format,
+                           in_free_buffers != free_buffers_.end());
+    }
   }
-
   return true;
 }
 
 void StagingBufferPool::AddStagingBuffer(const StagingBuffer* staging_buffer,
                                          ResourceFormat format) {
   lock_.AssertAcquired();
 
   DCHECK(buffers_.find(staging_buffer) == buffers_.end());
   buffers_.insert(staging_buffer);
   int buffer_usage_in_bytes =
@@ skipping 227 matching lines @@
       // Release all buffers, regardless of how recently they were used.
       ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
     } break;
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc