Add a Mojo MemoryDumpProvider.

mojo/edk/system/handle_table.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 "mojo/edk/system/handle_table.h"
 
 #include <stdint.h>
 
 #include <limits>
 
+#include "base/trace_event/memory_dump_manager.h"
+
 namespace mojo {
 namespace edk {
 
-HandleTable::HandleTable() {}
+namespace {
 
-HandleTable::~HandleTable() {}
+const char* GetNameForDispatcherType(Dispatcher::Type type) {
+  switch (type) {
+    case Dispatcher::Type::UNKNOWN:
+      return "unknown";
+    case Dispatcher::Type::MESSAGE_PIPE:
+      return "message_pipe";
+    case Dispatcher::Type::DATA_PIPE_PRODUCER:
+      return "data_pipe_producer";
+    case Dispatcher::Type::DATA_PIPE_CONSUMER:
+      return "data_pipe_consumer";
+    case Dispatcher::Type::SHARED_BUFFER:
+      return "shared_buffer";
+    case Dispatcher::Type::WATCHER:
+      return "watcher";
+    case Dispatcher::Type::PLATFORM_HANDLE:
+      return "platform_handle";
+  }
+  return "unknown";

[ssid, 2017/06/07 00:30:28]

Can you add NOTREACHED() here?
Creating 2 memory dumps with same name will fail and if it fails in
ProcessMemoryDump then we will be confused why.

+}
+
+const char* kDumpProviderName = "MojoHandleTable";

[ssid, 2017/06/07 00:30:28]

remove this constant here and just inline. Will be used at one place only.

+
+}  // namespace
+
+HandleTable::HandleTable() {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, kDumpProviderName, nullptr);
+}
+
+HandleTable::~HandleTable() {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(

[ssid, 2017/06/07 00:30:28]

Why are you registering the dump provider again. This is supposed to be
unregister?

+      this, kDumpProviderName, nullptr);
+}
+
+base::Lock& HandleTable::GetLock() {
+  return lock_;
+}
 
 MojoHandle HandleTable::AddDispatcher(scoped_refptr<Dispatcher> dispatcher) {
   // Oops, we're out of handles.
   if (next_available_handle_ == MOJO_HANDLE_INVALID)
     return MOJO_HANDLE_INVALID;
 
   MojoHandle handle = next_available_handle_++;
   auto result =
       handles_.insert(std::make_pair(handle, Entry(std::move(dispatcher))));
   DCHECK(result.second);
@@ skipping 88 matching lines @@
     dispatcher.dispatcher->CancelTransit();
   }
 }
 
 void HandleTable::GetActiveHandlesForTest(std::vector<MojoHandle>* handles) {
   handles->clear();
   for (const auto& entry : handles_)
     handles->push_back(entry.first);
 }
 
+// MemoryDumpProvider implementation.
+bool HandleTable::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,

[ssid, 2017/06/07 00:30:28]

Is it possible to add test for this?
If this is to be enabled in slow reports then it's better to have tests.

+                               base::trace_event::ProcessMemoryDump* pmd) {
+  // Create entries for all relevant dispatcher types to ensure they are present
+  // in the final dump.
+  std::map<Dispatcher::Type, int> handle_count;
+  handle_count[Dispatcher::Type::MESSAGE_PIPE];
+  handle_count[Dispatcher::Type::DATA_PIPE_PRODUCER];
+  handle_count[Dispatcher::Type::DATA_PIPE_CONSUMER];
+  handle_count[Dispatcher::Type::SHARED_BUFFER];
+  handle_count[Dispatcher::Type::WATCHER];
+  handle_count[Dispatcher::Type::PLATFORM_HANDLE];

[ssid, 2017/06/07 00:30:28]

These lines are not needed.
Just doing ++handle_count[entry.second.dispatcher->GetType()] will initialize
first entry to 0.

+
+  // Count the number of each dispatcher type.
+  {
+    base::AutoLock lock(GetLock());
+    for (const auto& entry : handles_) {
+      ++handle_count[entry.second.dispatcher->GetType()];
+    }
+  }
+
+  base::trace_event::MemoryAllocatorDump* outer_dump =
+      pmd->CreateAllocatorDump("mojo");
+  for (const auto& entry : handle_count) {
+    outer_dump->AddScalar(GetNameForDispatcherType(entry.first),

[ssid, 2017/06/07 00:30:28]

This should be "mojo/unknown" and so on. Else no size will be shown in the UI.

[ssid, 2017/06/07 00:31:16]

just noticed that this is fixed. please ignore.

+                          base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+                          entry.second);
+  }
+
+  return true;
+}
+
 HandleTable::Entry::Entry() {}
 
 HandleTable::Entry::Entry(scoped_refptr<Dispatcher> dispatcher)
     : dispatcher(std::move(dispatcher)) {}
 
 HandleTable::Entry::Entry(const Entry& other) = default;
 
 HandleTable::Entry::~Entry() {}
 
 }  // namespace edk
 }  // namespace mojo