leveldb: Add DBTracker for exposing databases to Chrome's memory-infra.

third_party/leveldatabase/env_chromium.h

Index: third_party/leveldatabase/env_chromium.h
diff --git a/third_party/leveldatabase/env_chromium.h b/third_party/leveldatabase/env_chromium.h
index d4335810b24496abaf1835a01ada393d9bdbbc43..7f063d055dbc21aba95d1817f9409b8f2af26a89 100644
--- a/third_party/leveldatabase/env_chromium.h
+++ b/third_party/leveldatabase/env_chromium.h
@@ -6,13 +6,18 @@
 #define THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 
 #include <deque>
+#include <functional>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/containers/linked_list.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/metrics/histogram.h"
+#include "leveldb/db.h"
 #include "leveldb/env.h"
 #include "port/port_chromium.h"
 #include "util/mutexlock.h"
@@ -230,6 +235,50 @@ class ChromiumEnv : public leveldb::Env,
   LockTable locks_;
 };
 
+// Database registry. Keeps track of all live databases and reports them to
+// memory-infra. This class is thread safe.
+class DBRegistry {
+ public:
+  // Opens a database. Internally calls leveldb::DB::Open(options, name)
+  // and wraps the result in |DBWrapper| instance (see below).
+  static leveldb::Status Open(const leveldb::Options& options,

[Marijn Kruisselbrink, 2017/06/20 23:38:52]

drive-by comment: presumably this is supposed to also replace things like the
MemoryDumpProvider in
https://cs.chromium.org/chromium/src/components/leveldb/leveldb_database_impl...,
in which case you'll need some way of optionally passing in a shared global
memory dump ID associated with the DB, to then allow linking leveldb memory
usage with whatever part of the code is using leveldb

[ssid, 2017/06/20 23:52:13]

I don't think we want to replace the existing providers. This is because we will
lose contextual information about the database itself. Like the ValueStore
provider might add extra details like number of values stored or local storage
might add information like URL name.

I think the plan is to just use AddOwnershipEdge between this dump and the dump
created by leveldb_database_impl and remove the AddSuballocation("malloc") call
from the leveldb_database_impl. This would account for double counting.

[Marijn Kruisselbrink, 2017/06/20 23:58:21]

Ah, okay, makes sense. So there will be some magic way for the other database
dumps to create the ownership edge between it and what is created by DBRegistry?

[DmitrySkiba, 2017/06/20 23:59:21]

Yup, that's pretty much what we discussed with ssid@ at some point. It seems
that if we make ID to be DB pointer everything is going to work - leveldatabase
will use DB pointer, and mojo will transfer it as an ID to clients, which will
use it to add an allocation edge. What do you think? Let's continue the
discussion in crbug.com/735269.

+                              const std::string& name,
+                              leveldb::DB** dbptr);
+
+  static DBRegistry* GetInstance();
+
+  // DB wrapper that provides extra information about the database.
+  class DBWrapper : public leveldb::DB {
+   public:
+    // DB name that Open() was called with.
+    virtual const std::string& name() const = 0;
+  };
+
+  using DatabaseVisitor = std::function<void(DBWrapper*)>;
+
+  // Calls |visitor| for each live database. Takes a lock, preventing
+  // any database from being created or destroyed (but doesn't lock the
+  // databases themselves).
+  void VisitDatabases(const DatabaseVisitor& visitor);
+
+ private:
+  class DBWrapperImpl;
+  class MDP;
+
+  DBRegistry();
+  ~DBRegistry();
+
+  void RegisterDatabase(DBWrapperImpl* database);
+  void UnregisterDatabase(DBWrapperImpl* database);
+
+  std::unique_ptr<MDP> mdp_;
+
+  base::Lock databases_lock_;
+  base::LinkedList<DBWrapperImpl> databases_;
+
+  DISALLOW_COPY_AND_ASSIGN(DBRegistry);
+};
+
 }  // namespace leveldb_env
 
 #endif  // THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_