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 {
 
 typedef int32_t MultiBufferBlockId;

[xhwang, 2015/11/19 23:34:17]

Add a comment?

[hubbe, 2015/11/20 23:24:22]

Done.

 class MultiBuffer;
 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 {
@@ skipping 28 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;

[xhwang, 2015/11/19 23:34:17]

not needed?

[hubbe, 2015/11/20 23:24:22]

Done.

 
 // 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:
@@ skipping 26 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 apprperiate
+  // for a provider in a deferred state to wake up.
+  void DataProviderEvent(DataProvider* provider);

[xhwang, 2015/11/19 23:34:17]

In media/ callbacks are often called OnXxx, not sure whether OnDataProviderEvent
would make sense. Also "event" is vague. Can we make it more clear?
OnDataAvailable doesn't cover the wake up case... 

[hubbe, 2015/11/20 23:24:23]

OnDataProviderEvent() seems ok, can't think of something better right now...
Event here is used in the same sense as "event loop", but I'm not sure how to
make that clear either.

DataProviderHandler() ?
OnDataProviderNeedsToDoSomething() ?
DataProviderCallback() ?

+
  protected:
   // Create a new writer at |pos| and return it.
   // Users needs to implemement this method.
   virtual DataProvider* CreateWriter(const BlockId& pos) = 0;

[xhwang, 2015/11/19 23:34:17]

Who owns the created Writer? If the caller owns it, return a scoped_ptr?

[hubbe, 2015/11/20 23:24:22]

Done.

 
   virtual bool RangeSupported() const = 0;
+  virtual void OnEmpty();
 
  private:
   // For testing.
   friend class TestMultiBuffer;
 
   enum ProviderState {
     ProviderStateDead,
     ProviderStateDefer,
     ProviderStateLoad
   };
@@ skipping 10 matching lines @@
 
   // 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.
@@ skipping 14 matching lines @@
 
   // 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_