Use leveldb_env::OpenDB() to open leveldb databases.

third_party/leveldatabase/env_chromium.cc

 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "third_party/leveldatabase/env_chromium.h"
 
 #include <utility>
 
 #if defined(OS_POSIX)
 #include <dirent.h>
@@ skipping 1179 matching lines @@
 //   0x7FE70F2040A0      4.0 KiB       /Users/.../data_reduction_proxy_leveldb
 //   0x7FE70F530D80      188.4 KiB     /Users/.../Sync Data/LevelDB
 //   0x7FE71442F270      4.0 KiB       /Users/.../Sync App Settings/...
 //   0x7FE71471EC50      8.0 KiB       /Users/.../Extension State
 //
 class DBTracker::MemoryDumpProvider
     : public base::trace_event::MemoryDumpProvider {
  public:
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override {
+    // Don't dump in background mode ("from the field") until whitelisted.
+    if (args.level_of_detail ==
+        base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
+      return true;
+    }
+
     auto db_visitor = [](const base::trace_event::MemoryDumpArgs& args,
                          base::trace_event::ProcessMemoryDump* pmd,
                          TrackedDB* db) {
-      std::string db_dump_name = base::StringPrintf(
-          "leveldatabase/0x%" PRIXPTR, reinterpret_cast<uintptr_t>(db));
+      std::string db_dump_name = DBTracker::GetMemoryDumpName(db);
       auto* db_dump = pmd->CreateAllocatorDump(db_dump_name.c_str());
 
       uint64_t db_memory_usage = 0;
       {
         std::string usage_string;
         bool success = db->GetProperty("leveldb.approximate-memory-usage",
                                        &usage_string) &&
                        base::StringToUint64(usage_string, &db_memory_usage);
         DCHECK(success);
       }
@@ skipping 23 matching lines @@
 DBTracker::DBTracker() : mdp_(new MemoryDumpProvider()) {
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       mdp_.get(), "LevelDB", nullptr);
 }
 
 DBTracker::~DBTracker() {
   NOTREACHED();  // DBTracker is a singleton
 }
 
 DBTracker* DBTracker::GetInstance() {
   static DBTracker* instance = new DBTracker();

[michaeln, 2017/07/18 00:18:49]

is this getter (and ctor) thread safe? unless there's a reason not to, i think
i'd vote for using a base::LazyInstance<> here for consistency

[michaeln, 2017/07/18 00:47:22]

Ack, thnx!

   return instance;
 }
 
+std::string DBTracker::GetMemoryDumpName(leveldb::DB* tracked_db) {
+  return base::StringPrintf("leveldatabase/0x%" PRIXPTR,
+                            reinterpret_cast<uintptr_t>(tracked_db));
+}
+
 leveldb::Status DBTracker::OpenDatabase(const leveldb::Options& options,
                                         const std::string& name,
                                         TrackedDB** dbptr) {
   leveldb::DB* db = nullptr;
   auto status = leveldb::DB::Open(options, name, &db);
+  CHECK((status.ok() && db) || (!status.ok() && !db));

[Marijn Kruisselbrink, 2017/07/18 17:12:25]

nit: might be slightly nicer as something like CHECK_EQ(status.ok(), db !=
nullptr) ?

[DmitrySkiba, 2017/07/18 19:01:05]

I like the way it's now because it explicitly lists two conditions that we
accept. I'll add a comment explaining that.

   if (status.ok()) {
     // TrackedDBImpl ctor adds the instance to the tracker.
     *dbptr = new TrackedDBImpl(GetInstance(), name, db);
   }
   return status;
 }
 
 void DBTracker::VisitDatabases(const DatabaseVisitor& visitor) {
   base::AutoLock lock(databases_lock_);
   for (auto* i = databases_.head(); i != databases_.end(); i = i->next()) {
@@ skipping 25 matching lines @@
 
 }  // namespace leveldb_env
 
 namespace leveldb {
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb