Tie multibuffers to URLs

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"
 
 namespace media {
 
 // 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,
@@ skipping 91 matching lines @@
 }
 
 //
 // MultiBuffer
 //
 MultiBuffer::MultiBuffer(int32_t block_size_shift,
                          const scoped_refptr<GlobalLRU>& global_lru)
     : max_size_(0), block_size_shift_(block_size_shift), lru_(global_lru) {}
 
 MultiBuffer::~MultiBuffer() {
-  // Delete all writers.
-  for (const auto& i : writer_index_) {
-    delete i.second;
-  }
   // Remove all blocks from the LRU.
   for (const auto& i : data_) {
     lru_->Remove(this, i.first);
   }
   lru_->IncrementDataSize(-static_cast<int64_t>(data_.size()));
   lru_->IncrementMaxSize(-max_size_);
 }
 
 void MultiBuffer::AddReader(const BlockId& pos, Reader* reader) {
   std::set<Reader*>* set_of_readers = &readers_[pos];
@@ skipping 18 matching lines @@
       closest_block = pos;
     } else if (i == present_.begin()) {
       closest_block = -1;
     } else {
       closest_block = i.interval_begin() - 1;
     }
 
     // Make sure that there are no present blocks between the writer and
     // the requested position, as that will cause the writer to quit.
     if (closest_writer > closest_block) {
-      provider = writer_index_[closest_writer];
+      provider = writer_index_[closest_writer].get();
       DCHECK(provider);
     }
   }
   if (!provider) {
     DCHECK(writer_index_.find(pos) == writer_index_.end());
-    provider = writer_index_[pos] = CreateWriter(pos);
-    provider->SetAvailableCallback(base::Bind(
-        &MultiBuffer::DataProviderEvent, base::Unretained(this), provider));
+    writer_index_[pos] = CreateWriter(pos);
+    provider = writer_index_[pos].get();
   }
   provider->SetDeferred(false);
 }
 
 void MultiBuffer::RemoveReader(const BlockId& pos, Reader* reader) {
   auto i = readers_.find(pos);
   if (i == readers_.end())
     return;
   i->second.erase(reader);
   if (i->second.empty()) {
     readers_.erase(i);
   }
 }
 
 void MultiBuffer::CleanupWriters(const BlockId& pos) {
   BlockId p2 = pos + kMaxWaitForReaderOffset;
   BlockId closest_writer = ClosestPreviousEntry(writer_index_, p2);
   while (closest_writer > pos - kMaxWaitForWriterOffset) {
     DCHECK(writer_index_[closest_writer]);
-    DataProviderEvent(writer_index_[closest_writer]);
+    OnDataProviderEvent(writer_index_[closest_writer].get());
     closest_writer = ClosestPreviousEntry(writer_index_, closest_writer - 1);
   }
 }
 
 bool MultiBuffer::Contains(const BlockId& pos) const {
   DCHECK(present_[pos] == 0 || present_[pos] == 1)
       << " pos = " << pos << " present_[pos] " << present_[pos];
   DCHECK_EQ(present_[pos], data_.find(pos) != data_.end() ? 1 : 0);
   return !!present_[pos];
 }
@@ skipping 54 matching lines @@
       }
       if (i.interval_end() == freed_range.first.end) {
         // Notify the following range that it contains fewer blocks.
         auto j = i;
         ++j;
         DCHECK_EQ(j.value(), 1);
         NotifyAvailableRange(j.interval(), j.interval());
       }
     }
   }
+  if (data_.empty())
+    OnEmpty();
 }
 
+void MultiBuffer::OnEmpty() {}
+
 void MultiBuffer::AddProvider(scoped_ptr<DataProvider> provider) {
   // If there is already a provider in the same location, we delete it.
   DCHECK(!provider->Available());
   BlockId pos = provider->Tell();
-  DataProvider** place = &writer_index_[pos];
-  DCHECK_NE(*place, provider.get());
-  if (*place)
-    delete *place;
-  *place = provider.release();
+  writer_index_[pos] = std::move(provider);
 }
 
 scoped_ptr<MultiBuffer::DataProvider> MultiBuffer::RemoveProvider(
     DataProvider* provider) {
   BlockId pos = provider->Tell();
-  DCHECK_EQ(writer_index_[pos], provider);
-  writer_index_.erase(pos);
-  return scoped_ptr<DataProvider>(provider);
+  auto iter = writer_index_.find(pos);
+  DCHECK(iter != writer_index_.end());
+  DCHECK_EQ(iter->second.get(), provider);
+  scoped_ptr<DataProvider> ret = std::move(iter->second);
+  writer_index_.erase(iter);
+  return ret;
 }
 
 MultiBuffer::ProviderState MultiBuffer::SuggestProviderState(
     const BlockId& pos) const {
   MultiBufferBlockId next_reader_pos = ClosestNextEntry(readers_, pos);
   if (next_reader_pos != std::numeric_limits<MultiBufferBlockId>::max() &&
       (next_reader_pos - pos <= kMaxWaitForWriterOffset || !RangeSupported())) {
     // Check if there is another writer between us and the next reader.
     MultiBufferBlockId next_writer_pos =
         ClosestNextEntry(writer_index_, pos + 1);
@@ skipping 27 matching lines @@
   if (RangeSupported() && Contains(id))
     return true;
 
   return false;
 }
 
 void MultiBuffer::Prune(size_t max_to_free) {
   lru_->Prune(max_to_free);
 }
 
-void MultiBuffer::DataProviderEvent(DataProvider* provider_tmp) {
+void MultiBuffer::OnDataProviderEvent(DataProvider* provider_tmp) {
   scoped_ptr<DataProvider> provider(RemoveProvider(provider_tmp));
   BlockId start_pos = provider->Tell();
   BlockId pos = start_pos;
   bool eof = false;
   int64_t blocks_before = data_.size();
 
   while (!ProviderCollision(pos) && !eof) {
     if (!provider->Available()) {
-      AddProvider(provider.Pass());
+      AddProvider(std::move(provider));
       break;
     }
     DCHECK_GE(pos, 0);
     scoped_refptr<DataBuffer> data = provider->Read();
     data_[pos] = data;
     eof = data->end_of_stream();
     if (!pinned_[pos])
       lru_->Use(this, pos);
     ++pos;
   }
   int64_t blocks_after = data_.size();
   int64_t blocks_added = blocks_after - blocks_before;
 
   if (pos > start_pos) {
     present_.SetInterval(start_pos, pos, 1);
     Interval<BlockId> expanded_range = present_.find(start_pos).interval();
     NotifyAvailableRange(expanded_range, expanded_range);
 
     lru_->IncrementDataSize(blocks_added);
     Prune(blocks_added * kMaxFreesPerAdd + 1);
   }
 
   // Check that it's still there before we try to delete it.
   // In case of EOF or a collision, we might not have called AddProvider above.
   // Even if we did call AddProvider, calling NotifyAvailableRange can cause
   // readers to seek or self-destruct and clean up any associated writers.
   auto i = writer_index_.find(pos);
-  if (i != writer_index_.end() && i->second == provider_tmp) {
+  if (i != writer_index_.end() && i->second.get() == provider_tmp) {
     switch (SuggestProviderState(pos)) {
       case ProviderStateLoad:
         // Not sure we actually need to do this
         provider_tmp->SetDeferred(false);
         break;
       case ProviderStateDefer:
         provider_tmp->SetDeferred(true);
         break;
       case ProviderStateDead:
         RemoveProvider(provider_tmp);
@@ skipping 96 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