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.

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

nit 1:  Can you please add a statement that this is an implementation detail,
and other modules should call leveldb_env::OpenDB()?

+  // The function guarantees that:

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

nit 2: You could say that the function has the same guarantees as
leveldb_env::OpenDB(). I think a redirect is acceptable here, as this is an
implementation detail, and most readers should end up reading
leveldb_env::OpenDB() instead. Also, the redirect is a reminder that OpenDB()
relies on OpenDatabase() for these guarantees.

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

Done.

+  //   1. |dbptr| is not touched on failure
+  //   2. |dbptr| is not NULL on success
   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_