Replace scoped_ptr with std::unique_ptr in //media/base.

media/base/audio_splicer.h

 // Copyright (c) 2012 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_BASE_AUDIO_SPLICER_H_
 #define MEDIA_BASE_AUDIO_SPLICER_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/media_export.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 class AudioBuffer;
 class AudioBus;
 class AudioStreamSanitizer;
@@ skipping 50 matching lines @@
   // Extracts frames to be crossfaded from |pre_splice_sanitizer_|.  Transfers
   // all frames before |splice_timestamp_| into |output_sanitizer_| and drops
   // frames outside of the crossfade duration.
   //
   // The size of the returned AudioBus is the crossfade duration in frames.
   // Crossfade duration is calculated based on the number of frames available
   // after |splice_timestamp_| in each sanitizer and capped by
   // |max_crossfade_duration_|.
   //
   // |pre_splice_sanitizer_| will be empty after this operation.
-  scoped_ptr<AudioBus> ExtractCrossfadeFromPreSplice(
+  std::unique_ptr<AudioBus> ExtractCrossfadeFromPreSplice(
       scoped_refptr<AudioBuffer>* crossfade_buffer);
 
   // Crossfades |pre_splice_bus->frames()| frames from
   // |post_splice_sanitizer_|
   // with those from |pre_splice_bus|.  Adds the crossfaded buffer to
   // |output_sanitizer_| along with all buffers in |post_splice_sanitizer_|.
   //
   // |post_splice_sanitizer_| will be empty after this operation.
-  void CrossfadePostSplice(scoped_ptr<AudioBus> pre_splice_bus,
+  void CrossfadePostSplice(std::unique_ptr<AudioBus> pre_splice_bus,
                            const scoped_refptr<AudioBuffer>& crossfade_buffer);
 
   // Reset the splice and splice end timestamps.
   void reset_splice_timestamps() {
     splice_timestamp_ = max_splice_end_timestamp_ = kNoTimestamp();
   }
 
   const base::TimeDelta max_crossfade_duration_;
   base::TimeDelta splice_timestamp_;
   base::TimeDelta max_splice_end_timestamp_;
 
   // The various sanitizers for each stage of the crossfade process.  Buffers in
   // |output_sanitizer_| are immediately available for consumption by external
   // callers.
   //
   // Overlapped buffers go into the |pre_splice_sanitizer_| while overlapping
   // buffers go into the |post_splice_sanitizer_|.  Once enough buffers for
   // crossfading are received the pre and post sanitizers are drained into
   // |output_sanitizer_| by the two ExtractCrossfadeFromXXX methods above.
   //
   // |pre_splice_sanitizer_| is not constructed until the first splice frame is
   // encountered.  At which point it is constructed based on the timestamp state
   // of |output_sanitizer_|.  It is destructed once the splice is finished.
-  scoped_ptr<AudioStreamSanitizer> output_sanitizer_;
-  scoped_ptr<AudioStreamSanitizer> pre_splice_sanitizer_;
-  scoped_ptr<AudioStreamSanitizer> post_splice_sanitizer_;
+  std::unique_ptr<AudioStreamSanitizer> output_sanitizer_;
+  std::unique_ptr<AudioStreamSanitizer> pre_splice_sanitizer_;
+  std::unique_ptr<AudioStreamSanitizer> post_splice_sanitizer_;
 
   // Whether all buffers which should go into |pre_splice_sanitizer_| have been
   // received.  If true, buffers should now be put in |post_splice_sanitizer_|.
   bool have_all_pre_splice_buffers_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AudioSplicer);
 };
 
 }  // namespace media
 
 #endif