Lazily prune the multibuffer block cache.

media/blink/multibuffer.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 <utility>
 
 #include "media/blink/multibuffer.h"
 
 #include "base/bind.h"
+#include "base/location.h"
 
 namespace media {
 
+// Prune 80 blocks per 30 seconds.
+// This means a full cache will go away in ~5 minutes.
+enum {
+  kBlockPruneInterval = 30,
+  kBlocksPrunedPerInterval = 80,
+};
+
 // Returns the block ID closest to (but less or equal than) |pos| from |index|.
 template <class T>
 static MultiBuffer::BlockId ClosestPreviousEntry(
     const std::map<MultiBuffer::BlockId, T>& index,
     MultiBuffer::BlockId pos) {
   auto i = index.upper_bound(pos);
   DCHECK(i == index.end() || i->first > pos);
   if (i == index.begin()) {
     return std::numeric_limits<MultiBufferBlockId>::min();
   }
@@ skipping 12 matching lines @@
   if (i == index.end()) {
     return std::numeric_limits<MultiBufferBlockId>::max();
   }
   DCHECK_GE(i->first, pos);
   return i->first;
 }
 
 //
 // MultiBuffer::GlobalLRU
 //
-MultiBuffer::GlobalLRU::GlobalLRU() : max_size_(0), data_size_(0) {}
+MultiBuffer::GlobalLRU::GlobalLRU(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    : max_size_(0),
+      data_size_(0),
+      background_pruning_pending_(false),
+      task_runner_(task_runner) {}
 
 MultiBuffer::GlobalLRU::~GlobalLRU() {
   // By the time we're freed, all blocks should have been removed,
   // and our sums should be zero.
   DCHECK(lru_.Empty());
   DCHECK_EQ(max_size_, 0);
   DCHECK_EQ(data_size_, 0);
 }
 
 void MultiBuffer::GlobalLRU::Use(MultiBuffer* multibuffer,
                                  MultiBufferBlockId block_id) {
   GlobalBlockId id(multibuffer, block_id);
   lru_.Use(id);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::Insert(MultiBuffer* multibuffer,
                                     MultiBufferBlockId block_id) {
   GlobalBlockId id(multibuffer, block_id);
   lru_.Insert(id);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::Remove(MultiBuffer* multibuffer,
                                     MultiBufferBlockId block_id) {
   GlobalBlockId id(multibuffer, block_id);
   lru_.Remove(id);
 }
 
 bool MultiBuffer::GlobalLRU::Contains(MultiBuffer* multibuffer,
                                       MultiBufferBlockId block_id) {
   GlobalBlockId id(multibuffer, block_id);
   return lru_.Contains(id);
 }
 
 void MultiBuffer::GlobalLRU::IncrementDataSize(int64_t blocks) {
   data_size_ += blocks;
   DCHECK_GE(data_size_, 0);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::IncrementMaxSize(int64_t blocks) {
   max_size_ += blocks;
   DCHECK_GE(max_size_, 0);
+  SchedulePrune();
+}
+
+bool MultiBuffer::GlobalLRU::Pruneable() const {
+  return data_size_ > max_size_ && !lru_.Empty();
+}
+
+void MultiBuffer::GlobalLRU::SchedulePrune() {
+  if (Pruneable() && !background_pruning_pending_) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&MultiBuffer::GlobalLRU::PruneTask, this),
+        base::TimeDelta::FromSeconds(kBlockPruneInterval));
+    background_pruning_pending_ = true;
+  }
+}
+
+void MultiBuffer::GlobalLRU::PruneTask() {
+  background_pruning_pending_ = false;
+  Prune(kBlocksPrunedPerInterval);
+  SchedulePrune();
 }
 
 void MultiBuffer::GlobalLRU::Prune(int64_t max_to_free) {
   // We group the blocks by multibuffer so that we can free as many blocks as
   // possible in one call. This reduces the number of callbacks to clients
   // when their available ranges change.
   std::map<MultiBuffer*, std::vector<MultiBufferBlockId>> to_free;
   int64_t freed = 0;
   while (data_size_ - freed > max_size_ && !lru_.Empty() &&
          freed < max_to_free) {
@@ skipping 379 matching lines @@
 }
 
 void MultiBuffer::IncrementMaxSize(int32_t size) {
   max_size_ += size;
   lru_->IncrementMaxSize(size);
   DCHECK_GE(max_size_, 0);
   // Pruning only happens when blocks are added.
 }
 
 }  // namespace media