Tie multibuffers to URLs

media/blink/multibuffer_unittest.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 <deque>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "media/blink/multibuffer.h"
 #include "media/blink/multibuffer_reader.h"
 #include "media/blink/test_random.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int kBlockSizeShift = 8;
 const size_t kBlockSize = 1UL << kBlockSizeShift;
 
 namespace media {
-class TestMultiBufferDataProvider;
 
-std::vector<TestMultiBufferDataProvider*> writers;
+class FakeMultiBufferDataProvider;
 
-class TestMultiBufferDataProvider : public media::MultiBuffer::DataProvider {
+std::vector<FakeMultiBufferDataProvider*> writers;

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

move this to an anonymous or internal namespace?

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

Done.

+
+class FakeMultiBufferDataProvider : public media::MultiBuffer::DataProvider {
  public:
-  TestMultiBufferDataProvider(MultiBufferBlockId pos,
+  FakeMultiBufferDataProvider(MultiBufferBlockId pos,
                               size_t file_size,
                               int max_blocks_after_defer,
-                              bool must_read_whole_file)
+                              bool must_read_whole_file,
+                              MultiBuffer* multibuffer)
       : pos_(pos),
         blocks_until_deferred_(1 << 30),
         max_blocks_after_defer_(max_blocks_after_defer),
         file_size_(file_size),
-        must_read_whole_file_(must_read_whole_file) {
+        must_read_whole_file_(must_read_whole_file),
+        multibuffer_(multibuffer) {
     writers.push_back(this);
   }
 
-  ~TestMultiBufferDataProvider() override {
+  ~FakeMultiBufferDataProvider() override {
     if (must_read_whole_file_) {
       CHECK_GE(pos_ * kBlockSize, file_size_);
     }
     for (size_t i = 0; i < writers.size(); i++) {
       if (writers[i] == this) {
         writers[i] = writers.back();
         writers.pop_back();
         return;
       }
     }
     LOG(FATAL) << "Couldn't find myself in writers!";
   }
 
   MultiBufferBlockId Tell() const override { return pos_; }
 
   bool Available() const override { return !fifo_.empty(); }
 
   scoped_refptr<DataBuffer> Read() override {
     DCHECK(Available());
     scoped_refptr<DataBuffer> ret = fifo_.front();
     fifo_.pop_front();
     ++pos_;
     return ret;
   }
 
-  void SetAvailableCallback(const base::Closure& cb) override {
-    DCHECK(!Available());
-    cb_ = cb;
-  }
-
   void SetDeferred(bool deferred) override {
     if (deferred) {
       if (max_blocks_after_defer_ > 0) {
         blocks_until_deferred_ = rand() % max_blocks_after_defer_;
       } else if (max_blocks_after_defer_ < 0) {
         blocks_until_deferred_ = -max_blocks_after_defer_;
       } else {
         blocks_until_deferred_ = 0;
       }
     } else {
@@ skipping 15 matching lines @@
         break;
       block->writable_data()[x] =
           static_cast<uint8_t>((byte_pos * 15485863) >> 16);
     }
     block->set_data_size(static_cast<int>(x));
     fifo_.push_back(block);
     if (byte_pos == file_size_) {
       fifo_.push_back(DataBuffer::CreateEOSBuffer());
       ret = false;
     }
-    cb_.Run();
+    multibuffer_->DataProviderEvent(this);
     return ret;
   }
 
  private:
   std::deque<scoped_refptr<media::DataBuffer>> fifo_;
   MultiBufferBlockId pos_;
   int32_t blocks_until_deferred_;
   int32_t max_blocks_after_defer_;
   size_t file_size_;
   bool must_read_whole_file_;
-  base::Closure cb_;
+  MultiBuffer* multibuffer_;
 };
 
 class TestMultiBuffer : public media::MultiBuffer {
  public:
   explicit TestMultiBuffer(
       int32_t shift,
       const scoped_refptr<media::MultiBuffer::GlobalLRU>& lru)
       : media::MultiBuffer(shift, lru),
         range_supported_(false),
         create_ok_(true),
@@ skipping 50 matching lines @@
 
   int32_t writers_created() const { return writers_created_; }
 
   void SetRangeSupported(bool supported) { range_supported_ = supported; }
 
  protected:
   DataProvider* CreateWriter(const MultiBufferBlockId& pos) override {
     DCHECK(create_ok_);
     writers_created_++;
     CHECK_LT(writers.size(), max_writers_);
-    return new TestMultiBufferDataProvider(
-        pos, file_size_, max_blocks_after_defer_, must_read_whole_file_);
+    return new FakeMultiBufferDataProvider(
+        pos, file_size_, max_blocks_after_defer_, must_read_whole_file_, this);
   }
   void Prune(size_t max_to_free) override {
     // Prune should not cause additional writers to be spawned.
     create_ok_ = false;
     MultiBuffer::Prune(max_to_free);
     create_ok_ = true;
   }
 
   bool RangeSupported() const override { return range_supported_; }
 
  private:
   bool range_supported_;
   bool create_ok_;
   size_t max_writers_;
   size_t file_size_;
   int32_t max_blocks_after_defer_;
   bool must_read_whole_file_;
   int32_t writers_created_;
 };
-}
+
+}  // namespace media
 
 class MultiBufferTest : public testing::Test {
  public:
   MultiBufferTest()
       : lru_(new media::MultiBuffer::GlobalLRU()),
         multibuffer_(kBlockSizeShift, lru_),
         rnd_(42) {}
 
   void Advance() {
     CHECK(media::writers.size());
@@ skipping 274 matching lines @@
       read_helpers[j]->StartRead();
       multibuffer_.CheckLRUState();
     }
   }
   multibuffer_.CheckPresentState();
   while (!read_helpers.empty()) {
     delete read_helpers.back();
     read_helpers.pop_back();
   }
 }