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

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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/hash.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.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.
@@ skipping 212 matching lines @@
 
   // Calls PinRange for each range in |ranges|, convenience
   // 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);
+  std::unique_ptr<DataProvider> RemoveProvider(DataProvider* provider);
 
   // Add a writer to this cache. Cache takes ownership, and may
   // destroy |provider| later. (Not during this call.)
-  void AddProvider(scoped_ptr<DataProvider> provider);
+  void AddProvider(std::unique_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 scoped_ptr<DataProvider> CreateWriter(const BlockId& pos) = 0;
+  virtual std::unique_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.
@@ skipping 31 matching lines @@
   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.
-  std::map<BlockId, scoped_ptr<DataProvider>> writer_index_;
+  std::map<BlockId, std::unique_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_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_MULTIBUFFER_H_