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

content/browser/dom_storage/session_storage_database.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/session_storage_database.h"
 
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.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"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "url/gurl.h"
 
 
 namespace {
@@ skipping 63 matching lines @@
   SessionStorageDatabase* session_storage_database_;
 };
 
 
 SessionStorageDatabase::SessionStorageDatabase(const base::FilePath& file_path)
     : file_path_(file_path),
       db_error_(false),
       is_inconsistent_(false),
       invalid_db_deleted_(false),
       operation_count_(0) {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this);
 }
 
 SessionStorageDatabase::~SessionStorageDatabase() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);

[Primiano Tucci (use gerrit), 2015/10/15 08:59:52]

if you unregister the RegisterDumpProvider call above must specify a task
runner. Otherwise you can unregister while dumping on another thread, which is
racy.
There is a dcheck preventing that in UnregisterDumpProvider, did you not hit
this in debug builds?

[ssid, 2015/10/15 15:22:04]

Thanks, I guess both were done in the same thread and i did not hit DCHECK.

 }
 
 void SessionStorageDatabase::ReadAreaValues(const std::string& namespace_id,
                                             const GURL& origin,
                                             DOMStorageValuesMap* result) {
   // We don't create a database if it doesn't exist. In that case, there is
   // nothing to be added to the result.
   if (!LazyOpen(false))
     return;
   DBOperation operation(this);
@@ skipping 205 matching lines @@
     } else {
       // The key is of the form "namespace-<namespaceid>-<origin>".
       std::string origin = key.substr(current_namespace_start_key.length());
       (*namespaces_and_origins)[current_namespace_id].push_back(GURL(origin));
     }
   }
   db_->ReleaseSnapshot(options.snapshot);
   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;
+  db_->GetProperty("leveldb.approximate-memory-usage", &value);

[Primiano Tucci (use gerrit), 2015/10/15 08:59:52]

shouldn't you check the return value of GetProperty?

[ssid, 2015/10/15 15:22:04]

Actually it cannot fail. added dcheck.

+  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) {
   base::AutoLock auto_lock(db_lock_);
   if (db_error_ || is_inconsistent_) {
     // Don't try to open a database that we know has failed already.
     return false;
   }
   if (IsOpen())
     return true;
 
   if (!create_if_needed &&
@@ skipping 385 matching lines @@
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace content