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

media/cast/test/receiver.cc

 // Copyright 2013 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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <climits>
 #include <cstdarg>
 #include <cstdio>
 #include <deque>
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/timer/timer.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/fake_audio_log_factory.h"
@@ skipping 194 matching lines @@
         base::Bind(&NaivePlayer::StopAudioOutputOnAudioManagerThread,
                    base::Unretained(this),
                    &done));
     done.Wait();
 
     // Now, stop receiving new frames.
     InProcessReceiver::Stop();
 
     // Finally, clear out any frames remaining in the queues.
     while (!audio_playout_queue_.empty()) {
-      const scoped_ptr<AudioBus> to_be_deleted(
+      const std::unique_ptr<AudioBus> to_be_deleted(
           audio_playout_queue_.front().second);
       audio_playout_queue_.pop_front();
     }
     video_playout_queue_.clear();
   }
 
  private:
   void StartAudioOutputOnAudioManagerThread() {
     DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
     DCHECK(!audio_output_stream_);
@@ skipping 31 matching lines @@
     ScheduleVideoPlayout();
     uint16_t frame_no;
     if (media::cast::test::DecodeBarcode(video_frame, &frame_no)) {
       video_play_times_.insert(
           std::pair<uint16_t, base::TimeTicks>(frame_no, playout_time));
     } else {
       VLOG(2) << "Barcode decode failed!";
     }
   }
 
-  void OnAudioFrame(scoped_ptr<AudioBus> audio_frame,
+  void OnAudioFrame(std::unique_ptr<AudioBus> audio_frame,
                     const base::TimeTicks& playout_time,
                     bool is_continuous) final {
     DCHECK(cast_env()->CurrentlyOn(CastEnvironment::MAIN));
     LOG_IF(WARNING, !is_continuous)
         << "Audio: Discontinuity in received frames.";
     base::AutoLock auto_lock(audio_lock_);
     uint16_t frame_no;
     if (media::cast::DecodeTimestamp(audio_frame->channel(0),
                                      audio_frame->frames(),
                                      &frame_no)) {
@@ skipping 143 matching lines @@
               << " usec later than intended.";
     }
 
     last_popped_video_playout_time_ = video_playout_queue_.front().first;
     const scoped_refptr<VideoFrame> ret = video_playout_queue_.front().second;
     video_playout_queue_.pop_front();
     ++num_video_frames_processed_;
     return ret;
   }
 
-  scoped_ptr<AudioBus> PopOneAudioFrame(bool was_skipped) {
+  std::unique_ptr<AudioBus> PopOneAudioFrame(bool was_skipped) {
     audio_lock_.AssertAcquired();
 
     if (was_skipped) {
       VLOG(1) << "AudioFrame[" << num_audio_frames_processed_
               << " (dt=" << (audio_playout_queue_.front().first -
                              last_popped_audio_playout_time_).InMicroseconds()
               << " usec)]: Skipped.";
     } else {
       VLOG(1) << "AudioFrame[" << num_audio_frames_processed_
               << " (dt=" << (audio_playout_queue_.front().first -
                              last_popped_audio_playout_time_).InMicroseconds()
               << " usec)]: Playing "
               << (cast_env()->Clock()->NowTicks() -
                       audio_playout_queue_.front().first).InMicroseconds()
               << " usec later than intended.";
     }
 
     last_popped_audio_playout_time_ = audio_playout_queue_.front().first;
-    scoped_ptr<AudioBus> ret(audio_playout_queue_.front().second);
+    std::unique_ptr<AudioBus> ret(audio_playout_queue_.front().second);
     audio_playout_queue_.pop_front();
     ++num_audio_frames_processed_;
     return ret;
   }
 
   void CheckAVSync() {
     if (video_play_times_.size() > 30 &&
         audio_play_times_.size() > 30) {
       size_t num_events = 0;
       base::TimeDelta delta;
@@ skipping 24 matching lines @@
   }
 
   // Frames in the queue older than this (relative to NowTicks()) will be
   // dropped (i.e., playback is falling behind).
   const base::TimeDelta max_frame_age_;
 
   // Outputs created, started, and destroyed by this NaivePlayer.
 #if defined(USE_X11)
   test::LinuxOutputWindow render_;
 #endif  // defined(USE_X11)
-  scoped_ptr<AudioOutputStream> audio_output_stream_;
+  std::unique_ptr<AudioOutputStream> audio_output_stream_;
 
   // Video playout queue.
   typedef std::pair<base::TimeTicks, scoped_refptr<VideoFrame> >
       VideoQueueEntry;
   std::deque<VideoQueueEntry> video_playout_queue_;
   base::TimeTicks last_popped_video_playout_time_;
   int64_t num_video_frames_processed_;
 
   base::OneShotTimer video_playout_timer_;
 
   // Audio playout queue, synchronized by |audio_lock_|.
   base::Lock audio_lock_;
   typedef std::pair<base::TimeTicks, AudioBus*> AudioQueueEntry;
   std::deque<AudioQueueEntry> audio_playout_queue_;
   base::TimeTicks last_popped_audio_playout_time_;
   int64_t num_audio_frames_processed_;
 
   // These must only be used on the audio thread calling OnMoreData().
-  scoped_ptr<AudioBus> currently_playing_audio_frame_;
+  std::unique_ptr<AudioBus> currently_playing_audio_frame_;
   int currently_playing_audio_frame_start_;
 
   std::map<uint16_t, base::TimeTicks> audio_play_times_;
   std::map<uint16_t, base::TimeTicks> video_play_times_;
   int32_t last_audio_frame_no_;
 };
 
 }  // namespace cast
 }  // namespace media
 
@@ skipping 51 matching lines @@
                                   audio_config,
                                   video_config,
                                   window_width,
                                   window_height);
   player.Start();
 
   message_loop.Run();  // Run forever (i.e., until SIGTERM).
   NOTREACHED();
   return 0;
 }