[tracing] Add a memory dump provider for DOM storage

content/browser/dom_storage/dom_storage_context_impl.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 "content/browser/dom_storage/dom_storage_context_impl.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/time/time.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_database.h"
 #include "content/browser/dom_storage/dom_storage_namespace.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"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
 #include "storage/browser/quota/special_storage_policy.h"
@@ skipping 16 matching lines @@
       task_runner_(task_runner),
       session_id_offset_(abs((g_session_id_offset_sequence++ % 10)) * 1000),
       is_shutdown_(false),
       force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
       scavenging_started_(false) {
   // AtomicSequenceNum starts at 0 but we want to start session
   // namespace ids at one since zero is reserved for the
   // kLocalStorageNamespaceId.
   session_id_sequence_.GetNext();
+
+  // Tests may run without task runners.
+  if (task_runner_) {
+    // Registering dump provider is safe even outside the task runner.
+    base::trace_event::MemoryDumpManager::GetInstance()
+        ->RegisterDumpProviderWithSequencedTaskRunner(
+            this, "DOMStorage", task_runner_->GetSequencedTaskRunner(
+                                    DOMStorageTaskRunner::PRIMARY_SEQUENCE),
+            base::trace_event::MemoryDumpProvider::Options());
+  }
 }
 
 DOMStorageContextImpl::~DOMStorageContextImpl() {
+  DCHECK(is_shutdown_);
   if (session_storage_database_.get()) {
     // SessionStorageDatabase shouldn't be deleted right away: deleting it will
     // potentially involve waiting in leveldb::DBImpl::~DBImpl, and waiting
     // shouldn't happen on this thread.
     SessionStorageDatabase* to_release = session_storage_database_.get();
     to_release->AddRef();
     session_storage_database_ = NULL;
     task_runner_->PostShutdownBlockingTask(
         FROM_HERE,
         DOMStorageTaskRunner::COMMIT_SEQUENCE,
@@ skipping 100 matching lines @@
       dom_storage_namespace->GetOpenStorageArea(usage_info.origin);
   if (area)
     NotifyAreaCleared(area, usage_info.origin);
 }
 
 void DOMStorageContextImpl::Flush() {
   for (auto& entry : namespaces_)
     entry.second->Flush();
 }
 
 void DOMStorageContextImpl::Shutdown() {

[michaeln, 2016/05/02 22:47:12]

DCHECK(!task_runner_ || task_runner_->IsRunningOnPrimarySequence());

Can you add that dcheck since we're relying on that now. It would also catch the
bug if somebody were to add a call to Shutdown() from within the dtor as a "fix"
for seeing DCHECK(is_shutdown_) tripping.

[ssid, 2016/05/04 06:06:14]

Done.

   is_shutdown_ = true;
   StorageNamespaceMap::const_iterator it = namespaces_.begin();
   for (; it != namespaces_.end(); ++it)
     it->second->Shutdown();
 
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
+
   if (localstorage_directory_.empty() && !session_storage_database_.get())
     return;
 
   // Respect the content policy settings about what to
   // keep and what to discard.
   if (force_keep_session_state_)
     return;  // Keep everything.
 
   bool has_session_only_origins =
       special_storage_policy_.get() &&
@@ skipping 158 matching lines @@
 
 void DOMStorageContextImpl::StartScavengingUnusedSessionStorage() {
   if (session_storage_database_.get()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DOMStorageContextImpl::FindUnusedNamespaces,
                               this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
+bool DOMStorageContextImpl::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  for (const auto& it : namespaces_) {
+    it.second->OnMemoryDump(pmd);
+  }
+  if (session_storage_database_)
+    session_storage_database_->OnMemoryDump(pmd);
+  return true;
+}
+
 void DOMStorageContextImpl::FindUnusedNamespaces() {
   DCHECK(session_storage_database_.get());
   if (scavenging_started_)
     return;
   scavenging_started_ = true;
   std::set<std::string> namespace_ids_in_use;
   for (StorageNamespaceMap::const_iterator it = namespaces_.begin();
        it != namespaces_.end(); ++it)
     namespace_ids_in_use.insert(it->second->persistent_namespace_id());
   std::set<std::string> protected_persistent_session_ids;
@@ skipping 50 matching lines @@
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DOMStorageContextImpl::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 }  // namespace content