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 1175 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 27 matching lines @@
 
 DBTracker::~DBTracker() {
   NOTREACHED();  // DBTracker is a singleton
 }
 
 DBTracker* DBTracker::GetInstance() {
   static DBTracker* instance = new DBTracker();
   return instance;
 }
 
+std::string DBTracker::GetMemoryDumpName(leveldb::DB* tracked_db) {
+  return base::StringPrintf("leveldatabase/0x%" PRIXPTR,

[pwnall, 2017/07/07 22:30:29]

nit: I'd prefer that GetMemoryDumpName() DCHECKs that tracked_db is in the
linked list. I can do it if you don't get around to.

[DmitrySkiba, 2017/07/17 22:09:25]

I can see value in that DCHECK, but I'm not sure what is the right way to add
it. The thing is that GetMemoryDumpName() is called from VisitDatabases visitor
right now, so we either have to split it in two (internal version that doesn't
lock, external that locks), or we introduce two GetMemoryDumpName() versions:
one that takes DB and has DHCECK (and calls another), and the one that takes
TrackedDB, and doesn't lock. Neither option is ideal to me. I suggest we move
further with this implementation, and and continue searching for a proper way in
a follow-up CL (which I'll create).

+                            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));
   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