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/message_loop/message_loop.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()
+    : max_size_(0), data_size_(0), background_pruning_active_(false) {}
 
 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);
 }
 
 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_active_) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&MultiBuffer::GlobalLRU::PruneTask, this),
+        base::TimeDelta::FromSeconds(kBlockPruneInterval));
+    background_pruning_active_ = true;
+  }
+}
+
+void MultiBuffer::GlobalLRU::PruneTask() {
+  background_pruning_active_ = false;

[DaleCurtis, 2016/03/24 19:12:24]

This disables pruning on the first scheduled one and will stop if Use/Insert is
not called. That doesn't seem like it will continue to run pruning if insert/use
is not called.

[hubbe, 2016/03/24 20:57:40]

I renamed background_pruning_active_ to backround_pruning_pending_.
This doesn't disable background pruning, it just means that there no pending
call to this function anymore, which means that SchedulePrune() can schedule
another one.

+  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