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

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 <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"
 
 namespace leveldb_env {
 
 // These entries map to values in tools/metrics/histograms/histograms.xml. New
 // values should be appended at the end.
 enum MethodID {
   kSequentialFileRead,
@@ skipping 197 matching lines @@
   // Entry per Schedule() call
   struct BGItem {
     void* arg;
     void (*function)(void*);
   };
   typedef std::deque<BGItem> BGQueue;
   BGQueue queue_;
   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_