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

media/cast/test/sender.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.
 
 // Test application that simulates a cast sender - Data can be either generated
 // or read from a file.
 
 #include <stdint.h>
+
+#include <memory>
 #include <queue>
 #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/json/json_writer.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
 #include "media/base/media.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_sender.h"
@@ skipping 55 matching lines @@
   return net::IPEndPoint(ip_address, port);
 }
 
 void DumpLoggingData(const media::cast::proto::LogMetadata& log_metadata,
                      const media::cast::FrameEventList& frame_events,
                      const media::cast::PacketEventList& packet_events,
                      base::ScopedFILE log_file) {
   VLOG(0) << "Frame map size: " << frame_events.size();
   VLOG(0) << "Packet map size: " << packet_events.size();
 
-  scoped_ptr<char[]> event_log(new char[kMaxSerializedLogBytes]);
+  std::unique_ptr<char[]> event_log(new char[kMaxSerializedLogBytes]);
   int event_log_bytes;
   if (!media::cast::SerializeEvents(log_metadata,
                                     frame_events,
                                     packet_events,
                                     true,
                                     kMaxSerializedLogBytes,
                                     event_log.get(),
                                     &event_log_bytes)) {
     VLOG(0) << "Failed to serialize events.";
     return;
   }
 
   VLOG(0) << "Events serialized length: " << event_log_bytes;
 
   int ret = fwrite(event_log.get(), 1, event_log_bytes, log_file.get());
   if (ret != event_log_bytes)
     VLOG(0) << "Failed to write logs to file.";
 }
 
 void WriteLogsToFileAndDestroySubscribers(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
-    scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber,
-    scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber,
+    std::unique_ptr<media::cast::EncodingEventSubscriber>
+        video_event_subscriber,
+    std::unique_ptr<media::cast::EncodingEventSubscriber>
+        audio_event_subscriber,
     base::ScopedFILE video_log_file,
     base::ScopedFILE audio_log_file) {
   cast_environment->logger()->Unsubscribe(video_event_subscriber.get());
   cast_environment->logger()->Unsubscribe(audio_event_subscriber.get());
 
   VLOG(0) << "Dumping logging data for video stream.";
   media::cast::proto::LogMetadata log_metadata;
   media::cast::FrameEventList frame_events;
   media::cast::PacketEventList packet_events;
   video_event_subscriber->GetEventsAndReset(
       &log_metadata, &frame_events, &packet_events);
 
   DumpLoggingData(log_metadata, frame_events, packet_events,
                   std::move(video_log_file));
 
   VLOG(0) << "Dumping logging data for audio stream.";
   audio_event_subscriber->GetEventsAndReset(
       &log_metadata, &frame_events, &packet_events);
 
   DumpLoggingData(log_metadata, frame_events, packet_events,
                   std::move(audio_log_file));
 }
 
 void WriteStatsAndDestroySubscribers(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
-    scoped_ptr<media::cast::StatsEventSubscriber> video_stats_subscriber,
-    scoped_ptr<media::cast::StatsEventSubscriber> audio_stats_subscriber,
-    scoped_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl> estimator) {
+    std::unique_ptr<media::cast::StatsEventSubscriber> video_stats_subscriber,
+    std::unique_ptr<media::cast::StatsEventSubscriber> audio_stats_subscriber,
+    std::unique_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl> estimator) {
   cast_environment->logger()->Unsubscribe(video_stats_subscriber.get());
   cast_environment->logger()->Unsubscribe(audio_stats_subscriber.get());
   cast_environment->logger()->Unsubscribe(estimator.get());
 
-  scoped_ptr<base::DictionaryValue> stats = video_stats_subscriber->GetStats();
+  std::unique_ptr<base::DictionaryValue> stats =
+      video_stats_subscriber->GetStats();
   std::string json;
   base::JSONWriter::WriteWithOptions(
       *stats, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   VLOG(0) << "Video stats: " << json;
 
   stats = audio_stats_subscriber->GetStats();
   json.clear();
   base::JSONWriter::WriteWithOptions(
       *stats, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   VLOG(0) << "Audio stats: " << json;
 }
 
 class TransportClient : public media::cast::CastTransport::Client {
  public:
   explicit TransportClient(
       media::cast::LogEventDispatcher* log_event_dispatcher)
       : log_event_dispatcher_(log_event_dispatcher) {}
 
   void OnStatusChanged(media::cast::CastTransportStatus status) final {
     VLOG(1) << "Transport status: " << status;
   };
   void OnLoggingEventsReceived(
-      scoped_ptr<std::vector<media::cast::FrameEvent>> frame_events,
-      scoped_ptr<std::vector<media::cast::PacketEvent>> packet_events) final {
+      std::unique_ptr<std::vector<media::cast::FrameEvent>> frame_events,
+      std::unique_ptr<std::vector<media::cast::PacketEvent>> packet_events)
+      final {
     DCHECK(log_event_dispatcher_);
     log_event_dispatcher_->DispatchBatchOfEvents(std::move(frame_events),
                                                  std::move(packet_events));
   };
-  void ProcessRtpPacket(scoped_ptr<media::cast::Packet> packet) final {}
+  void ProcessRtpPacket(std::unique_ptr<media::cast::Packet> packet) final {}
 
  private:
   media::cast::LogEventDispatcher* const
       log_event_dispatcher_;  // Not owned by this class.
 
   DISALLOW_COPY_AND_ASSIGN(TransportClient);
 };
 
 }  // namespace
 
@@ skipping 34 matching lines @@
 
   // Running transport on the main thread.
   // Setting up transport config.
   net::IPEndPoint remote_endpoint =
       CreateUDPAddress(remote_ip_address, static_cast<uint16_t>(remote_port));
 
   // Enable raw event and stats logging.
   // Running transport on the main thread.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(
       new media::cast::CastEnvironment(
-          make_scoped_ptr<base::TickClock>(new base::DefaultTickClock()),
-          io_message_loop.task_runner(),
-          audio_thread.task_runner(),
+          base::WrapUnique<base::TickClock>(new base::DefaultTickClock()),
+          io_message_loop.task_runner(), audio_thread.task_runner(),
           video_thread.task_runner()));
 
   // SendProcess initialization.
-  scoped_ptr<media::cast::FakeMediaSource> fake_media_source(
+  std::unique_ptr<media::cast::FakeMediaSource> fake_media_source(
       new media::cast::FakeMediaSource(test_thread.task_runner(),
-                                       cast_environment->Clock(),
-                                       audio_config,
-                                       video_config,
-                                       false));
+                                       cast_environment->Clock(), audio_config,
+                                       video_config, false));
 
   int final_fps = 0;
   if (!base::StringToInt(cmd->GetSwitchValueASCII(kSwitchFps),
                          &final_fps)){
     final_fps = 0;
   }
   base::FilePath source_path = cmd->GetSwitchValuePath(kSwitchSourceFile);
   if (!source_path.empty()) {
     LOG(INFO) << "Source: " << source_path.value();
     fake_media_source->SetSourceFile(source_path, final_fps);
   }
   if (cmd->HasSwitch(kSwitchVaryFrameSizes))
     fake_media_source->SetVariableFrameSizeMode(true);
 
   // CastTransport initialization.
-  scoped_ptr<media::cast::CastTransport> transport_sender =
+  std::unique_ptr<media::cast::CastTransport> transport_sender =
       media::cast::CastTransport::Create(
           cast_environment->Clock(), base::TimeDelta::FromSeconds(1),
-          make_scoped_ptr(new TransportClient(cast_environment->logger())),
-          make_scoped_ptr(new media::cast::UdpTransport(
+          base::WrapUnique(new TransportClient(cast_environment->logger())),
+          base::WrapUnique(new media::cast::UdpTransport(
               nullptr, io_message_loop.task_runner(), net::IPEndPoint(),
               remote_endpoint, base::Bind(&UpdateCastTransportStatus))),
           io_message_loop.task_runner());
 
   // Set up event subscribers.
-  scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber;
-  scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber;
+  std::unique_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber;
+  std::unique_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber;
   std::string video_log_file_name("/tmp/video_events.log.gz");
   std::string audio_log_file_name("/tmp/audio_events.log.gz");
   LOG(INFO) << "Logging audio events to: " << audio_log_file_name;
   LOG(INFO) << "Logging video events to: " << video_log_file_name;
   video_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
       media::cast::VIDEO_EVENT, 10000));
   audio_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
       media::cast::AUDIO_EVENT, 10000));
   cast_environment->logger()->Subscribe(video_event_subscriber.get());
   cast_environment->logger()->Subscribe(audio_event_subscriber.get());
 
   // Subscribers for stats.
-  scoped_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl> offset_estimator(
-      new media::cast::ReceiverTimeOffsetEstimatorImpl());
+  std::unique_ptr<media::cast::ReceiverTimeOffsetEstimatorImpl>
+      offset_estimator(new media::cast::ReceiverTimeOffsetEstimatorImpl());
   cast_environment->logger()->Subscribe(offset_estimator.get());
-  scoped_ptr<media::cast::StatsEventSubscriber> video_stats_subscriber(
+  std::unique_ptr<media::cast::StatsEventSubscriber> video_stats_subscriber(
       new media::cast::StatsEventSubscriber(media::cast::VIDEO_EVENT,
                                             cast_environment->Clock(),
                                             offset_estimator.get()));
-  scoped_ptr<media::cast::StatsEventSubscriber> audio_stats_subscriber(
+  std::unique_ptr<media::cast::StatsEventSubscriber> audio_stats_subscriber(
       new media::cast::StatsEventSubscriber(media::cast::AUDIO_EVENT,
                                             cast_environment->Clock(),
                                             offset_estimator.get()));
   cast_environment->logger()->Subscribe(video_stats_subscriber.get());
   cast_environment->logger()->Subscribe(audio_stats_subscriber.get());
 
   base::ScopedFILE video_log_file(fopen(video_log_file_name.c_str(), "w"));
   if (!video_log_file) {
     VLOG(1) << "Failed to open video log file for writing.";
     exit(-1);
@@ skipping 19 matching lines @@
   io_message_loop.task_runner()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&WriteStatsAndDestroySubscribers,
                  cast_environment,
                  base::Passed(&video_stats_subscriber),
                  base::Passed(&audio_stats_subscriber),
                  base::Passed(&offset_estimator)),
       base::TimeDelta::FromSeconds(logging_duration_seconds));
 
   // CastSender initialization.
-  scoped_ptr<media::cast::CastSender> cast_sender =
+  std::unique_ptr<media::cast::CastSender> cast_sender =
       media::cast::CastSender::Create(cast_environment, transport_sender.get());
   io_message_loop.PostTask(
       FROM_HERE,
       base::Bind(&media::cast::CastSender::InitializeVideo,
                  base::Unretained(cast_sender.get()),
                  fake_media_source->get_video_config(),
                  base::Bind(&QuitLoopOnInitializationResult),
                  media::cast::CreateDefaultVideoEncodeAcceleratorCallback(),
                  media::cast::CreateDefaultVideoEncodeMemoryCallback()));
   io_message_loop.Run();  // Wait for video initialization.
   io_message_loop.PostTask(
       FROM_HERE,
       base::Bind(&media::cast::CastSender::InitializeAudio,
                  base::Unretained(cast_sender.get()),
                  audio_config,
                  base::Bind(&QuitLoopOnInitializationResult)));
   io_message_loop.Run();  // Wait for audio initialization.
 
   fake_media_source->Start(cast_sender->audio_frame_input(),
                            cast_sender->video_frame_input());
   io_message_loop.Run();
   return 0;
 }