[tracing] Add SkResourceCache as suballocation to avoid double counting.

base/memory/discardable_shared_memory.h

 // 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.
 
 #ifndef BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
 #define BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_
 
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 11 matching lines @@
 #endif
 
 namespace base {
 
 // Platform abstraction for discardable shared memory.
 //
 // This class is not thread-safe. Clients are responsible for synchronizing
 // access to an instance of this class.
 class BASE_EXPORT DiscardableSharedMemory {
  public:
+  // Used by other allocators to expess sub-allocation from discardable memory
+  // heap for tracing. To expess any suballocation, the dump providers need to
+  // create a sub-allocation edge from this node.
+  // E.g.: ProcessMemoryDump::AddSuballocation(skia_dump_guid,
+  //                                           kAllocatedObjectsDumpName);
+  static const char kAllocatedObjectsDumpName[];

[reveman, 2015/07/29 18:32:11]

I don't think we want this here. We shouldn't assume that DiscardableMemory
instances are backed by DiscardableSharedMemory.

[ssid, 2015/07/29 19:36:22]

Do you think DiscardableMemoryAllocator is a better place for this? I initially
placed it there, but moved it here since the kAllocatedObjectsDumpName is used
only if shared memory allocator is used.

[reveman, 2015/07/30 16:00:59]

Yes, DiscardableMemoryAllocator is better. That name we add there will be
correct independent of the underlying discardable memory system. Shared memory
based or not.

Also, can we make the name consistent with the name for system allocator dumps
and wrap it in a function?
https://code.google.com/p/chromium/codesearch#chromium/src/base/trace_event/m...

GetDiscardableAllocatorMemoryPoolName() maybe?

[ssid, 2015/07/30 20:05:15]

Thanks I din't know this existed.

+
   enum LockResult { SUCCESS, PURGED, FAILED };
 
   DiscardableSharedMemory();
 
   // Create a new DiscardableSharedMemory object from an existing, open shared
   // memory file. Memory must be locked.
   explicit DiscardableSharedMemory(SharedMemoryHandle handle);
 
   // Closes any open files.
   virtual ~DiscardableSharedMemory();
@@ skipping 99 matching lines @@
   // synchronized somehow. Use a collision warner to detect incorrect usage.
   DFAKE_MUTEX(thread_collision_warner_);
   Time last_known_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableSharedMemory);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_SHARED_MEMORY_H_