Tie multibuffers to URLs

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 <stdint.h>
 
 #include <limits>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.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
+// is 1 << (15 + 31) = 64Tb
 typedef int32_t MultiBufferBlockId;
 class MultiBuffer;
+
+// This type is used to identify a block in the LRU, which is shared between
+// multibuffers.
 typedef std::pair<MultiBuffer*, MultiBufferBlockId> MultiBufferGlobalBlockId;
 
 }  // namespace media
 
 namespace BASE_HASH_NAMESPACE {
 
 template <>
 struct hash<media::MultiBufferGlobalBlockId> {
   std::size_t operator()(const media::MultiBufferGlobalBlockId& key) const {
 // It would be nice if we could use intptr_t instead of int64_t here, but
@@ skipping 27 matching lines @@
 // When new readers are added, new data providers are created if
 // the new reader doesn't fall into the look-ahead region of
 // an existing data provider.
 
 // This is the size of the look-ahead region.
 const int kMaxWaitForWriterOffset = 5;
 
 // This is the size of the look-behind region.
 const int kMaxWaitForReaderOffset = 50;
 
-class MultiBuffer;
-
 // MultiBuffers are multi-reader multi-writer cache/buffers with
 // prefetching and pinning. Data is stored internally in ref-counted
 // blocks of identical size. |block_size_shift| is log2 of the block
 // size.
 //
 // Users should inherit this class and implement CreateWriter().
 // TODO(hubbe): Make the multibuffer respond to memory pressure.
 class MEDIA_BLINK_EXPORT MultiBuffer {
  public:
   // Interface for clients wishing to read data out of this cache.
@@ skipping 25 matching lines @@
     // Returns true if one (or more) blocks are
     // availble to read.
     virtual bool Available() const = 0;
 
     // Returns the next block. Only valid if Available()
     // returns true. Last block might be of a smaller size
     // and after the last block we will get an end-of-stream
     // DataBuffer.
     virtual scoped_refptr<DataBuffer> Read() = 0;
 
-    // |cb| is called every time Available() becomes true.
-    virtual void SetAvailableCallback(const base::Closure& cb) = 0;
-
     // Ask the data provider to stop giving us data.
     // 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:
@@ skipping 87 matching lines @@
   // function for applying multiple changes to the pinned ranges.
   void PinRanges(const IntervalMap<BlockId, int32_t>& ranges);
 
   // Increment max cache size by |size| (counted in blocks).
   void IncrementMaxSize(int32_t size);
 
   // Caller takes ownership of 'provider', cache will
   // not call it anymore.
   scoped_ptr<DataProvider> RemoveProvider(DataProvider* provider);
 
-  // Add a writer to this cache. Cache takes ownership and
-  // may choose to destroy it.
+  // Add a writer to this cache. Cache takes ownership, and may
+  // destroy |provider| later. (Not during this call.)
   void AddProvider(scoped_ptr<DataProvider> provider);
 
   // Transfer all data from |other| to this.
   void MergeFrom(MultiBuffer* other);
 
   // Accessors.
   const DataMap& map() const { return data_; }
   int32_t block_size_shift() const { return block_size_shift_; }
 
+  // Callback which notifies us that a data provider has
+  // some data for us. Also called when it might be appropriate
+  // for a provider in a deferred state to wake up.
+  void OnDataProviderEvent(DataProvider* provider);
+
  protected:
   // Create a new writer at |pos| and return it.
   // Users needs to implemement this method.
-  virtual DataProvider* CreateWriter(const BlockId& pos) = 0;
+  virtual scoped_ptr<DataProvider> CreateWriter(const BlockId& pos) = 0;
 
   virtual bool RangeSupported() const = 0;
 
+  // Called when the cache becomes empty. Implementations can use this
+  // as a signal for when we should free this object and any metadata
+  // that goes with it.
+  virtual void OnEmpty();
+
  private:
   // For testing.
   friend class TestMultiBuffer;
 
   enum ProviderState {
     ProviderStateDead,
     ProviderStateDefer,
     ProviderStateLoad
   };
 
   // Can be overriden for testing.
   virtual void Prune(size_t max_to_free);
 
   // Remove the given blocks from the multibuffer, called from
   // GlobalLRU::Prune().
   void ReleaseBlocks(const std::vector<MultiBufferBlockId>& blocks);
 
   // Figure out what state a writer at |pos| should be in.
   ProviderState SuggestProviderState(const BlockId& pos) const;
 
   // Returns true if a writer at |pos| is colliding with
   // output of another writer.
   bool ProviderCollision(const BlockId& pos) const;
 
   // Call NotifyAvailableRange(new_range) on all readers waiting
   // for a block in |observer_range|
   void NotifyAvailableRange(const Interval<MultiBufferBlockId>& observer_range,
                             const Interval<MultiBufferBlockId>& new_range);
 
-  // Callback which notifies us that a data provider has
-  // some data for us. Also called when it might be apprperiate
-  // for a provider in a deferred state to wake up.
-  void DataProviderEvent(DataProvider* provider);
-
   // Max number of blocks.
   int64_t max_size_;
 
   // log2 of block size.
   int32_t block_size_shift_;
 
   // Stores the actual data.
   DataMap data_;
 
   // Keeps track of readers waiting for data.
   std::map<MultiBufferBlockId, std::set<Reader*>> readers_;
 
   // Keeps track of writers by their position.
   // The writers are owned by this class.
-  // TODO(hubbe): Use ScopedPtrMap here. (must add upper/lower_bound first)
-  std::map<BlockId, DataProvider*> writer_index_;
+  std::map<BlockId, scoped_ptr<DataProvider>> writer_index_;
 
   // Gloabally shared LRU, decides which block to free next.
   scoped_refptr<GlobalLRU> lru_;
 
   // Keeps track of what blocks are pinned. If block p is pinned,
   // then pinned_[p] > 0. Pinned blocks cannot be freed and should not
   // be present in |lru_|.
   IntervalMap<BlockId, int32_t> pinned_;
 
   // present_[block] should be 1 for all blocks that are present
   // 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_;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_MULTIBUFFER_H_