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

media/cast/test/end2end_unittest.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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
@@ skipping 110 matching lines @@
 // Shim that turns forwards packets from a test::PacketPipe to a
 // PacketReceiverCallback.
 class LoopBackPacketPipe : public test::PacketPipe {
  public:
   explicit LoopBackPacketPipe(const PacketReceiverCallback& packet_receiver)
       : packet_receiver_(packet_receiver) {}
 
   ~LoopBackPacketPipe() final {}
 
   // PacketPipe implementations.
-  void Send(scoped_ptr<Packet> packet) final {
+  void Send(std::unique_ptr<Packet> packet) final {
     packet_receiver_.Run(std::move(packet));
   }
 
  private:
   PacketReceiverCallback packet_receiver_;
 };
 
 // Class that sends the packet direct from sender into the receiver with the
 // ability to drop packets between the two.
 //
 // TODO(miu): This should be reconciled/merged into
 // media/cast/test/loopback_transport.*.  It's roughly the same class and has
 // exactly the same name (and when it was outside of the anonymous namespace bad
 // things happened when linking on Android!).
 class LoopBackTransport : public PacketTransport {
  public:
   explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
       : send_packets_(true),
         drop_packets_belonging_to_odd_frames_(false),
         cast_environment_(cast_environment),
         bytes_sent_(0) {}
 
   void SetPacketReceiver(
       const PacketReceiverCallback& packet_receiver,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::TickClock* clock) {
-    scoped_ptr<test::PacketPipe> loopback_pipe(
+    std::unique_ptr<test::PacketPipe> loopback_pipe(
         new LoopBackPacketPipe(packet_receiver));
     if (packet_pipe_) {
       packet_pipe_->AppendToPipe(std::move(loopback_pipe));
     } else {
       packet_pipe_ = std::move(loopback_pipe);
     }
     packet_pipe_->InitOnIOThread(task_runner, clock);
   }
 
   bool SendPacket(PacketRef packet, const base::Closure& cb) final {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_)
       return true;
 
     bytes_sent_ += packet->data.size();
     if (drop_packets_belonging_to_odd_frames_) {
       uint32_t frame_id = packet->data[13];
       if (frame_id % 2 == 1)
         return true;
     }
 
-    scoped_ptr<Packet> packet_copy(new Packet(packet->data));
+    std::unique_ptr<Packet> packet_copy(new Packet(packet->data));
     packet_pipe_->Send(std::move(packet_copy));
     return true;
   }
 
   int64_t GetBytesSent() final { return bytes_sent_; }
 
   void StartReceiving(
       const PacketReceiverCallbackWithStatus& packet_receiver) final {}
 
   void StopReceiving() final {}
 
   void SetSendPackets(bool send_packets) { send_packets_ = send_packets; }
 
   void DropAllPacketsBelongingToOddFrames() {
     drop_packets_belonging_to_odd_frames_ = true;
   }
 
-  void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) {
+  void SetPacketPipe(std::unique_ptr<test::PacketPipe> pipe) {
     // Append the loopback pipe to the end.
     pipe->AppendToPipe(std::move(packet_pipe_));
     packet_pipe_ = std::move(pipe);
   }
 
  private:
   bool send_packets_;
   bool drop_packets_belonging_to_odd_frames_;
   scoped_refptr<CastEnvironment> cast_environment_;
-  scoped_ptr<test::PacketPipe> packet_pipe_;
+  std::unique_ptr<test::PacketPipe> packet_pipe_;
   int64_t bytes_sent_;
 };
 
 // Class that verifies the audio frames coming out of the receiver.
 class TestReceiverAudioCallback
     : public base::RefCountedThreadSafe<TestReceiverAudioCallback> {
  public:
   struct ExpectedAudioFrame {
-    scoped_ptr<AudioBus> audio_bus;
+    std::unique_ptr<AudioBus> audio_bus;
     base::TimeTicks playout_time;
   };
 
   TestReceiverAudioCallback() : num_called_(0) {}
 
   void SetExpectedSamplingFrequency(int expected_sampling_frequency) {
     expected_sampling_frequency_ = expected_sampling_frequency;
   }
 
   void AddExpectedResult(const AudioBus& audio_bus,
                          const base::TimeTicks& playout_time) {
-    scoped_ptr<ExpectedAudioFrame> expected_audio_frame(
+    std::unique_ptr<ExpectedAudioFrame> expected_audio_frame(
         new ExpectedAudioFrame());
     expected_audio_frame->audio_bus =
         AudioBus::Create(audio_bus.channels(), audio_bus.frames());
     audio_bus.CopyTo(expected_audio_frame->audio_bus.get());
     expected_audio_frame->playout_time = playout_time;
     expected_frames_.push_back(expected_audio_frame.release());
   }
 
-  void IgnoreAudioFrame(scoped_ptr<AudioBus> audio_bus,
+  void IgnoreAudioFrame(std::unique_ptr<AudioBus> audio_bus,
                         const base::TimeTicks& playout_time,
                         bool is_continuous) {
     ++num_called_;
   }
 
-  void CheckAudioFrame(scoped_ptr<AudioBus> audio_bus,
+  void CheckAudioFrame(std::unique_ptr<AudioBus> audio_bus,
                        const base::TimeTicks& playout_time,
                        bool is_continuous) {
     ++num_called_;
 
     ASSERT_TRUE(audio_bus);
     ASSERT_FALSE(expected_frames_.empty());
-    const scoped_ptr<ExpectedAudioFrame> expected_audio_frame(
+    const std::unique_ptr<ExpectedAudioFrame> expected_audio_frame(
         expected_frames_.front());
     expected_frames_.pop_front();
 
     EXPECT_EQ(audio_bus->channels(), kAudioChannels);
     EXPECT_EQ(audio_bus->frames(), expected_audio_frame->audio_bus->frames());
     for (int ch = 0; ch < audio_bus->channels(); ++ch) {
       EXPECT_NEAR(CountZeroCrossings(
                       expected_audio_frame->audio_bus->channel(ch),
                       expected_audio_frame->audio_bus->frames()),
                   CountZeroCrossings(audio_bus->channel(ch),
@@ skipping 105 matching lines @@
   std::list<ExpectedVideoFrame> expected_frame_;
   base::TimeTicks last_playout_time_;
 };
 
 }  // namespace
 
 // The actual test class, generate synthetic data for both audio and video and
 // send those through the sender and receiver and analyzes the result.
 class End2EndTest : public ::testing::Test {
  public:
-  void ReceivePacket(scoped_ptr<media::cast::Packet> packet) {
+  void ReceivePacket(std::unique_ptr<media::cast::Packet> packet) {
     cast_receiver_->ReceivePacket(std::move(packet));
   };
 
  protected:
   End2EndTest()
       : start_time_(),
         task_runner_(new FakeSingleThreadTaskRunner(&testing_clock_)),
         testing_clock_sender_(new test::SkewedTickClock(&testing_clock_)),
         task_runner_sender_(
             new test::SkewedSingleThreadTaskRunner(task_runner_)),
         testing_clock_receiver_(new test::SkewedTickClock(&testing_clock_)),
         task_runner_receiver_(
             new test::SkewedSingleThreadTaskRunner(task_runner_)),
         cast_environment_sender_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_sender_),
+            std::unique_ptr<base::TickClock>(testing_clock_sender_),
             task_runner_sender_,
             task_runner_sender_,
             task_runner_sender_)),
         cast_environment_receiver_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_receiver_),
+            std::unique_ptr<base::TickClock>(testing_clock_receiver_),
             task_runner_receiver_,
             task_runner_receiver_,
             task_runner_receiver_)),
         receiver_to_sender_(new LoopBackTransport(cast_environment_receiver_)),
         sender_to_receiver_(new LoopBackTransport(cast_environment_sender_)),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->logger()->Subscribe(&event_subscriber_sender_);
@@ skipping 75 matching lines @@
   void SetExpectedVideoPlayoutSmoothness(base::TimeDelta min_delta,
                                          base::TimeDelta max_delta,
                                          base::TimeDelta max_curvature) {
     min_video_playout_delta_ = min_delta;
     max_video_playout_delta_ = max_delta;
     max_video_playout_curvature_ = max_curvature;
   }
 
   void FeedAudioFrames(int count, bool will_be_checked) {
     for (int i = 0; i < count; ++i) {
-      scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
+      std::unique_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
           base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs)));
       const base::TimeTicks reference_time =
           testing_clock_sender_->NowTicks() +
               i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs);
       if (will_be_checked) {
         test_receiver_audio_callback_->AddExpectedResult(
             *audio_bus,
             reference_time +
                 base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs));
       }
       audio_frame_input_->InsertAudio(std::move(audio_bus), reference_time);
     }
   }
 
   void FeedAudioFramesWithExpectedDelay(int count,
                                         const base::TimeDelta& delay) {
     for (int i = 0; i < count; ++i) {
-      scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
+      std::unique_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
           base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs)));
       const base::TimeTicks reference_time =
           testing_clock_sender_->NowTicks() +
               i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs);
       test_receiver_audio_callback_->AddExpectedResult(
           *audio_bus,
           reference_time + delay +
               base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs));
       audio_frame_input_->InsertAudio(std::move(audio_bus), reference_time);
     }
@@ skipping 253 matching lines @@
     last_video_playout_time_ = playout_time;
 
     video_ticks_.push_back(std::make_pair(
         testing_clock_receiver_->NowTicks(),
         playout_time));
     cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&End2EndTest::BasicPlayerGotVideoFrame,
                    base::Unretained(this)));
   }
 
-  void BasicPlayerGotAudioFrame(scoped_ptr<AudioBus> audio_bus,
+  void BasicPlayerGotAudioFrame(std::unique_ptr<AudioBus> audio_bus,
                                 const base::TimeTicks& playout_time,
                                 bool is_continuous) {
     VLOG_IF(1, !last_audio_playout_time_.is_null())
         << "Audio frame playout time delta (compared to last frame) is "
         << (playout_time - last_audio_playout_time_).InMicroseconds()
         << " usec.";
     last_audio_playout_time_ = playout_time;
 
     audio_ticks_.push_back(std::make_pair(
         testing_clock_receiver_->NowTicks(),
@@ skipping 36 matching lines @@
   base::TimeTicks last_video_playout_time_;
   base::TimeDelta last_video_playout_delta_;
   base::TimeTicks last_audio_playout_time_;
 
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport* receiver_to_sender_;  // Owned by CastTransport.
   LoopBackTransport* sender_to_receiver_;  // Owned by CastTransport.
 
-  scoped_ptr<CastTransportImpl> transport_sender_;
-  scoped_ptr<CastTransportImpl> transport_receiver_;
+  std::unique_ptr<CastTransportImpl> transport_sender_;
+  std::unique_ptr<CastTransportImpl> transport_receiver_;
 
-  scoped_ptr<CastReceiver> cast_receiver_;
-  scoped_ptr<CastSender> cast_sender_;
+  std::unique_ptr<CastReceiver> cast_receiver_;
+  std::unique_ptr<CastSender> cast_sender_;
   scoped_refptr<AudioFrameInput> audio_frame_input_;
   scoped_refptr<VideoFrameInput> video_frame_input_;
 
   scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
   scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
 
-  scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
+  std::unique_ptr<TestAudioBusFactory> audio_bus_factory_;
 
   SimpleEventSubscriber event_subscriber_sender_;
 
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
 
   // |transport_sender_| has a RepeatingTimer which needs a MessageLoop.
   base::MessageLoop message_loop_;
 };
 
 namespace {
 
 class TransportClient : public CastTransport::Client {
  public:
   TransportClient(LogEventDispatcher* log_event_dispatcher,
                   End2EndTest* e2e_test)
       : log_event_dispatcher_(log_event_dispatcher), e2e_test_(e2e_test) {}
 
   void OnStatusChanged(media::cast::CastTransportStatus status) final {
     bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
                    status == TRANSPORT_VIDEO_INITIALIZED);
     EXPECT_TRUE(result);
   };
   void OnLoggingEventsReceived(
-      scoped_ptr<std::vector<FrameEvent>> frame_events,
-      scoped_ptr<std::vector<PacketEvent>> packet_events) final {
+      std::unique_ptr<std::vector<FrameEvent>> frame_events,
+      std::unique_ptr<std::vector<PacketEvent>> packet_events) final {
     log_event_dispatcher_->DispatchBatchOfEvents(std::move(frame_events),
                                                  std::move(packet_events));
   };
-  void ProcessRtpPacket(scoped_ptr<Packet> packet) final {
+  void ProcessRtpPacket(std::unique_ptr<Packet> packet) final {
     if (e2e_test_)
       e2e_test_->ReceivePacket(std::move(packet));
   };
 
  private:
   LogEventDispatcher* const log_event_dispatcher_;  // Not owned by this class.
   End2EndTest* const e2e_test_;                     // Not owned by this class.
 
   DISALLOW_COPY_AND_ASSIGN(TransportClient);
 };
 
 }  // namespace
 
 void End2EndTest::Create() {
   transport_sender_.reset(new CastTransportImpl(
       testing_clock_sender_, base::TimeDelta::FromMilliseconds(1),
-      make_scoped_ptr(
+      base::WrapUnique(
           new TransportClient(cast_environment_sender_->logger(), nullptr)),
-      make_scoped_ptr(sender_to_receiver_), task_runner_sender_));
+      base::WrapUnique(sender_to_receiver_), task_runner_sender_));
 
   transport_receiver_.reset(new CastTransportImpl(
       testing_clock_sender_, base::TimeDelta::FromMilliseconds(1),
-      make_scoped_ptr(
+      base::WrapUnique(
           new TransportClient(cast_environment_receiver_->logger(), this)),
-      make_scoped_ptr(receiver_to_sender_), task_runner_sender_));
+      base::WrapUnique(receiver_to_sender_), task_runner_sender_));
 
   cast_receiver_ =
       CastReceiver::Create(cast_environment_receiver_, audio_receiver_config_,
                            video_receiver_config_, transport_receiver_.get());
 
   cast_sender_ =
       CastSender::Create(cast_environment_sender_, transport_sender_.get());
 
   // Initializing audio and video senders.
   cast_sender_->InitializeAudio(audio_sender_config_,
@@ skipping 258 matching lines @@
   EXPECT_LT(static_cast<size_t>(kLongTestIterations / 100),
             video_ticks_.size());
   EXPECT_GE(static_cast<size_t>(kLongTestIterations / 3), video_ticks_.size());
   VLOG(1) << "Fully transmitted " << video_ticks_.size() << " frames.";
   EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 TEST_F(End2EndTest, OldPacketNetwork) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
   sender_to_receiver_->SetPacketPipe(test::NewRandomDrop(0.01));
-  scoped_ptr<test::PacketPipe> echo_chamber(
+  std::unique_ptr<test::PacketPipe> echo_chamber(
       test::NewDuplicateAndDelay(1, 10 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 20 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 40 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 80 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 160 * kFrameTimerMs));
 
@@ skipping 49 matching lines @@
       EXPECT_EQ(0u, jump);
       jump = i;
     }
   }
   EXPECT_GT(jump, 49u);
   EXPECT_LT(jump, 120u);
 }
 
 }  // namespace cast
 }  // namespace media