[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 13 matching lines @@
 // Default allocation size.
 const size_t kAllocationSize = 4 * 1024 * 1024;
 
 // Global atomic to generate unique discardable shared memory IDs.
 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
 
 class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
   DiscardableMemoryImpl(ChildDiscardableSharedMemoryManager* manager,
                         scoped_ptr<DiscardableSharedMemoryHeap::Span> span)
-      : manager_(manager), span_(span.Pass()), is_locked_(true) {}
+      : manager_(manager), span_(span.Pass()) {}
 
   ~DiscardableMemoryImpl() override {
-    if (is_locked_)
+    if (span_->is_locked())
       manager_->UnlockSpan(span_.get());
 
     manager_->ReleaseSpan(span_.Pass());
   }
 
   // Overridden from base::DiscardableMemory:
   bool Lock() override {
-    DCHECK(!is_locked_);
+    DCHECK(!span_->is_locked());
 
     if (!manager_->LockSpan(span_.get()))
       return false;
 
-    is_locked_ = true;
     return true;
   }
   void Unlock() override {
-    DCHECK(is_locked_);
+    DCHECK(span_->is_locked());
 
     manager_->UnlockSpan(span_.get());
-    is_locked_ = false;
   }
   void* data() const override {
-    DCHECK(is_locked_);
+    DCHECK(span_->is_locked());
     return reinterpret_cast<void*>(span_->start() * base::GetPageSize());
   }
 
   base::trace_event::MemoryAllocatorDump* CreateMemoryAllocatorDump(
       const char* name,
       base::trace_event::ProcessMemoryDump* pmd) const override {
     return manager_->CreateMemoryAllocatorDump(span_.get(), name, pmd);
   }
 
  private:
   ChildDiscardableSharedMemoryManager* const manager_;
   scoped_ptr<DiscardableSharedMemoryHeap::Span> span_;
-  bool is_locked_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryImpl);
 };
 
 void SendDeletedDiscardableSharedMemoryMessage(
     scoped_refptr<ThreadSafeSender> sender,
     DiscardableSharedMemoryId id) {
   sender->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
 }
 
@@ skipping 46 matching lines @@
   size_t heap_size_prior_to_releasing_purged_memory = heap_.GetSize();
   for (;;) {
     // Search free lists for suitable span.
     scoped_ptr<DiscardableSharedMemoryHeap::Span> free_span =
         heap_.SearchFreeLists(pages, slack);
     if (!free_span.get())
       break;
 
     // Attempt to lock |free_span|. Delete span and search free lists again
     // if locking failed.
-    if (free_span->shared_memory()->Lock(
-            free_span->start() * base::GetPageSize() -
-                reinterpret_cast<size_t>(free_span->shared_memory()->memory()),
-            free_span->length() * base::GetPageSize()) ==
+    if (free_span->Lock(base::GetPageSize()) ==
         base::DiscardableSharedMemory::FAILED) {
-      DCHECK(!free_span->shared_memory()->IsMemoryResident());
+      DCHECK(!free_span->IsMemoryResident());
       // We have to release purged memory before |free_span| can be destroyed.
       heap_.ReleasePurgedMemory();
       DCHECK(!free_span->shared_memory());
       continue;
     }
 
     // Memory usage is guaranteed to have changed after having removed
     // at least one span from the free lists.
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
@@ skipping 21 matching lines @@
 
   // 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)));
 
   // 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->Unlock(base::GetPageSize());
     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 15 matching lines @@
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 }
 
 bool ChildDiscardableSharedMemoryManager::LockSpan(
     DiscardableSharedMemoryHeap::Span* span) {
   base::AutoLock lock(lock_);
 
   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)) {
+  switch (span->Lock(base::GetPageSize())) {
     case base::DiscardableSharedMemory::SUCCESS:
       return true;
     case base::DiscardableSharedMemory::PURGED:
-      span->shared_memory()->Unlock(offset, length);
+      span->Unlock(base::GetPageSize());
       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();
 
-  return span->shared_memory()->Unlock(offset, length);
+  return span->Unlock(base::GetPageSize());
 }
 
 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 39 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