Convert media/formats to std::unique_ptr

media/formats/mp2t/mp2t_stream_parser.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.
 
 #include "media/formats/mp2t/mp2t_stream_parser.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "media/base/media_tracks.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/formats/mp2t/es_parser.h"
@@ skipping 19 matching lines @@
 
 class PidState {
  public:
   enum PidType {
     kPidPat,
     kPidPmt,
     kPidAudioPes,
     kPidVideoPes,
   };
 
-  PidState(int pid, PidType pid_tyoe,
-           scoped_ptr<TsSection> section_parser);
+  PidState(int pid,
+           PidType pid_tyoe,
+           std::unique_ptr<TsSection> section_parser);
 
   // Extract the content of the TS packet and parse it.
   // Return true if successful.
   bool PushTsPacket(const TsPacket& ts_packet);
 
   // Flush the PID state (possibly emitting some pending frames)
   // and reset its state.
   void Flush();
 
   // Enable/disable the PID.
   // Disabling a PID will reset its state and ignore any further incoming TS
   // packets.
   void Enable();
   void Disable();
   bool IsEnabled() const;
 
   PidType pid_type() const { return pid_type_; }
 
  private:
   void ResetState();
 
   int pid_;
   PidType pid_type_;
-  scoped_ptr<TsSection> section_parser_;
+  std::unique_ptr<TsSection> section_parser_;
 
   bool enable_;
 
   int continuity_counter_;
 };
 
 PidState::PidState(int pid,
                    PidType pid_type,
-                   scoped_ptr<TsSection> section_parser)
+                   std::unique_ptr<TsSection> section_parser)
     : pid_(pid),
       pid_type_(pid_type),
       section_parser_(std::move(section_parser)),
       enable_(false),
       continuity_counter_(-1) {
   DCHECK(section_parser_);
 }
 
 bool PidState::PushTsPacket(const TsPacket& ts_packet) {
   DCHECK_EQ(ts_packet.pid(), pid_);
@@ skipping 172 matching lines @@
     // Synchronization.
     int skipped_bytes = TsPacket::Sync(ts_buffer, ts_buffer_size);
     if (skipped_bytes > 0) {
       DVLOG(1) << "Packet not aligned on a TS syncword:"
                << " skipped_bytes=" << skipped_bytes;
       ts_byte_queue_.Pop(skipped_bytes);
       continue;
     }
 
     // Parse the TS header, skipping 1 byte if the header is invalid.
-    scoped_ptr<TsPacket> ts_packet(TsPacket::Parse(ts_buffer, ts_buffer_size));
+    std::unique_ptr<TsPacket> ts_packet(
+        TsPacket::Parse(ts_buffer, ts_buffer_size));
     if (!ts_packet) {
       DVLOG(1) << "Error: invalid TS packet";
       ts_byte_queue_.Pop(1);
       continue;
     }
     DVLOG(LOG_LEVEL_TS)
         << "Processing PID=" << ts_packet->pid()
         << " start_unit=" << ts_packet->payload_unit_start_indicator();
 
     // Parse the section.
     std::map<int, PidState*>::iterator it = pids_.find(ts_packet->pid());
     if (it == pids_.end() &&
         ts_packet->pid() == TsSection::kPidPat) {
       // Create the PAT state here if needed.
-      scoped_ptr<TsSection> pat_section_parser(
-          new TsSectionPat(
-              base::Bind(&Mp2tStreamParser::RegisterPmt,
-                         base::Unretained(this))));
-      scoped_ptr<PidState> pat_pid_state(new PidState(
+      std::unique_ptr<TsSection> pat_section_parser(new TsSectionPat(
+          base::Bind(&Mp2tStreamParser::RegisterPmt, base::Unretained(this))));
+      std::unique_ptr<PidState> pat_pid_state(new PidState(
           ts_packet->pid(), PidState::kPidPat, std::move(pat_section_parser)));
       pat_pid_state->Enable();
       it = pids_.insert(
           std::pair<int, PidState*>(ts_packet->pid(),
                                     pat_pid_state.release())).first;
     }
 
     if (it != pids_.end()) {
       if (!it->second->PushTsPacket(*ts_packet))
         return false;
@@ skipping 22 matching lines @@
        it != pids_.end(); ++it) {
     PidState* pid_state = it->second;
     if (pid_state->pid_type() == PidState::kPidPmt) {
       DVLOG_IF(1, pmt_pid != it->first) << "More than one program is defined";
       return;
     }
   }
 
   // Create the PMT state here if needed.
   DVLOG(1) << "Create a new PMT parser";
-  scoped_ptr<TsSection> pmt_section_parser(
-      new TsSectionPmt(
-          base::Bind(&Mp2tStreamParser::RegisterPes,
-                     base::Unretained(this), pmt_pid)));
-  scoped_ptr<PidState> pmt_pid_state(
+  std::unique_ptr<TsSection> pmt_section_parser(new TsSectionPmt(base::Bind(
+      &Mp2tStreamParser::RegisterPes, base::Unretained(this), pmt_pid)));
+  std::unique_ptr<PidState> pmt_pid_state(
       new PidState(pmt_pid, PidState::kPidPmt, std::move(pmt_section_parser)));
   pmt_pid_state->Enable();
   pids_.insert(std::pair<int, PidState*>(pmt_pid, pmt_pid_state.release()));
 }
 
 void Mp2tStreamParser::RegisterPes(int pmt_pid,
                                    int pes_pid,
                                    int stream_type) {
   // TODO(damienv): check there is no mismatch if the entry already exists.
   DVLOG(1) << "RegisterPes:"
            << " pes_pid=" << pes_pid
            << " stream_type=" << std::hex << stream_type << std::dec;
   std::map<int, PidState*>::iterator it = pids_.find(pes_pid);
   if (it != pids_.end())
     return;
 
   // Create a stream parser corresponding to the stream type.
   bool is_audio = false;
-  scoped_ptr<EsParser> es_parser;
+  std::unique_ptr<EsParser> es_parser;
   if (stream_type == kStreamTypeAVC) {
     es_parser.reset(
         new EsParserH264(
             base::Bind(&Mp2tStreamParser::OnVideoConfigChanged,
                        base::Unretained(this),
                        pes_pid),
             base::Bind(&Mp2tStreamParser::OnEmitVideoBuffer,
                        base::Unretained(this),
                        pes_pid)));
   } else if (stream_type == kStreamTypeAAC) {
@@ skipping 14 matching lines @@
         base::Bind(&Mp2tStreamParser::OnEmitAudioBuffer, base::Unretained(this),
                    pes_pid),
         media_log_));
     is_audio = true;
   } else {
     return;
   }
 
   // Create the PES state here.
   DVLOG(1) << "Create a new PES state";
-  scoped_ptr<TsSection> pes_section_parser(
+  std::unique_ptr<TsSection> pes_section_parser(
       new TsSectionPes(std::move(es_parser), &timestamp_unroller_));
   PidState::PidType pid_type =
       is_audio ? PidState::kPidAudioPes : PidState::kPidVideoPes;
-  scoped_ptr<PidState> pes_pid_state(
+  std::unique_ptr<PidState> pes_pid_state(
       new PidState(pes_pid, pid_type, std::move(pes_section_parser)));
   pids_.insert(std::pair<int, PidState*>(pes_pid, pes_pid_state.release()));
 
   // A new PES pid has been added, the PID filter might change.
   UpdatePidFilter();
 }
 
 void Mp2tStreamParser::UpdatePidFilter() {
   // Applies the HLS rule to select the default audio/video PIDs:
   // select the audio/video streams with the lowest PID.
@@ skipping 91 matching lines @@
   // Replace any non valid config with the 1st valid entry.
   // This might happen if there was no available config before.
   for (std::list<BufferQueueWithConfig>::iterator it =
        buffer_queue_chain_.begin(); it != buffer_queue_chain_.end(); ++it) {
     if (it->audio_config.IsValidConfig())
       break;
     it->audio_config = audio_decoder_config;
   }
 }
 
-scoped_ptr<MediaTracks> GenerateMediaTrackInfo(
+std::unique_ptr<MediaTracks> GenerateMediaTrackInfo(
     const AudioDecoderConfig& audio_config,
     const VideoDecoderConfig& video_config) {
-  scoped_ptr<MediaTracks> media_tracks(new MediaTracks());
+  std::unique_ptr<MediaTracks> media_tracks(new MediaTracks());
   // TODO(servolk): Implement proper sourcing of media track info as described
   // in crbug.com/590085
   if (audio_config.IsValidConfig()) {
     media_tracks->AddAudioTrack(audio_config, "audio", "main", "", "");
   }
   if (video_config.IsValidConfig()) {
     media_tracks->AddVideoTrack(video_config, "video", "main", "", "");
   }
   return media_tracks;
 }
@@ skipping 10 matching lines @@
   // Wait for more data to come if one of the config is not available.
   BufferQueueWithConfig& queue_with_config = buffer_queue_chain_.front();
   if (selected_audio_pid_ > 0 &&
       !queue_with_config.audio_config.IsValidConfig())
     return true;
   if (selected_video_pid_ > 0 &&
       !queue_with_config.video_config.IsValidConfig())
     return true;
 
   // Pass the config before invoking the initialization callback.
-  scoped_ptr<MediaTracks> media_tracks = GenerateMediaTrackInfo(
+  std::unique_ptr<MediaTracks> media_tracks = GenerateMediaTrackInfo(
       queue_with_config.audio_config, queue_with_config.video_config);
   RCHECK(config_cb_.Run(std::move(media_tracks), TextTrackConfigMap()));
   queue_with_config.is_config_sent = true;
 
   // For Mpeg2 TS, the duration is not known.
   DVLOG(1) << "Mpeg2TS stream parser initialization done";
 
   // TODO(wolenetz): If possible, detect and report track counts by type more
   // accurately here. Currently, capped at max 1 each for audio and video, with
   // assumption of 0 text tracks.
@@ skipping 87 matching lines @@
     // Start a segment if needed.
     if (!segment_started_) {
       DVLOG(1) << "Starting a new segment";
       segment_started_ = true;
       new_segment_cb_.Run();
     }
 
     // Update the audio and video config if needed.
     BufferQueueWithConfig& queue_with_config = buffer_queue_chain_.front();
     if (!queue_with_config.is_config_sent) {
-      scoped_ptr<MediaTracks> media_tracks = GenerateMediaTrackInfo(
+      std::unique_ptr<MediaTracks> media_tracks = GenerateMediaTrackInfo(
           queue_with_config.audio_config, queue_with_config.video_config);
       if (!config_cb_.Run(std::move(media_tracks), TextTrackConfigMap()))
         return false;
       queue_with_config.is_config_sent = true;
     }
 
     // Add buffers.
     TextBufferQueueMap empty_text_map;
     if (!queue_with_config.audio_queue.empty() ||
         !queue_with_config.video_queue.empty()) {
@@ skipping 11 matching lines @@
   // so that buffers with the same config can be added later on.
   BufferQueueWithConfig queue_with_config(
       true, last_audio_config, last_video_config);
   buffer_queue_chain_.push_back(queue_with_config);
 
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media