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

third_party/leveldatabase/env_chromium_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <map>
+#include <vector>
+
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/lazy_instance.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/test_suite.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 
 #define FPL FILE_PATH_LITERAL
 
 using leveldb::DB;
 using leveldb::Env;
 using leveldb::Options;
@@ skipping 162 matching lines @@
   // The disk size equating to the max buffer size
   EXPECT_EQ(size_t(4 * MB), leveldb_env::WriteBufferSize(40 * MB));
 
   // Make sure sizes larger than 40MB are clamped to max buffer size.
   EXPECT_EQ(size_t(4 * MB), leveldb_env::WriteBufferSize(80 * MB));
 
   // Check for very large disk size (catch overflow).
   EXPECT_EQ(size_t(4 * MB), leveldb_env::WriteBufferSize(100 * MB * MB));
 }
 
+TEST(ChromiumEnv, DBTrackerOpen) {
+  base::ScopedTempDir scoped_temp_dir;
+  ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir());
+  base::FilePath dir = scoped_temp_dir.GetPath();
+
+  struct KeyValue {
+    const char* key;
+    const char* value;
+  };
+  constexpr KeyValue db_data[] = {
+      {"banana", "yellow"}, {"sky", "blue"}, {"enthusiasm", ""},
+  };
+
+  // Open a new database using DBTracker::Open, write some data.
+  Options options;
+  options.create_if_missing = true;
+  DB* db;
+  Status status =
+      leveldb_env::DBTracker::Open(options, dir.AsUTF8Unsafe(), &db);
+  ASSERT_TRUE(status.ok()) << status.ToString();
+  for (const auto& kv : db_data) {
+    status = db->Put(WriteOptions(), kv.key, kv.value);
+    ASSERT_TRUE(status.ok()) << status.ToString();
+  }
+
+  // Close the database.
+  delete db;
+
+  // Open the database again with DB::Open, and check the data.
+  options.create_if_missing = false;
+  status = leveldb::DB::Open(options, dir.AsUTF8Unsafe(), &db);
+  ASSERT_TRUE(status.ok()) << status.ToString();
+  for (const auto& kv : db_data) {
+    std::string value;
+    status = db->Get(ReadOptions(), kv.key, &value);
+    ASSERT_TRUE(status.ok()) << status.ToString();
+    ASSERT_EQ(value, kv.value);
+  }
+  delete db;
+}
+
+TEST(ChromiumEnv, DBTrackerVisitDatabases) {
+  base::ScopedTempDir scoped_temp_dir;
+  ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir());
+
+  // Information available to the database visitor.
+  struct DBInfo {
+    std::string name;
+  };
+
+  struct LiveDB {
+    std::unique_ptr<DB> db;
+    DBInfo info;
+  };
+
+  std::vector<LiveDB> live_dbs;
+
+  // Open several databases.
+  for (const char* tag : {"poets", "movies", "recipes", "novels"}) {
+    Options options;
+    options.create_if_missing = true;
+    std::string name = scoped_temp_dir.GetPath().Append(tag).AsUTF8Unsafe();
+    DB* db;
+    Status status = leveldb_env::DBTracker::Open(options, name, &db);
+    ASSERT_TRUE(status.ok()) << status.ToString();
+    LiveDB& live_db = *live_dbs.emplace(live_dbs.end());
+    live_db.db.reset(db);
+    live_db.info.name = name;
+  }
+
+  using VisitedDBs = std::map<DB*, DBInfo>;
+
+  // Visits databases and returns them.
+  auto visit_databases = []() -> VisitedDBs {

[pwnall, 2017/06/26 23:37:14]

I'd prefer that you use a ChromiumEnvDBTrackerTest test fixture class and move
the types and VisitDatabases / AssertDatabasesLive there.

[DmitrySkiba, 2017/06/28 20:35:29]

Partially done. assert_databases_live() is still here, because it's used in one
place and accesses local variable, but VisitDatabases() was moved to
ChromiumEnvDBTrackerTest because it's now used in two tests.

[pwnall, 2017/06/28 22:52:55]

I think this'd be more readable if the method would be AssertEqualSets(const
VisitedDBSet&, const LiveDBSet&) where VisitedDBSet is a rename of VisitedDBs,
and LiveDBSet is an alias for std::vector<std::unique_ptr<leveldb::DB>>.

+    VisitedDBs visited;
+    auto db_visitor = [&](leveldb_env::DBTracker::DBWrapper* db) {
+      DBInfo info = {db->name()};
+      ASSERT_TRUE(visited.insert({db, info}).second)
+          << "Database " << std::hex << db << " visited for the second time";
+    };
+    leveldb_env::DBTracker::GetInstance()->VisitDatabases(db_visitor);
+    return visited;
+  };
+
+  // Checks that |visited_dbs| contains only live databases, and nothing else.
+  auto assert_databases_live = [&](const VisitedDBs& visited_dbs) {
+    ASSERT_EQ(live_dbs.size(), visited_dbs.size());
+    for (const auto& live_db : live_dbs) {
+      auto visited_db = visited_dbs.find(live_db.db.get());
+      ASSERT_NE(visited_dbs.end(), visited_db);
+      ASSERT_EQ(live_db.info.name, visited_db->second.name);
+    }
+  };
+
+  // Check that all live databases are visited.
+  assert_databases_live(visit_databases());
+
+  // Close couple of databases.
+  live_dbs.erase(live_dbs.begin());
+  live_dbs.erase(live_dbs.begin() + 1);
+
+  // Check that only remaining live databases are visited.
+  assert_databases_live(visit_databases());
+}
+
 int main(int argc, char** argv) { return base::TestSuite(argc, argv).Run(); }