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

components/discardable_memory/service/discardable_shared_memory_manager.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/discardable_memory/service/discardable_shared_memory_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/numerics/safe_math.h"
 #include "base/process/memory.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/discardable_memory/common/discardable_shared_memory_heap.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
 #if defined(OS_LINUX)
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram_macros.h"
 #endif
 
 namespace discardable_memory {
 namespace {
 
-const char kSingleProcess[] = "single-process";
-
 const int kInvalidUniqueClientID = -1;
 
-const uint64_t kBrowserTracingProcessId = std::numeric_limits<uint64_t>::max();
-
-uint64_t ClientProcessUniqueIdToTracingProcessId(int client_id) {
-  // TODO(penghuang): Move this function to right place.
-  // https://crbug.com/661257
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcess))
-    return kBrowserTracingProcessId;
-  // The hash value is incremented so that the tracing id is never equal to
-  // MemoryDumpManager::kInvalidTracingProcessId.
-  return static_cast<uint64_t>(base::Hash(
-             reinterpret_cast<const char*>(&client_id), sizeof(client_id))) +
-         1;
-}
-
 // mojom::DiscardableSharedMemoryManager implementation. It contains the
 // |client_id_| which is not visible to client. We associate allocations with a
 // given mojo instance, so if the instance is closed, we can release the
 // allocations associated with that instance.
 class MojoDiscardableSharedMemoryManagerImpl
     : public mojom::DiscardableSharedMemoryManager {
  public:
   MojoDiscardableSharedMemoryManagerImpl(
       int32_t client_id,
       ::discardable_memory::DiscardableSharedMemoryManager* manager)
@@ skipping 243 matching lines @@
       // Host can only tell if whole segment is locked or not.
       dump->AddScalar(
           "locked_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes,
           segment->memory()->IsMemoryLocked() ? segment->memory()->mapped_size()
                                               : 0u);
 
       // Create the cross-process ownership edge. If the client creates a
       // corresponding dump for the same segment, this will avoid to
       // double-count them in tracing. If, instead, no other process will emit a
       // dump with the same guid, the segment will be accounted to the browser.
-      const uint64_t client_tracing_id =
-          ClientProcessUniqueIdToTracingProcessId(client_id);
-      base::trace_event::MemoryAllocatorDumpGuid shared_segment_guid =
-          DiscardableSharedMemoryHeap::GetSegmentGUIDForTracing(
-              client_tracing_id, segment_id);
-      pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid);
-      pmd->AddOwnershipEdge(dump->guid(), shared_segment_guid);
+
+      base::SharedMemoryTracker::AddOwnershipEdges(
+          pmd, dump->guid(), segment->memory()->handle(),
+          segment->memory()->mapped_size());
 
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
       if (args.level_of_detail ==
           base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
-        size_t resident_size =
+        // TODO: Fix this
+        /*size_t resident_size =
             base::trace_event::ProcessMemoryDump::CountResidentBytes(
-                segment->memory()->memory(), segment->memory()->mapped_size());
+            segment->memory()->memory(), segment->memory()->mapped_size());*/
 
         // This is added to the global dump since it has to be attributed to
         // both the allocator dumps involved.
-        pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
+        /*pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
             ->AddScalar("resident_size",

[hajimehoshi, 2017/03/27 10:05:01]

I have no idea what is the difference between 'resident_size' here and 'size'
and how to treat this with my fix.

                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                        static_cast<uint64_t>(resident_size));
+                        static_cast<uint64_t>(resident_size));*/
       }
 #endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
     }
   }
   return true;
 }
 
 void DiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForClient(
         int client_id,
@@ skipping 270 matching lines @@
     return;
 
   enforce_memory_policy_pending_ = true;
   DCHECK(enforce_memory_policy_task_runner_);
   enforce_memory_policy_task_runner_->PostDelayedTask(
       FROM_HERE, enforce_memory_policy_callback_,
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace discardable_memory