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

media/base/audio_splicer.cc

 // 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.
 
 #include "media/base/audio_splicer.h"
 
 #include <stdint.h>
 #include <cstdlib>
 #include <deque>
 #include <utility>
@@ skipping 29 matching lines @@
 // AudioBuffer::TrimStart() is not as accurate as the timestamp helper, so
 // manually adjust the duration and timestamp after trimming.
 void AccurateTrimStart(int frames_to_trim,
                        const scoped_refptr<AudioBuffer> buffer,
                        const AudioTimestampHelper& timestamp_helper) {
   buffer->TrimStart(frames_to_trim);
   buffer->set_timestamp(timestamp_helper.GetTimestamp());
 }
 
 // Returns an AudioBus whose frame buffer is backed by the provided AudioBuffer.
-scoped_ptr<AudioBus> CreateAudioBufferWrapper(
+std::unique_ptr<AudioBus> CreateAudioBufferWrapper(
     const scoped_refptr<AudioBuffer>& buffer) {
-  scoped_ptr<AudioBus> wrapper =
+  std::unique_ptr<AudioBus> wrapper =
       AudioBus::CreateWrapper(buffer->channel_count());
   wrapper->set_frames(buffer->frame_count());
   for (int ch = 0; ch < buffer->channel_count(); ++ch) {
     wrapper->SetChannelData(
         ch, reinterpret_cast<float*>(buffer->channel_data()[ch]));
   }
   return wrapper;
 }
 
 }  // namespace
@@ skipping 305 matching lines @@
     return true;
   }
 
   // Wait until we have enough data to crossfade or end of stream.
   if (!input->end_of_stream() &&
       input->timestamp() + input->duration() < max_splice_end_timestamp_) {
     return true;
   }
 
   scoped_refptr<AudioBuffer> crossfade_buffer;
-  scoped_ptr<AudioBus> pre_splice =
+  std::unique_ptr<AudioBus> pre_splice =
       ExtractCrossfadeFromPreSplice(&crossfade_buffer);
 
   // Crossfade the pre splice and post splice sections and transfer all relevant
   // buffers into |output_sanitizer_|.
   CrossfadePostSplice(std::move(pre_splice), crossfade_buffer);
 
   // Clear the splice timestamp so new splices can be accepted.
   reset_splice_timestamps();
   return true;
 }
@@ skipping 22 matching lines @@
   // data from the last one.  Leave this as a CHECK for now to figure out if
   // this case is possible.
   CHECK(splice_timestamp_ == kNoTimestamp());
   splice_timestamp_ = splice_timestamp;
   max_splice_end_timestamp_ = splice_timestamp_ + max_crossfade_duration_;
   pre_splice_sanitizer_->Reset();
   post_splice_sanitizer_->Reset();
   have_all_pre_splice_buffers_ = false;
 }
 
-scoped_ptr<AudioBus> AudioSplicer::ExtractCrossfadeFromPreSplice(
+std::unique_ptr<AudioBus> AudioSplicer::ExtractCrossfadeFromPreSplice(
     scoped_refptr<AudioBuffer>* crossfade_buffer) {
   DCHECK(crossfade_buffer);
   const AudioTimestampHelper& output_ts_helper =
       output_sanitizer_->timestamp_helper();
 
   int frames_before_splice =
       output_ts_helper.GetFramesToTarget(splice_timestamp_);
 
   // Determine crossfade frame count based on available frames in each splicer
   // and capping to the maximum crossfade duration.
   const int max_crossfade_frame_count =
       output_ts_helper.GetFramesToTarget(max_splice_end_timestamp_) -
       frames_before_splice;
   const int frames_to_crossfade = std::min(
       max_crossfade_frame_count,
       std::min(pre_splice_sanitizer_->GetFrameCount() - frames_before_splice,
                post_splice_sanitizer_->GetFrameCount()));
   // There must always be frames to crossfade, otherwise the splice should not
   // have been generated.
   DCHECK_GT(frames_to_crossfade, 0);
 
   int frames_read = 0;
-  scoped_ptr<AudioBus> output_bus;
+  std::unique_ptr<AudioBus> output_bus;
   while (pre_splice_sanitizer_->HasNextBuffer() &&
          frames_read < frames_to_crossfade) {
     scoped_refptr<AudioBuffer> preroll = pre_splice_sanitizer_->GetNextBuffer();
 
     // We don't know the channel count until we see the first buffer, so wait
     // until the first buffer to allocate the output AudioBus.
     if (!output_bus) {
       output_bus =
           AudioBus::Create(preroll->channel_count(), frames_to_crossfade);
       // Allocate output buffer for crossfade.
@@ skipping 39 matching lines @@
   CHECK(crossfade_buffer->get());
 
   // All necessary buffers have been processed, it's safe to reset.
   pre_splice_sanitizer_->Reset();
   DCHECK_EQ(output_bus->frames(), frames_read);
   DCHECK_EQ(output_ts_helper.GetFramesToTarget(splice_timestamp_), 0);
   return output_bus;
 }
 
 void AudioSplicer::CrossfadePostSplice(
-    scoped_ptr<AudioBus> pre_splice_bus,
+    std::unique_ptr<AudioBus> pre_splice_bus,
     const scoped_refptr<AudioBuffer>& crossfade_buffer) {
   // Use the calculated timestamp and duration to ensure there's no extra gaps
   // or overlaps to process when adding the buffer to |output_sanitizer_|.
   const AudioTimestampHelper& output_ts_helper =
       output_sanitizer_->timestamp_helper();
   crossfade_buffer->set_timestamp(output_ts_helper.GetTimestamp());
 
   // AudioBuffer::ReadFrames() only allows output into an AudioBus, so wrap
   // our AudioBuffer in one so we can avoid extra data copies.
-  scoped_ptr<AudioBus> output_bus = CreateAudioBufferWrapper(crossfade_buffer);
+  std::unique_ptr<AudioBus> output_bus =
+      CreateAudioBufferWrapper(crossfade_buffer);
 
   // Extract crossfade section from the |post_splice_sanitizer_|.
   int frames_read = 0, frames_to_trim = 0;
   scoped_refptr<AudioBuffer> remainder;
   while (post_splice_sanitizer_->HasNextBuffer() &&
          frames_read < output_bus->frames()) {
     scoped_refptr<AudioBuffer> postroll =
         post_splice_sanitizer_->GetNextBuffer();
     const int frames_to_read =
         std::min(postroll->frame_count(), output_bus->frames() - frames_read);
@@ skipping 26 matching lines @@
     AccurateTrimStart(frames_to_trim, remainder, output_ts_helper);
     CHECK(output_sanitizer_->AddInput(remainder));
   }
 
   // Transfer all remaining buffers out and reset once empty.
   CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
   post_splice_sanitizer_->Reset();
 }
 
 }  // namespace media