Convert //media/blink from scoped_ptr to std::unique_ptr

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"
 #include "base/location.h"
@@ skipping 281 matching lines @@
         NotifyAvailableRange(j.interval(), j.interval());
       }
     }
   }
   if (data_.empty())
     OnEmpty();
 }
 
 void MultiBuffer::OnEmpty() {}
 
-void MultiBuffer::AddProvider(scoped_ptr<DataProvider> provider) {
+void MultiBuffer::AddProvider(std::unique_ptr<DataProvider> provider) {
   // If there is already a provider in the same location, we delete it.
   DCHECK(!provider->Available());
   BlockId pos = provider->Tell();
   writer_index_[pos] = std::move(provider);
 }
 
-scoped_ptr<MultiBuffer::DataProvider> MultiBuffer::RemoveProvider(
+std::unique_ptr<MultiBuffer::DataProvider> MultiBuffer::RemoveProvider(
     DataProvider* provider) {
   BlockId pos = provider->Tell();
   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);
+  std::unique_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.
@@ skipping 30 matching lines @@
     return true;
 
   return false;
 }
 
 void MultiBuffer::Prune(size_t max_to_free) {
   lru_->Prune(max_to_free);
 }
 
 void MultiBuffer::OnDataProviderEvent(DataProvider* provider_tmp) {
-  scoped_ptr<DataProvider> provider(RemoveProvider(provider_tmp));
+  std::unique_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(std::move(provider));
       break;
     }
@@ skipping 135 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