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

content/child/child_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 "content/child/child_discardable_shared_memory_manager.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
 #include "base/memory/discardable_memory.h"
@@ skipping 131 matching lines @@
                 reinterpret_cast<size_t>(free_span->shared_memory()->memory()),
             free_span->length() * base::GetPageSize()) ==
         base::DiscardableSharedMemory::FAILED) {
       DCHECK(!free_span->shared_memory()->IsMemoryResident());
       // We have to release purged memory before |free_span| can be destroyed.
       heap_.ReleasePurgedMemory();
       DCHECK(!free_span->shared_memory());
       continue;
     }
 
+    free_span->set_is_locked(true);
+
     // Memory usage is guaranteed to have changed after having removed
     // at least one span from the free lists.
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
     return make_scoped_ptr(new DiscardableMemoryImpl(this, free_span.Pass()));
   }
 
   // Release purged memory to free up the address space before we attempt to
   // allocate more memory.
   heap_.ReleasePurgedMemory();
@@ skipping 10 matching lines @@
       g_next_discardable_shared_memory_id.GetNext();
 
   // Ask parent process to allocate a new discardable shared memory segment.
   scoped_ptr<base::DiscardableSharedMemory> shared_memory(
       AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id));
 
   // Create span for allocated memory.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(heap_.Grow(
       shared_memory.Pass(), allocation_size_in_bytes, new_id,
       base::Bind(&SendDeletedDiscardableSharedMemoryMessage, sender_, new_id)));
+  new_span->set_is_locked(true);
 
   // Unlock and insert any left over memory into free lists.
   if (pages < pages_to_allocate) {
     scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover =
         heap_.Split(new_span.get(), pages);
     leftover->shared_memory()->Unlock(
         leftover->start() * base::GetPageSize() -
             reinterpret_cast<size_t>(leftover->shared_memory()->memory()),
         leftover->length() * base::GetPageSize());
+    leftover->set_is_locked(false);
     heap_.MergeIntoFreeLists(leftover.Pass());
   }
 
   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
   return make_scoped_ptr(new DiscardableMemoryImpl(this, new_span.Pass()));
 }
 
 bool ChildDiscardableSharedMemoryManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
@@ skipping 21 matching lines @@
 
   if (!span->shared_memory())
     return false;
 
   size_t offset = span->start() * base::GetPageSize() -
       reinterpret_cast<size_t>(span->shared_memory()->memory());
   size_t length = span->length() * base::GetPageSize();
 
   switch (span->shared_memory()->Lock(offset, length)) {
     case base::DiscardableSharedMemory::SUCCESS:
+      span->set_is_locked(true);
       return true;
     case base::DiscardableSharedMemory::PURGED:
       span->shared_memory()->Unlock(offset, length);
+      span->set_is_locked(false);
       return false;
     case base::DiscardableSharedMemory::FAILED:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 void ChildDiscardableSharedMemoryManager::UnlockSpan(
     DiscardableSharedMemoryHeap::Span* span) {
   base::AutoLock lock(lock_);
 
   DCHECK(span->shared_memory());
   size_t offset = span->start() * base::GetPageSize() -
       reinterpret_cast<size_t>(span->shared_memory()->memory());
   size_t length = span->length() * base::GetPageSize();
 
+  span->set_is_locked(false);
   return span->shared_memory()->Unlock(offset, length);
 }
 
 void ChildDiscardableSharedMemoryManager::ReleaseSpan(
     scoped_ptr<DiscardableSharedMemoryHeap::Span> span) {
   base::AutoLock lock(lock_);
 
   // Delete span instead of merging it into free lists if memory is gone.
   if (!span->shared_memory())
     return;
@@ skipping 40 matching lines @@
       "discardable-memory-allocated";
   base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey,
                                 base::Uint64ToString(new_bytes_total));
 
   static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free";
   base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey,
                                 base::Uint64ToString(new_bytes_free));
 }
 
 }  // namespace content