Add a DiscardableMemoryShmemeAllocator.

mojo/services/html_viewer/discardable_memory_allocator.cc

+// Copyright 2015 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 "mojo/services/html_viewer/discardable_memory_allocator.h"
+
+#include "base/memory/weak_ptr.h"
+#include "base/stl_util.h"
+
+namespace html_viewer {
+
+// Represents an actual memory chunk. This is an object owned by
+// DiscardableMemoryAllocator. DiscardableMemoryChunkImpl are passed to the
+// rest of the program, and access this memory through a weak ptr.
+class DiscardableMemoryAllocator::OwnedMemoryChunk {
+ public:
+  OwnedMemoryChunk(size_t size)

[jamesr, 2015/03/17 23:26:19]

explicit

+      : is_locked_(true),
+        size_(size),
+        memory_(new uint8_t[size]),
+        allocator_(nullptr),
+        weak_factory_(this) {}
+  ~OwnedMemoryChunk() {}
+
+  void Lock() {
+    DCHECK(!is_locked_);
+    is_locked_ = true;
+
+    // While locked, we also move ourselves to the back of the list.
+    allocator_->MoveToBack(it_);
+  }
+
+  void Unlock() {
+    DCHECK(is_locked_);
+    is_locked_ = false;
+  }
+
+  bool locked() const { return is_locked_; }
+  size_t size() const { return size_; }
+  void* Memory() const { return memory_.get(); }

[jamesr, 2015/03/17 23:26:19]

DCHECK(is_locked_) here

+
+  base::WeakPtr<OwnedMemoryChunk> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+  void SetAllocatorAndPosition(std::list<OwnedMemoryChunk*>::iterator it,
+                               DiscardableMemoryAllocator* allocator) {
+    it_ = it;
+    allocator_ = allocator;
+  }
+
+ private:
+  bool is_locked_;
+  size_t size_;
+  scoped_ptr<uint8_t[]> memory_;
+
+  std::list<OwnedMemoryChunk*>::iterator it_;
+  DiscardableMemoryAllocator* allocator_;
+
+  base::WeakPtrFactory<OwnedMemoryChunk> weak_factory_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(OwnedMemoryChunk);
+};
+
+namespace {
+
+// Interface to the rest of the program. These objects are owned outside of the
+// allocator and wrap a weak ptr.
+class DiscardableMemoryChunkImpl : public base::DiscardableMemoryShmemChunk {
+ public:
+  explicit DiscardableMemoryChunkImpl(
+      base::WeakPtr<DiscardableMemoryAllocator::OwnedMemoryChunk> chunk)
+      : memory_chunk_(chunk) {}
+  ~DiscardableMemoryChunkImpl() override {}
+
+  // Overridden from DiscardableMemoryShmemChunk:
+  bool Lock() override {
+    if (!memory_chunk_)
+      return false;
+
+    memory_chunk_->Lock();
+    return true;
+  }
+
+  void Unlock() override {
+    if (memory_chunk_)
+      memory_chunk_->Unlock();
+  }
+
+  void* Memory() const override {
+    if (memory_chunk_)
+      return memory_chunk_->Memory();
+    return nullptr;
+  }
+
+ private:
+  base::WeakPtr<DiscardableMemoryAllocator::OwnedMemoryChunk> memory_chunk_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(DiscardableMemoryChunkImpl);
+};
+
+}  // namespace
+
+DiscardableMemoryAllocator::DiscardableMemoryAllocator(size_t max_memory)
+    : max_memory_(max_memory),
+      total_live_memory_(0) {
+}
+
+DiscardableMemoryAllocator::~DiscardableMemoryAllocator() {
+  STLDeleteElements(&live_chunks_);
+}
+
+scoped_ptr<base::DiscardableMemoryShmemChunk>
+DiscardableMemoryAllocator::AllocateLockedDiscardableMemory(size_t size) {
+  OwnedMemoryChunk* chunk = new OwnedMemoryChunk(size);
+  auto it = live_chunks_.insert(live_chunks_.end(), chunk);
+  chunk->SetAllocatorAndPosition(it, this);
+  total_live_memory_ += size;
+
+  // Purge unlocked chunks from the cache until |total_live_memory_| is under
+  // the desired maximum size.
+  it = live_chunks_.begin();
+  while (total_live_memory_ > max_memory_ && it != live_chunks_.end()) {
+    if (!(*it)->locked()) {
+      total_live_memory_ -= (*it)->size();
+      delete *it;
+      it = live_chunks_.erase(it);
+    } else {
+      it++;
+    }
+  }
+
+  return make_scoped_ptr(new DiscardableMemoryChunkImpl(chunk->GetWeakPtr()));
+}
+
+void DiscardableMemoryAllocator::MoveToBack(
+    std::list<OwnedMemoryChunk*>::iterator it) {
+  OwnedMemoryChunk* chunk = *it;
+  live_chunks_.erase(it);
+  it = live_chunks_.insert(live_chunks_.end(), chunk);
+  chunk->SetAllocatorAndPosition(it, this);
+}
+
+}  // namespace html_viewer