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

third_party/leveldatabase/env_chromium.h

 // Copyright (c) 2013 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.
 
 #ifndef THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 #define THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 
 #include <deque>
 #include <memory>
 #include <set>
@@ skipping 224 matching lines @@
   LockTable locks_;
 };
 
 // Tracks databases open via OpenDatabase() method and exposes them to
 // memory-infra. The class is thread safe.
 class DBTracker {
  public:
   // DBTracker singleton instance.
   static DBTracker* GetInstance();
 
+  // Returns name of memory-infra dump for |tracked_db|. Can be used to attach
+  // additional info to the database dump, or to properly attribute memory
+  // usage in memory dump providers that also dump |tracked_db|.
+  // Note that |tracked_db| should be a live database instance produced by
+  // OpenDatabase() method or leveldb_env::OpenDB() function.
+  static std::string GetMemoryDumpName(leveldb::DB* tracked_db);
+
   // Provides extra information about a tracked database.
   class TrackedDB : public leveldb::DB {
    public:
     // Name that OpenDatabase() was called with.
     virtual const std::string& name() const = 0;
   };
 
   // Opens a database and starts tracking it. As long as the opened database
   // is alive (i.e. its instance is not destroyed) the database is exposed to
   // memory-infra and is enumerated by VisitDatabases() method.
+  // This function is an implementation detail of leveldb_env::OpenDB(), and
+  // has similar guarantees regarding |dbptr| argument.
   leveldb::Status OpenDatabase(const leveldb::Options& options,
                                const std::string& name,
                                TrackedDB** dbptr);
 
   using DatabaseVisitor = base::RepeatingCallback<void(TrackedDB*)>;
 
   // Calls |visitor| for each live database. The database is live from the
   // point it was returned from OpenDatabase() and up until its instance is
   // destroyed.
   // The databases may be visited in an arbitrary order.
@@ skipping 13 matching lines @@
 
   std::unique_ptr<MemoryDumpProvider> mdp_;
 
   base::Lock databases_lock_;
   base::LinkedList<TrackedDBImpl> databases_;
 
   DISALLOW_COPY_AND_ASSIGN(DBTracker);
 };
 
 // Opens a database and exposes it to Chrome's tracing (see DBTracker for
-// details). Note that |dbptr| is touched only when function succeeds.
+// details). The function guarantees that:
+//   1. |dbptr| is not touched on failure
+//   2. |dbptr| is not NULL on success
 leveldb::Status OpenDB(const leveldb::Options& options,
                        const std::string& name,
                        std::unique_ptr<leveldb::DB>* dbptr);
 
 }  // namespace leveldb_env
 
 #endif  // THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_