[tracing] Add memory statistics from level db clients to tracing.

content/browser/dom_storage/session_storage_database.cc

Index: content/browser/dom_storage/session_storage_database.cc
diff --git a/content/browser/dom_storage/session_storage_database.cc b/content/browser/dom_storage/session_storage_database.cc
index d0ab442238b5817b48761a8267e5858002ba420d..067e053591f44ec11c0ba9c09b42b6bdf831d81f 100644
--- a/content/browser/dom_storage/session_storage_database.cc
+++ b/content/browser/dom_storage/session_storage_database.cc
@@ -12,6 +12,9 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
@@ -95,9 +98,13 @@ SessionStorageDatabase::SessionStorageDatabase(const base::FilePath& file_path)
       is_inconsistent_(false),
       invalid_db_deleted_(false),
       operation_count_(0) {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, base::ThreadTaskRunnerHandle::Get());

[michaeln, 2015/10/15 23:55:13]

The threading needs some work. This class is created on the main thread and
deleted on a worker pool thread.

DCHECK(!base::ThreadTaskRunnerHandle::IsSet()) is a valid assertion on worker
pool threads.

Does the MemoryDumpManager know about SequencedTaskRunners? Session storage
doesn't care about thread affinity but it does care about ordering.  It uses the
SequencedWorkerPool and SequencedTaskRunners for that. A lot of things care
about ordering more than thread affinity so modifying the dump manager to work
with them instead of ThreadTaskRunners would be a good change.

[Primiano Tucci (use gerrit), 2015/10/16 09:10:34]

There are mainly two reason why I restricted the manager to ThreadTaskRunners :
- I want to guarantee that Registration, Unregistration and OnMemoryDump calls
do not overlap. Restricting to a single thread felt the safe choice to me. But
is sounds like we might be able to get the same guarantee with STR, but I have
to think more on this.
- By using thread task runners I can make the manager smarter on the thread
hopping logic: if I have 20 dumpers registered on 5 different threads, I can
reshuffle the OnMemoryDump sequence grouping by thread and do only 5 thread hops
in total.

If I switch to STR, how do I figure out what is the smartest sequence of
hopping?
I guess the best choice would be to have a different code path for STR, and just
do uncoditional PostTasks all the times there.

 }
 
 SessionStorageDatabase::~SessionStorageDatabase() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 void SessionStorageDatabase::ReadAreaValues(const std::string& namespace_id,
@@ -323,6 +330,32 @@ bool SessionStorageDatabase::ReadNamespacesAndOrigins(
   return true;
 }
 
+bool SessionStorageDatabase::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (!db_)
+    return true;
+
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump("leveldb/session_storage_db");
+
+  base::AutoLock auto_lock(db_lock_);
+  std::string value;
+  uint64 size;
+  bool res = db_->GetProperty("leveldb.approximate-memory-usage", &value);
+  DCHECK(res);
+  base::StringToUint64(value, &size);
+
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes, size);
+
+  // Memory is allocated from system allocator (malloc).
+  pmd->AddSuballocation(dump->guid(),
+                        base::trace_event::MemoryDumpManager::GetInstance()
+                            ->system_allocator_pool_name());
+  return true;
+}
+
 bool SessionStorageDatabase::LazyOpen(bool create_if_needed) {

[michaeln, 2015/10/15 23:55:13]

This might be a better place to Register with the dumpmgr but we need to make
the task runner available to this class.

   base::AutoLock auto_lock(db_lock_);
   if (db_error_ || is_inconsistent_) {