[tracing] Display the locked size of discardable memory segment.

base/memory/discardable_shared_memory.h

Index: base/memory/discardable_shared_memory.h
diff --git a/base/memory/discardable_shared_memory.h b/base/memory/discardable_shared_memory.h
index 74bbe8e95f427ba347d696e6c6e9c408e166e167..edfe54e29c2f1188db93772ec974f3f32a9f562c 100644
--- a/base/memory/discardable_shared_memory.h
+++ b/base/memory/discardable_shared_memory.h
@@ -56,6 +56,11 @@ class BASE_EXPORT DiscardableSharedMemory {
   // The actual size of the mapped memory (may be larger than requested).
   size_t mapped_size() const { return mapped_size_; }
 
+  // The total size of locked segments by this instance of
+  // DiscardableSharedMemory. If the memory is shared with other process,
+  // then returns the total size of the segment if locked.
+  size_t LockedSize() const;

[reveman, 2015/09/29 12:29:10]

I assume you're interested in being able to call this from any process and not
just the process locking the segment. LockedSize() doesn't make sense for that
as only the process locking the memory will know how much is locked. "bool
IsMemoryLocked() const" would work. If you add such a function, please keep it
next to "IsMemoryResident()".

I'm not sure we should expose the value of locked_page_count_ as that will be
confusing from a multi-process usage pov. I think it might be better to keep
track of this in each child process using the DiscardableSharedMemoryHeap spans.

[ssid, 2015/09/29 16:03:55]

Maybe I should just rename it? instead of calculating these outside or make it
private method and friend or something?
Hm, this looks like lot of change to me, I have adding the lock state in span
also moved lock and unlock feature to span itself. This is because everytime
someone wants to unlock the span they should remember to update the span locked
state. Curently manager was just using span->shared_memory()->Lock, now it will
use span::Lock. If not for the lock mechanism, I would have removed the
ChildDiscardableSharedMemoryManager::Lock and directly called span->Lock in
DiscardableMemoryImpl. But this feels a bit weird that the impl now has two
choices, it can span->lock or manager->lock(span). But calling manager is thread
safe.
Also I had to hard code true and false for span constructor.

Should I just store the locked state and update it everytime memory is locked
and unlocked?

+
   // Returns a shared memory handle for this DiscardableSharedMemory object.
   SharedMemoryHandle handle() const { return shared_memory_.handle(); }