content: Add DeletedDiscardableSharedMemory IPC.

content/common/discardable_shared_memory_heap.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/common/discardable_shared_memory_heap.h"
 
 #include <algorithm>
 
 #include "base/memory/discardable_shared_memory.h"
 
@@ skipping 16 matching lines @@
     size_t length)
     : shared_memory_(shared_memory), start_(start), length_(length) {
 }
 
 DiscardableSharedMemoryHeap::Span::~Span() {
 }
 
 DiscardableSharedMemoryHeap::ScopedMemorySegment::ScopedMemorySegment(
     DiscardableSharedMemoryHeap* heap,
     scoped_ptr<base::DiscardableSharedMemory> shared_memory,
-    size_t size)
-    : heap_(heap), shared_memory_(shared_memory.Pass()), size_(size) {
+    size_t size,
+    const base::Closure& deleted_callback)
+    : heap_(heap),
+      shared_memory_(shared_memory.Pass()),
+      size_(size),
+      deleted_callback_(deleted_callback) {
 }
 
 DiscardableSharedMemoryHeap::ScopedMemorySegment::~ScopedMemorySegment() {
   heap_->ReleaseMemory(shared_memory_.get(), size_);
-  // Purge memory. This has no effect if already purged.
-  shared_memory_->Purge(base::Time::Now());
+  deleted_callback_.Run();
 }
 
 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsUsed() const {
   return heap_->IsMemoryUsed(shared_memory_.get(), size_);
 }
 
 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsResident() const {
   return heap_->IsMemoryResident(shared_memory_.get());
 }
 
 DiscardableSharedMemoryHeap::DiscardableSharedMemoryHeap(size_t block_size)
     : block_size_(block_size), num_blocks_(0), num_free_blocks_(0) {
   DCHECK_NE(block_size_, 0u);
   DCHECK(IsPowerOfTwo(block_size_));
 }
 
 DiscardableSharedMemoryHeap::~DiscardableSharedMemoryHeap() {
   memory_segments_.clear();
   DCHECK_EQ(num_blocks_, 0u);
   DCHECK_EQ(num_free_blocks_, 0u);
   DCHECK_EQ(std::count_if(free_spans_, free_spans_ + arraysize(free_spans_),
                           [](const base::LinkedList<Span>& free_spans) {
                             return !free_spans.empty();
                           }),
             0);
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span> DiscardableSharedMemoryHeap::Grow(
     scoped_ptr<base::DiscardableSharedMemory> shared_memory,
-    size_t size) {
+    size_t size,
+    const base::Closure& deleted_callback) {
   // Memory must be aligned to block size.
   DCHECK_EQ(
       reinterpret_cast<size_t>(shared_memory->memory()) & (block_size_ - 1),
       0u);
   DCHECK_EQ(size & (block_size_ - 1), 0u);
 
   scoped_ptr<Span> span(
       new Span(shared_memory.get(),
                reinterpret_cast<size_t>(shared_memory->memory()) / block_size_,
                size / block_size_));
   DCHECK(spans_.find(span->start_) == spans_.end());
   DCHECK(spans_.find(span->start_ + span->length_ - 1) == spans_.end());
   RegisterSpan(span.get());
 
   num_blocks_ += span->length_;
 
   // Start tracking if segment is resident by adding it to |memory_segments_|.
-  memory_segments_.push_back(
-      new ScopedMemorySegment(this, shared_memory.Pass(), size));
+  memory_segments_.push_back(new ScopedMemorySegment(this, shared_memory.Pass(),
+                                                     size, deleted_callback));
 
   return span.Pass();
 }
 
 void DiscardableSharedMemoryHeap::MergeIntoFreeLists(scoped_ptr<Span> span) {
   DCHECK(span->shared_memory_);
 
   // First add length of |span| to |num_free_blocks_|.
   num_free_blocks_ += span->length_;
 
@@ skipping 202 matching lines @@
     // If |span| is in the free list, remove it and update |num_free_blocks_|.
     if (IsInFreeList(span)) {
       DCHECK_GE(num_free_blocks_, span->length_);
       num_free_blocks_ -= span->length_;
       RemoveFromFreeList(span);
     }
   }
 }
 
 }  // namespace content