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

media/cast/test/simulator.cc

 // Copyright 2014 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.
 
 // Simulate end to end streaming.
 //
 // Input:
 // --source=
 //   WebM used as the source of video and audio frames.
 // --output=
@@ skipping 18 matching lines @@
 //   File path to write YUV decoded frames in YUV4MPEG2 format.
 // --no-simulation
 //   Do not run network simulation.
 //
 // Output:
 // - Raw event log of the simulation session tagged with the unique test ID,
 //   written out to the specified file path.
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/tick_clock.h"
 #include "base/values.h"
 #include "media/base/audio_bus.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/media.h"
@@ skipping 56 matching lines @@
 void LogAudioOperationalStatus(OperationalStatus status) {
   LOG(INFO) << "Audio status: " << status;
 }
 
 void LogVideoOperationalStatus(OperationalStatus status) {
   LOG(INFO) << "Video status: " << status;
 }
 
 struct PacketProxy {
   PacketProxy() : receiver(NULL) {}
-  void ReceivePacket(scoped_ptr<Packet> packet) {
+  void ReceivePacket(std::unique_ptr<Packet> packet) {
     if (receiver)
       receiver->ReceivePacket(std::move(packet));
   }
   CastReceiver* receiver;
 };
 
 class TransportClient : public CastTransport::Client {
  public:
   TransportClient(LogEventDispatcher* log_event_dispatcher,
                   PacketProxy* packet_proxy)
       : log_event_dispatcher_(log_event_dispatcher),
         packet_proxy_(packet_proxy) {}
 
   void OnStatusChanged(CastTransportStatus status) final {
     LOG(INFO) << "Cast transport status: " << status;
   };
   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 {
     DCHECK(log_event_dispatcher_);
     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 (packet_proxy_)
       packet_proxy_->ReceivePacket(std::move(packet));
   };
 
  private:
   LogEventDispatcher* const log_event_dispatcher_;  // Not owned by this class.
   PacketProxy* const packet_proxy_;                 // Not owned by this class.
 
   DISALLOW_COPY_AND_ASSIGN(TransportClient);
 };
@@ skipping 105 matching lines @@
         video_frame_tracker->PopOldestEncodedFrame();
     metrics_output->psnr.push_back(I420PSNR(src_frame, video_frame));
     metrics_output->ssim.push_back(I420SSIM(src_frame, video_frame));
   }
 
   if (!yuv_output.empty()) {
     AppendYuvToFile(yuv_output, video_frame);
   }
 }
 
-void GotAudioFrame(
-    int* counter,
-    CastReceiver* cast_receiver,
-    scoped_ptr<AudioBus> audio_bus,
-    const base::TimeTicks& playout_time,
-    bool is_continuous) {
+void GotAudioFrame(int* counter,
+                   CastReceiver* cast_receiver,
+                   std::unique_ptr<AudioBus> audio_bus,
+                   const base::TimeTicks& playout_time,
+                   bool is_continuous) {
   ++*counter;
   cast_receiver->RequestDecodedAudioFrame(
       base::Bind(&GotAudioFrame, counter, cast_receiver));
 }
 
 // Serialize |frame_events| and |packet_events| and append to the file
 // located at |output_path|.
 void AppendLogToFile(media::cast::proto::LogMetadata* metadata,
                      const media::cast::FrameEventList& frame_events,
                      const media::cast::PacketEventList& packet_events,
                      const base::FilePath& output_path) {
   media::cast::proto::GeneralDescription* gen_desc =
       metadata->mutable_general_description();
   gen_desc->set_product("Cast Simulator");
   gen_desc->set_product_version("0.1");
 
-  scoped_ptr<char[]> serialized_log(new char[media::cast::kMaxSerializedBytes]);
+  std::unique_ptr<char[]> serialized_log(
+      new char[media::cast::kMaxSerializedBytes]);
   int output_bytes;
   bool success = media::cast::SerializeEvents(*metadata,
                                               frame_events,
                                               packet_events,
                                               true,
                                               media::cast::kMaxSerializedBytes,
                                               serialized_log.get(),
                                               &output_bytes);
 
   if (!success) {
@@ skipping 19 matching lines @@
   // Fake clock. Make sure start time is non zero.
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromSeconds(1));
 
   // Task runner.
   scoped_refptr<FakeSingleThreadTaskRunner> task_runner =
       new FakeSingleThreadTaskRunner(&testing_clock);
   base::ThreadTaskRunnerHandle task_runner_handle(task_runner);
 
   // CastEnvironments.
-  scoped_refptr<CastEnvironment> sender_env = new CastEnvironment(
-      scoped_ptr<base::TickClock>(new test::SkewedTickClock(&testing_clock)),
-      task_runner, task_runner, task_runner);
-  scoped_refptr<CastEnvironment> receiver_env = new CastEnvironment(
-      scoped_ptr<base::TickClock>(new test::SkewedTickClock(&testing_clock)),
-      task_runner, task_runner, task_runner);
+  scoped_refptr<CastEnvironment> sender_env =
+      new CastEnvironment(std::unique_ptr<base::TickClock>(
+                              new test::SkewedTickClock(&testing_clock)),
+                          task_runner, task_runner, task_runner);
+  scoped_refptr<CastEnvironment> receiver_env =
+      new CastEnvironment(std::unique_ptr<base::TickClock>(
+                              new test::SkewedTickClock(&testing_clock)),
+                          task_runner, task_runner, task_runner);
 
   // Event subscriber. Store at most 1 hour of events.
   EncodingEventSubscriber audio_event_subscriber(AUDIO_EVENT,
                                                  100 * 60 * 60);
   EncodingEventSubscriber video_event_subscriber(VIDEO_EVENT,
                                                  30 * 60 * 60);
   sender_env->logger()->Subscribe(&audio_event_subscriber);
   sender_env->logger()->Subscribe(&video_event_subscriber);
 
   // Audio sender config.
@@ skipping 24 matching lines @@
   video_receiver_config.rtp_max_delay_ms =
       video_sender_config.max_playout_delay.InMilliseconds();
 
   // Loopback transport. Owned by CastTransport.
   LoopBackTransport* receiver_to_sender = new LoopBackTransport(receiver_env);
   LoopBackTransport* sender_to_receiver = new LoopBackTransport(sender_env);
 
   PacketProxy packet_proxy;
 
   // Cast receiver.
-  scoped_ptr<CastTransport> transport_receiver(
+  std::unique_ptr<CastTransport> transport_receiver(
       new CastTransportImpl(&testing_clock, base::TimeDelta::FromSeconds(1),
-                            make_scoped_ptr(new TransportClient(
+                            base::WrapUnique(new TransportClient(
                                 receiver_env->logger(), &packet_proxy)),
-                            make_scoped_ptr(receiver_to_sender), task_runner));
-  scoped_ptr<CastReceiver> cast_receiver(
-      CastReceiver::Create(receiver_env,
-                           audio_receiver_config,
-                           video_receiver_config,
-                           transport_receiver.get()));
+                            base::WrapUnique(receiver_to_sender), task_runner));
+  std::unique_ptr<CastReceiver> cast_receiver(
+      CastReceiver::Create(receiver_env, audio_receiver_config,
+                           video_receiver_config, transport_receiver.get()));
 
   packet_proxy.receiver = cast_receiver.get();
 
   // Cast sender and transport sender.
-  scoped_ptr<CastTransport> transport_sender(new CastTransportImpl(
+  std::unique_ptr<CastTransport> transport_sender(new CastTransportImpl(
       &testing_clock, base::TimeDelta::FromSeconds(1),
-      make_scoped_ptr(new TransportClient(sender_env->logger(), nullptr)),
-      make_scoped_ptr(sender_to_receiver), task_runner));
-  scoped_ptr<CastSender> cast_sender(
+      base::WrapUnique(new TransportClient(sender_env->logger(), nullptr)),
+      base::WrapUnique(sender_to_receiver), task_runner));
+  std::unique_ptr<CastSender> cast_sender(
       CastSender::Create(sender_env, transport_sender.get()));
 
   // Initialize network simulation model.
   const bool use_network_simulation =
       model.type() == media::cast::proto::INTERRUPTED_POISSON_PROCESS;
-  scoped_ptr<test::InterruptedPoissonProcess> ipp;
+  std::unique_ptr<test::InterruptedPoissonProcess> ipp;
   if (use_network_simulation) {
     LOG(INFO) << "Running Poisson based network simulation.";
     const IPPModel& ipp_model = model.ipp();
     std::vector<double> average_rates(ipp_model.average_rate_size());
     std::copy(ipp_model.average_rate().begin(),
               ipp_model.average_rate().end(),
               average_rates.begin());
     ipp.reset(new test::InterruptedPoissonProcess(
         average_rates,
         ipp_model.coef_burstiness(), ipp_model.coef_variance(), 0));
     receiver_to_sender->Initialize(ipp->NewBuffer(128 * 1024),
                                    transport_sender->PacketReceiverForTesting(),
                                    task_runner, &testing_clock);
     sender_to_receiver->Initialize(
         ipp->NewBuffer(128 * 1024),
         transport_receiver->PacketReceiverForTesting(), task_runner,
         &testing_clock);
   } else {
     LOG(INFO) << "No network simulation.";
-    receiver_to_sender->Initialize(scoped_ptr<test::PacketPipe>(),
+    receiver_to_sender->Initialize(std::unique_ptr<test::PacketPipe>(),
                                    transport_sender->PacketReceiverForTesting(),
                                    task_runner, &testing_clock);
     sender_to_receiver->Initialize(
-        scoped_ptr<test::PacketPipe>(),
+        std::unique_ptr<test::PacketPipe>(),
         transport_receiver->PacketReceiverForTesting(), task_runner,
         &testing_clock);
   }
 
   // Initialize a fake media source and a tracker to encoded video frames.
   const bool quality_test = !metrics_output_path.empty();
   FakeMediaSource media_source(task_runner,
                                &testing_clock,
                                audio_sender_config,
                                video_sender_config,
                                quality_test);
-  scoped_ptr<EncodedVideoFrameTracker> video_frame_tracker;
+  std::unique_ptr<EncodedVideoFrameTracker> video_frame_tracker;
   if (quality_test) {
     video_frame_tracker.reset(new EncodedVideoFrameTracker(&media_source));
     sender_env->logger()->Subscribe(video_frame_tracker.get());
   }
 
   // Quality metrics computed for each frame decoded.
   GotVideoFrameOutput metrics_output;
 
   // Start receiver.
   int audio_frame_count = 0;
@@ skipping 272 matching lines @@
   values.SetString("sim-id", sim_id);
 
   std::string extra_data;
   base::JSONWriter::Write(values, &extra_data);
 
   // Run.
   media::cast::RunSimulation(source_path, log_output_path, metrics_output_path,
                              yuv_output_path, extra_data, model);
   return 0;
 }