content: Add SharedBitmap MemoryDumpProvider implementation.

content/common/host_shared_bitmap_manager.cc

 // Copyright 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 "content/common/host_shared_bitmap_manager.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
+#include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "content/common/view_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 class BitmapData : public base::RefCountedThreadSafe<BitmapData> {
  public:
   BitmapData(base::ProcessHandle process_handle,
              size_t buffer_size)
       : process_handle(process_handle),
@@ skipping 24 matching lines @@
   ~HostSharedBitmap() override {
     if (manager_)
       manager_->FreeSharedMemoryFromMap(id());
   }
 
  private:
   scoped_refptr<BitmapData> bitmap_data_;
   HostSharedBitmapManager* manager_;
 };
 
+const char kMemoryAllocatorName[] = "sharedbitmap";
+
 }  // namespace
 
 base::LazyInstance<HostSharedBitmapManager> g_shared_memory_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 HostSharedBitmapManagerClient::HostSharedBitmapManagerClient(
     HostSharedBitmapManager* manager)
     : manager_(manager) {
 }
 
@@ skipping 20 matching lines @@
   manager_->ChildAllocatedSharedBitmap(buffer_size, handle, process_handle, id);
   owned_bitmaps_.insert(id);
 }
 
 void HostSharedBitmapManagerClient::ChildDeletedSharedBitmap(
     const cc::SharedBitmapId& id) {
   manager_->ChildDeletedSharedBitmap(id);
   owned_bitmaps_.erase(id);
 }
 
-HostSharedBitmapManager::HostSharedBitmapManager() {}
+HostSharedBitmapManager::HostSharedBitmapManager() {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this);

[Primiano Tucci (use gerrit), 2015/04/28 21:40:06]

I think you want a task_runner (IIRC the HostSBM is in the RendererMesageFilter
which lives on the IO?).
If the ctor already happens on the IO, just use TaskRunnerHandler::Get()

[reveman, 2015/04/29 01:45:58]

This is a singleton. See HostSharedBitmapManager::current().

+}
+
 HostSharedBitmapManager::~HostSharedBitmapManager() {
   DCHECK(handle_map_.empty());
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);

[Primiano Tucci (use gerrit), 2015/04/28 21:40:06]

Hmm if you unregister you should specify a task_runner in the registration,
otherwise you'll hit a CHECK in the MDM.
The rational is: you can't declare that you are fine being called on any thread
(no task_runner arg) and at the same time unregister, otherwise the MDM could
call you while you unregister on a different thread.
IN essence, no-affinity (no taskrunner) is safe only for MDPs that are
singletons.

[reveman, 2015/04/29 01:45:58]

Makes sense. I moved RegisterDumpProvider() call to
BrowserMainLoop::MainMessageLoopStart to make this less confusing.

 }
 
 HostSharedBitmapManager* HostSharedBitmapManager::current() {
   return g_shared_memory_manager.Pointer();
 }
 
 scoped_ptr<cc::SharedBitmap> HostSharedBitmapManager::AllocateSharedBitmap(
     const gfx::Size& size) {
   base::AutoLock lock(lock_);
   size_t bitmap_size;
@@ skipping 33 matching lines @@
         new HostSharedBitmap(data->pixels.get(), data, id, nullptr));
   }
   if (!data->memory->memory()) {
     return scoped_ptr<cc::SharedBitmap>();
   }
 
   return make_scoped_ptr(new HostSharedBitmap(
       static_cast<uint8*>(data->memory->memory()), data, id, nullptr));
 }
 
+bool HostSharedBitmapManager::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd) {
+  base::AutoLock lock(lock_);
+
+  for (const auto& bitmap_it : handle_map_) {
+    std::string heap_name;
+
+    for (size_t i = 0; i < sizeof(bitmap_it.first.name); ++i)
+      base::StringAppendF(&heap_name, "%02x", bitmap_it.first.name[i]);
+
+    base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
+        base::StringPrintf("%s/%s", kMemoryAllocatorName, heap_name.c_str()));
+    if (!dump)
+      return false;
+
+    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameOuterSize,
+                    base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                    bitmap_it.second->buffer_size);
+  }
+
+  return true;
+}
+
 void HostSharedBitmapManager::ChildAllocatedSharedBitmap(
     size_t buffer_size,
     const base::SharedMemoryHandle& handle,
     base::ProcessHandle process_handle,
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   if (handle_map_.find(id) != handle_map_.end())
     return;
   scoped_refptr<BitmapData> data(
       new BitmapData(process_handle, buffer_size));
@@ skipping 51 matching lines @@
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 }  // namespace content