Add BACKGROUND dump mode to various GPU/CC MemoryDumpProviders

cc/resources/resource_pool.cc

 // Copyright 2012 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/resources/resource_pool.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/memory/memory_coordinator_client_registry.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/resources/resource_provider.h"
 #include "cc/resources/resource_util.h"
 #include "cc/resources/scoped_resource.h"
 
+using base::trace_event::MemoryAllocatorDump;
+using base::trace_event::MemoryDumpLevelOfDetail;
+
 namespace cc {
 base::TimeDelta ResourcePool::kDefaultExpirationDelay =
     base::TimeDelta::FromSeconds(1);
 
 void ResourcePool::PoolResource::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd,
     const ResourceProvider* resource_provider,
     bool is_free) const {
   // Resource IDs are not process-unique, so log with the ResourceProvider's
   // unique id.
   std::string parent_node =
       base::StringPrintf("cc/resource_memory/provider_%d/resource_%d",
                          resource_provider->tracing_id(), id());
 
   std::string dump_name =
       base::StringPrintf("cc/tile_memory/provider_%d/resource_%d",
                          resource_provider->tracing_id(), id());
-  base::trace_event::MemoryAllocatorDump* dump =
-      pmd->CreateAllocatorDump(dump_name);
-
+  MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
   pmd->AddSuballocation(dump->guid(), parent_node);
 
   uint64_t total_bytes =
       ResourceUtil::UncheckedSizeInBytesAligned<size_t>(size(), format());
-  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
-                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                  total_bytes);
+  dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                  MemoryAllocatorDump::kUnitsBytes, total_bytes);
 
   if (is_free) {
-    dump->AddScalar("free_size",
-                    base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                    total_bytes);
+    dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes, total_bytes);
   }
 }
 
 ResourcePool::ResourcePool(ResourceProvider* resource_provider,
                            base::SingleThreadTaskRunner* task_runner,
                            bool use_gpu_memory_buffers,
                            const base::TimeDelta& expiration_delay)
     : resource_provider_(resource_provider),
       use_gpu_memory_buffers_(use_gpu_memory_buffers),
       max_memory_usage_bytes_(0),
@@ skipping 375 matching lines @@
     return unused_resources_.back()->last_usage();
   }
 
   // This is only called when we have at least one evictable resource.
   DCHECK(!busy_resources_.empty());
   return busy_resources_.back()->last_usage();
 }
 
 bool ResourcePool::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                                 base::trace_event::ProcessMemoryDump* pmd) {
-  for (const auto& resource : unused_resources_) {
-    resource->OnMemoryDump(pmd, resource_provider_, true /* is_free */);
-  }
-  for (const auto& resource : busy_resources_) {
-    resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
-  }
-  for (const auto& entry : in_use_resources_) {
-    entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
+  if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
+    std::string dump_name = base::StringPrintf(
+        "cc/tile_memory/provider_%d", resource_provider_->tracing_id());
+    MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar(MemoryAllocatorDump::kNameSize,
+                    MemoryAllocatorDump::kUnitsBytes,
+                    total_memory_usage_bytes_);
+  } else {
+    for (const auto& resource : unused_resources_) {
+      resource->OnMemoryDump(pmd, resource_provider_, true /* is_free */);
+    }
+    for (const auto& resource : busy_resources_) {
+      resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
+    }
+    for (const auto& entry : in_use_resources_) {
+      entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
+    }
   }
   return true;
 }
 
 void ResourcePool::OnMemoryStateChange(base::MemoryState state) {
   switch (state) {
     case base::MemoryState::NORMAL:
       // TODO(tasak): go back to normal state.
       break;
     case base::MemoryState::THROTTLED:
       // TODO(tasak): make the limits of this component's caches smaller to
       // save memory usage.
       break;
     case base::MemoryState::SUSPENDED:
       // Release all resources, regardless of how recently they were used.
       EvictResourcesNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
       break;
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc