[WIP] Add SharedMemoryTracker to dump base::SharedMemory usage

base/memory/shared_memory_posix.cc

 // Copyright (c) 2012 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 "base/memory/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory_helper.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/process/process_metrics.h"
 #include "base/scoped_generic.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 
 #if defined(OS_ANDROID)
 #include "base/os_compat_android.h"
@@ skipping 249 matching lines @@
   }
 #endif
 
   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
                  MAP_SHARED, mapped_file_, offset);
 
   bool mmap_succeeded = memory_ != (void*)-1 && memory_ != NULL;
   if (mmap_succeeded) {
     mapped_size_ = bytes;
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
-        (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
+                      (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
+    if (!SharedMemoryTracker::GetInstance()->IncrementMemoryUsage(*this))
+      return false;
   } else {
     memory_ = NULL;
   }
 
   return mmap_succeeded;
 }
 
 bool SharedMemory::Unmap() {
   if (memory_ == NULL)
     return false;
 
   munmap(memory_, mapped_size_);
+  SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
   memory_ = NULL;
   mapped_size_ = 0;
   return true;
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
   return FileDescriptor(mapped_file_, false);
 }
 
 SharedMemoryHandle SharedMemory::TakeHandle() {
   FileDescriptor handle(mapped_file_, true);
   mapped_file_ = -1;
   memory_ = nullptr;
   mapped_size_ = 0;
   return handle;
 }
 
 void SharedMemory::Close() {
   if (mapped_file_ > 0) {
     if (IGNORE_EINTR(close(mapped_file_)) < 0)
       PLOG(ERROR) << "close";
+    SharedMemoryTracker::GetInstance()->DecrementMemoryUsage(*this);
     mapped_file_ = -1;
   }
   if (readonly_mapped_file_ > 0) {
     if (IGNORE_EINTR(close(readonly_mapped_file_)) < 0)
       PLOG(ERROR) << "close";
     readonly_mapped_file_ = -1;
   }
 }
 
 #if !defined(OS_ANDROID)
@@ skipping 53 matching lines @@
 
   if (close_self) {
     Unmap();
     Close();
   }
 
   return true;
 }
 
 }  // namespace base