Lazily prune the multibuffer block cache.

media/blink/multibuffer.h

 // 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.
 
 #ifndef MEDIA_BLINK_MULTIBUFFER_H_
 #define MEDIA_BLINK_MULTIBUFFER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/hash.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "media/base/data_buffer.h"
 #include "media/blink/interval_map.h"
 #include "media/blink/lru.h"
 #include "media/blink/media_blink_export.h"
 
 namespace media {
 
 // Used to identify a block of data in the multibuffer.
 // Our blocks are 32kb (1 << 15), so our maximum cacheable file size
@@ skipping 91 matching lines @@
     // It's ok if the effect is not immediate.
     virtual void SetDeferred(bool deferred) = 0;
   };
 
   // Multibuffers use a global shared LRU to free memory.
   // This effectively means that recently used multibuffers can
   // borrow memory from less recently used ones.
   class MEDIA_BLINK_EXPORT GlobalLRU : public base::RefCounted<GlobalLRU> {
    public:
     typedef MultiBufferGlobalBlockId GlobalBlockId;
-    GlobalLRU();
+    explicit GlobalLRU(
+        const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 
     // Free elements from cache if needed and possible.
     // Don't free more than |max_to_free| blocks.
     // Virtual for testing purposes.
     void Prune(int64_t max_to_free);
 
+    // Returns true if there are prunable blocks.
+    bool Pruneable() const;
+
+    // Incremnt the amount of data used by all multibuffers.
     void IncrementDataSize(int64_t blocks);
+
+    // Each multibuffer is allowed a certain amount of memory,
+    // that memory is registered by calling this function.
+    // The memory is actually shared by all multibuffers.
+    // When the total amount of memory used by all multibuffers
+    // is greater than what has been registered here, we use the
+    // LRU to decide what blocks to free first.
     void IncrementMaxSize(int64_t blocks);
 
     // LRU operations.
     void Use(MultiBuffer* multibuffer, MultiBufferBlockId id);
     void Remove(MultiBuffer* multibuffer, MultiBufferBlockId id);
     void Insert(MultiBuffer* multibuffer, MultiBufferBlockId id);
     bool Contains(MultiBuffer* multibuffer, MultiBufferBlockId id);
     int64_t Size() const;
 
    private:
     friend class base::RefCounted<GlobalLRU>;
     ~GlobalLRU();
 
+    // Schedule background pruning, if needed.
+    void SchedulePrune();
+
+    // Perform background pruning.
+    void PruneTask();
+
     // Max number of blocks.
     int64_t max_size_;
 
     // Sum of all multibuffer::data_.size().
     int64_t data_size_;
 
+    // True if there is a call to the background pruning outstanding.
+    bool background_pruning_pending_;
+
     // The LRU should contain all blocks which are not pinned from
     // all multibuffers.
     LRU<GlobalBlockId> lru_;
+
+    // Where we run our tasks.
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+    DISALLOW_COPY_AND_ASSIGN(GlobalLRU);
   };
 
   MultiBuffer(int32_t block_size_shift,
               const scoped_refptr<GlobalLRU>& global_lru);
   virtual ~MultiBuffer();
 
   // Identifies a block in the cache.
   // Block numbers can be calculated from byte positions as:
   // block_num = byte_pos >> block_size_shift
   typedef MultiBufferBlockId BlockId;
@@ skipping 138 matching lines @@
   // and 0 for all blocks that are not. Used to quickly figure out
   // ranges of available/unavailable blocks without iterating.
   IntervalMap<BlockId, int32_t> present_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_MULTIBUFFER_H_