base: Improve DiscardableSharedMemory support for ashmem.

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/memory/discardable_shared_memory.h"
 #include "base/process/process_metrics.h"
 #include "content/child/child_thread.h"
 #include "content/common/child_process_messages.h"
@@ skipping 54 matching lines @@
 
   for (;;) {
     // Search free list for available space.
     scoped_ptr<DiscardableSharedMemoryHeap::Span> free_span =
         heap_.SearchFreeList(pages);
     if (!free_span.get())
       break;
 
     // Attempt to lock |free_span|. Delete span and search free list again
     // if locking failed.
-    if (!free_span->shared_memory()->Lock(
+    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())) {
+            free_span->length() * base::GetPageSize()) !=
+        base::DiscardableSharedMemory::SUCCESS) {
       heap_.DeleteSpan(free_span.Pass());
       continue;
     }
 
     return make_scoped_ptr(
         new DiscardableMemoryShmemChunkImpl(this, free_span.Pass()));
   }
 
   size_t pages_to_allocate =
       std::max(kAllocationSize / base::GetPageSize(), pages);
@@ skipping 18 matching lines @@
     heap_.MergeIntoFreeList(leftover.Pass());
   }
 
   return make_scoped_ptr(
       new DiscardableMemoryShmemChunkImpl(this, new_span.Pass()));
 }
 
 bool ChildDiscardableSharedMemoryManager::LockSpan(
     DiscardableSharedMemoryHeap::Span* span) {
   base::AutoLock lock(lock_);
-  return span->shared_memory()->Lock(
-      span->start() * base::GetPageSize() -
-          reinterpret_cast<size_t>(span->shared_memory()->memory()),
-      span->length() * base::GetPageSize());
+
+  size_t offset = span->start() * base::GetPageSize() -
+      reinterpret_cast<size_t>(span->shared_memory()->memory());
+  size_t length = span->length() * base::GetPageSize();
+
+  auto result = span->shared_memory()->Lock(offset, length);
+  if (result == base::DiscardableSharedMemory::SUCCESS)

[danakj, 2015/01/24 00:16:06]

switch instead of series of ifs?

[reveman, 2015/01/24 00:27:48]

Good idea. Done.

+    return true;
+  if (result == base::DiscardableSharedMemory::PURGED)
+    span->shared_memory()->Unlock(offset, length);
+
+  return false;
 }
 
 void ChildDiscardableSharedMemoryManager::UnlockSpan(
     DiscardableSharedMemoryHeap::Span* span) {
   base::AutoLock lock(lock_);
-  return span->shared_memory()->Unlock(
-      span->start() * base::GetPageSize() -
-          reinterpret_cast<size_t>(span->shared_memory()->memory()),
-      span->length() * base::GetPageSize());
+
+  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);
 }
 
 bool ChildDiscardableSharedMemoryManager::IsSpanResident(
     DiscardableSharedMemoryHeap::Span* span) const {
   base::AutoLock lock(lock_);
   return span->shared_memory()->IsMemoryResident();
 }
 
 void ChildDiscardableSharedMemoryManager::ReleaseSpan(
     scoped_ptr<DiscardableSharedMemoryHeap::Span> span) {
@@ skipping 21 matching lines @@
   sender_->Send(
       new ChildProcessHostMsg_SyncAllocateLockedDiscardableSharedMemory(
           size, &handle));
   scoped_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory(handle));
   CHECK(memory->Map(size));
   return memory.Pass();
 }
 
 }  // namespace content