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

media/cast/test/simulator.cc

Index: media/cast/test/simulator.cc
diff --git a/media/cast/test/simulator.cc b/media/cast/test/simulator.cc
index e68e0e8e38eb00bd68a8a081d3d7ce2f28ce7c55..7044db8ea1c7094703bf5104644cfe8d45f318d3 100644
--- a/media/cast/test/simulator.cc
+++ b/media/cast/test/simulator.cc
@@ -36,6 +36,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/at_exit.h"
@@ -48,6 +49,7 @@
 #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"
@@ -124,7 +126,7 @@ void LogVideoOperationalStatus(OperationalStatus 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));
   }
@@ -142,13 +144,13 @@ class TransportClient : public CastTransport::Client {
     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));
   };
@@ -274,12 +276,11 @@ void GotVideoFrame(
   }
 }
 
-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));
@@ -296,7 +297,8 @@ void AppendLogToFile(media::cast::proto::LogMetadata* metadata,
   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,
@@ -336,12 +338,14 @@ void RunSimulation(const base::FilePath& source_path,
   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,
@@ -386,31 +390,29 @@ void RunSimulation(const base::FilePath& source_path,
   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();
@@ -430,11 +432,11 @@ void RunSimulation(const base::FilePath& source_path,
         &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);
   }
@@ -446,7 +448,7 @@ void RunSimulation(const base::FilePath& source_path,
                                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());