[tracing] Add WebCache memory usage in Blink to chrome://tracing

components/web_cache/browser/web_cache_manager.cc

 // Copyright (c) 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 "components/web_cache/browser/web_cache_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/format_macros.h"
 #include "base/location.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "base/trace_event/memory_allocator_dump.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "components/web_cache/common/web_cache_messages.h"
+#include "content/common/child_process_host_impl.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 
 using base::Time;
 using base::TimeDelta;
 using blink::WebCache;
 
 namespace web_cache {
 
@@ skipping 28 matching lines @@
   return Singleton<WebCacheManager>::get();
 }
 
 WebCacheManager::WebCacheManager()
     : global_size_limit_(GetDefaultGlobalSizeLimit()),
       weak_factory_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this);
 }
 
 WebCacheManager::~WebCacheManager() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 void WebCacheManager::Add(int renderer_id) {
   DCHECK(inactive_renderers_.count(renderer_id) == 0);
 
   // It is tempting to make the following DCHECK here, but it fails when a new
   // tab is created as we observe activity from that tab because the
   // RenderProcessHost is recreated and adds itself.
   //
   //   DCHECK(active_renderers_.count(renderer_id) == 0);
@@ skipping 88 matching lines @@
           content::Source<content::RenderProcessHost>(source).ptr();
       Remove(process->GetID());
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
+bool WebCacheManager::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  std::set<int>::const_iterator active_renderers_iter =
+      active_renderers_.begin();
+  while (active_renderers_iter != active_renderers_.end()) {
+    DumpUsageStats(*active_renderers_iter, pmd);
+    ++active_renderers_iter;
+  }
+
+  std::set<int>::const_iterator inactive_renderers_iter =
+      inactive_renderers_.begin();
+  while (inactive_renderers_iter != inactive_renderers_.end()) {
+    DumpUsageStats(*inactive_renderers_iter, pmd);
+    ++inactive_renderers_iter;
+  }
+
+  return true;
+}
+
+void WebCacheManager::DumpUsageStats(
+    int renderer_id,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  StatsMap::iterator stats = stats_.find(renderer_id);
+  if (stats == stats_.end())
+    return;
+  uint64 child_tracing_id =
+      content::ChildProcessHostImpl::ChildProcessUniqueIdToTracingProcessId(

[ssid, 2015/08/11 17:40:01]

This causes a DEPS addition to component which is not really desired. But, I
couldn't find other choices! Maybe send the function as callback to initialize
this component?

+          renderer_id);
+  std::string dump_name = base::StringPrintf(
+      "web_cache/renderer_%lu", static_cast<unsigned long>(child_tracing_id));
+  base::trace_event::MemoryAllocatorDump* allocator_dump =
+      pmd->CreateAllocatorDump(dump_name);
+  allocator_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                            base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                            stats->second.liveSize + stats->second.deadSize);
+
+  allocator_dump->AddScalar("live_size",
+                            base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                            stats->second.liveSize);
+  allocator_dump->AddScalar("dead_size",
+                            base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                            stats->second.deadSize);
+
+  auto shared_guid = base::trace_event::MemoryAllocatorDumpGuid(
+      base::StringPrintf("web-cache-x-process/%" PRIx64, child_tracing_id));
+  pmd->CreateSharedGlobalAllocatorDump(shared_guid);
+  pmd->AddOwnershipEdge(allocator_dump->guid(), shared_guid);
+}
+
 // static
 size_t WebCacheManager::GetDefaultGlobalSizeLimit() {
   return GetDefaultCacheSize();
 }
 
 void WebCacheManager::GatherStats(const std::set<int>& renderers,
                                   WebCache::UsageStats* stats) {
   DCHECK(stats);
 
   memset(stats, 0, sizeof(WebCache::UsageStats));
@@ skipping 244 matching lines @@
       inactive_renderers_.insert(*iter);
       active_renderers_.erase(*iter);
       iter = active_renderers_.begin();
       continue;
     }
     ++iter;
   }
 }
 
 }  // namespace web_cache