[tracing] Add a memory dump provider for DOM storage

content/browser/dom_storage/dom_storage_namespace.cc

 // Copyright 2013 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 "content/browser/dom_storage/dom_storage_namespace.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_database.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 
 namespace content {
 
 DOMStorageNamespace::DOMStorageNamespace(
     const base::FilePath& directory,
     DOMStorageTaskRunner* task_runner)
     : namespace_id_(kLocalStorageNamespaceId),
       directory_(directory),
       task_runner_(task_runner) {
 }
 
 DOMStorageNamespace::DOMStorageNamespace(
     int64_t namespace_id,
     const std::string& persistent_namespace_id,
     SessionStorageDatabase* session_storage_database,
     DOMStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
       persistent_namespace_id_(persistent_namespace_id),
       task_runner_(task_runner),
       session_storage_database_(session_storage_database) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
+  base::trace_event::MemoryDumpManager::GetInstance()
+      ->RegisterDumpProviderWithSequencedTaskRunner(
+          this, "DOMStorage", task_runner_->GetSequencedTaskRunner(
+                                  DOMStorageTaskRunner::PRIMARY_SEQUENCE),
+          base::trace_event::MemoryDumpProvider::Options());
 }
 
 DOMStorageNamespace::~DOMStorageNamespace() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 DOMStorageArea* DOMStorageNamespace::OpenStorageArea(const GURL& origin) {
   if (AreaHolder* holder = GetAreaHolder(origin)) {
     ++(holder->open_count_);
     return holder->area_.get();
   }
   DOMStorageArea* area;
   if (namespace_id_ == kLocalStorageNamespaceId) {
     area = new DOMStorageArea(origin, directory_, task_runner_.get());
@@ skipping 121 matching lines @@
 
 unsigned int DOMStorageNamespace::CountInMemoryAreas() const {
   unsigned int area_count = 0;
   for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {
     if (it->second.area_->IsLoadedInMemory())
       ++area_count;
   }
   return area_count;
 }
 
+bool DOMStorageNamespace::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  DCHECK(task_runner_->IsRunningOnPrimarySequence());
+  for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {

[Primiano Tucci (use gerrit), 2016/04/22 09:56:39]

or if you prefer just
for (const auto& area : areas_)

[ssid, 2016/04/22 23:28:16]

Done.

+    it->second.area_->OnMemoryDump(pmd);
+  }
+  return true;
+}
+
 DOMStorageNamespace::AreaHolder*
 DOMStorageNamespace::GetAreaHolder(const GURL& origin) {
   AreaMap::iterator found = areas_.find(origin);
   if (found == areas_.end())
     return NULL;
   return &(found->second);
 }
 
 // AreaHolder
 
 DOMStorageNamespace::AreaHolder::AreaHolder()
     : open_count_(0) {
 }
 
 DOMStorageNamespace::AreaHolder::AreaHolder(
     DOMStorageArea* area, int count)
     : area_(area), open_count_(count) {
 }
 
 DOMStorageNamespace::AreaHolder::AreaHolder(const AreaHolder& other) = default;
 
 DOMStorageNamespace::AreaHolder::~AreaHolder() {
 }
 
 }  // namespace content