[tracing] Memory dump provider for leveldb_proto

components/leveldb_proto/proto_database_impl_unittest.cc

 // Copyright 2014 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 "components/leveldb_proto/proto_database_impl.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "components/leveldb_proto/leveldb_database.h"
 #include "components/leveldb_proto/testing/proto/test.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 
 using base::MessageLoop;
 using base::ScopedTempDir;
 using testing::Invoke;
 using testing::Return;
@@ skipping 450 matching lines @@
   base::RunLoop run_loop;
   db_thread.task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(base::DoNothing), run_loop.QuitClosure());
   run_loop.Run();
 }
 
 // Test that the LevelDB properly saves entries and that load returns the saved
 // entries. If |close_after_save| is true, the database will be closed after
 // saving and then re-opened to ensure that the data is properly persisted.
 void TestLevelDBSaveAndLoad(bool close_after_save) {
+  base::MessageLoop main_loop;
+
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   EntryMap model = GetSmallModel();
 
   KeyValueVector save_entries;
   std::vector<std::string> load_entries;
   KeyVector remove_keys;
 
   for (const auto& pair : model) {
@@ skipping 42 matching lines @@
   KeyValueVector save_entries;
   std::vector<std::string> load_entries;
   KeyVector remove_keys;
 
   EXPECT_FALSE(db->InitWithOptions(temp_dir.GetPath(), options));
   EXPECT_FALSE(db->Load(&load_entries));
   EXPECT_FALSE(db->Save(save_entries, remove_keys));
 }
 
 TEST(ProtoDatabaseImplLevelDBTest, TestMemoryDatabase) {
+  base::MessageLoop main_loop;
+
   std::unique_ptr<LevelDB> db(new LevelDB(kTestLevelDBClientName));
 
   std::vector<std::string> load_entries;
 
   ASSERT_TRUE(db->Init(base::FilePath()));
 
   ASSERT_TRUE(db->Load(&load_entries));
   EXPECT_EQ(0u, load_entries.size());
 
   KeyValueVector save_entries(1, std::make_pair("foo", "bar"));
   KeyVector remove_keys;
 
   ASSERT_TRUE(db->Save(save_entries, remove_keys));
 
   std::vector<std::string> second_load_entries;
 
   ASSERT_TRUE(db->Load(&second_load_entries));
   EXPECT_EQ(1u, second_load_entries.size());
 }
 
+TEST(ProtoDatabaseImplLevelDBTest, TestOnMemoryDump) {

[nyquist, 2016/09/23 15:57:32]

TestOnMemoryDumpEmitsData

[ssid, 2016/09/26 18:13:37]

Done.

+  base::MessageLoop main_loop;
+  std::unique_ptr<LevelDB> db(new LevelDB(kTestLevelDBClientName));
+  std::vector<std::string> load_entries;
+  ASSERT_TRUE(db->Init(base::FilePath()));
+  KeyValueVector save_entries(1, std::make_pair("foo", "bar"));
+  KeyVector remove_keys;
+  ASSERT_TRUE(db->Save(save_entries, remove_keys));
+
+  base::trace_event::MemoryDumpArgs dump_args = {
+      base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
+  std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
+      new base::trace_event::ProcessMemoryDump(nullptr, dump_args));
+  db->OnMemoryDump(dump_args, process_memory_dump.get());
+
+  const auto& allocator_dumps = process_memory_dump->allocator_dumps();
+  EXPECT_EQ(2u, allocator_dumps.size());
+  for (const auto& dump : allocator_dumps) {
+    ASSERT_TRUE(dump.first.find("leveldb/leveldb_proto/") == 0 ||
+                dump.first.find("malloc/allocated_objects/") == 0);
+  }
+}
+
 }  // namespace leveldb_proto