Remove stl_util's deletion functions from media/.

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"
 #include "media/formats/mp2t/es_parser_adts.h"
 #include "media/formats/mp2t/es_parser_h264.h"
 #include "media/formats/mp2t/es_parser_mpeg1audio.h"
 #include "media/formats/mp2t/mp2t_common.h"
 #include "media/formats/mp2t/ts_packet.h"
@@ skipping 15 matching lines @@
 class PidState {
  public:
   enum PidType {
     kPidPat,
     kPidPmt,
     kPidAudioPes,
     kPidVideoPes,
   };
 
   PidState(int pid,
-           PidType pid_tyoe,
+           PidType pid_type,
            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();
 
@@ skipping 102 matching lines @@
 
 Mp2tStreamParser::Mp2tStreamParser(bool sbr_in_mimetype)
   : sbr_in_mimetype_(sbr_in_mimetype),
     selected_audio_pid_(-1),
     selected_video_pid_(-1),
     is_initialized_(false),
     segment_started_(false) {
 }
 
 Mp2tStreamParser::~Mp2tStreamParser() {
-  base::STLDeleteValues(&pids_);
 }
 
 void Mp2tStreamParser::Init(
     const InitCB& init_cb,
     const NewConfigCB& config_cb,
     const NewBuffersCB& new_buffers_cb,
     bool /* ignore_text_tracks */,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewMediaSegmentCB& new_segment_cb,
     const EndMediaSegmentCB& end_of_segment_cb,
@@ skipping 13 matching lines @@
   encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
   media_log_ = media_log;
 }
 
 void Mp2tStreamParser::Flush() {
   DVLOG(1) << "Mp2tStreamParser::Flush";
 
   // Flush the buffers and reset the pids.
-  for (std::map<int, PidState*>::iterator it = pids_.begin();
-       it != pids_.end(); ++it) {
-    DVLOG(1) << "Flushing PID: " << it->first;
-    PidState* pid_state = it->second;
-    pid_state->Flush();
-    delete pid_state;
+  for (const auto& pid_pair : pids_) {
+    DVLOG(1) << "Flushing PID: " << pid_pair.first;
+    pid_pair.second->Flush();
   }
   pids_.clear();
 
   // Flush is invoked from SourceBuffer.abort/SourceState::ResetParserState, and
   // MSE spec prohibits emitting new configs in ResetParserState algorithm (see
   // https://w3c.github.io/media-source/#sourcebuffer-reset-parser-state,
   // 3.5.2 Reset Parser State states that new frames might be processed only in
   // PARSING_MEDIA_SEGMENT and therefore doesn't allow emitting new configs,
   // since that might need to run "init segment received" algorithm).
   // So before we emit remaining buffers here, we need to trim our buffer queue
@@ skipping 56 matching lines @@
     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());
+    auto it = pids_.find(ts_packet->pid());
     if (it == pids_.end() &&
         ts_packet->pid() == TsSection::kPidPat) {
       // Create the PAT state here if needed.
       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;
+      it = pids_
+               .insert(
+                   std::make_pair(ts_packet->pid(), std::move(pat_pid_state)))
+               .first;
     }
 
     if (it != pids_.end()) {
       if (!it->second->PushTsPacket(*ts_packet))
         return false;
     } else {
       DVLOG(LOG_LEVEL_TS) << "Ignoring TS packet for pid: " << ts_packet->pid();
     }
 
     // Go to the next packet.
     ts_byte_queue_.Pop(TsPacket::kPacketSize);
   }
 
   RCHECK(FinishInitializationIfNeeded());
 
   // Emit the A/V buffers that kept accumulating during TS parsing.
   return EmitRemainingBuffers();
 }
 
 void Mp2tStreamParser::RegisterPmt(int program_number, int pmt_pid) {
   DVLOG(1) << "RegisterPmt:"
            << " program_number=" << program_number
            << " pmt_pid=" << pmt_pid;
 
   // Only one TS program is allowed. Ignore the incoming program map table,
   // if there is already one registered.
-  for (std::map<int, PidState*>::iterator it = pids_.begin();
-       it != pids_.end(); ++it) {
-    PidState* pid_state = it->second;
+  for (const auto& pid_pair : pids_) {
+    PidState* pid_state = pid_pair.second.get();
     if (pid_state->pid_type() == PidState::kPidPmt) {
-      DVLOG_IF(1, pmt_pid != it->first) << "More than one program is defined";
+      DVLOG_IF(1, pmt_pid != pid_pair.first)
+          << "More than one program is defined";
       return;
     }
   }
 
   // Create the PMT state here if needed.
   DVLOG(1) << "Create a new PMT parser";
   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()));
+  pids_.insert(std::make_pair(pmt_pid, std::move(pmt_pid_state)));
 }
 
 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);
+  auto it = pids_.find(pes_pid);
   if (it != pids_.end())
     return;
 
   // Create a stream parser corresponding to the stream type.
   bool is_audio = false;
   std::unique_ptr<EsParser> es_parser;
   if (stream_type == kStreamTypeAVC) {
     es_parser.reset(
         new EsParserH264(
             base::Bind(&Mp2tStreamParser::OnVideoConfigChanged,
@@ skipping 26 matching lines @@
   }
 
   // Create the PES state here.
   DVLOG(1) << "Create a new PES state";
   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;
   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()));
+  pids_.insert(std::make_pair(pes_pid, std::move(pes_pid_state)));
 
   // 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.
   // TODO(damienv): this can be changed when the StreamParser interface
   // supports multiple audio/video streams.
-  PidMap::iterator lowest_audio_pid = pids_.end();
-  PidMap::iterator lowest_video_pid = pids_.end();
-  for (PidMap::iterator it = pids_.begin(); it != pids_.end(); ++it) {
+  auto lowest_audio_pid = pids_.end();
+  auto lowest_video_pid = pids_.end();
+  for (auto it = pids_.begin(); it != pids_.end(); ++it) {
     int pid = it->first;
-    PidState* pid_state = it->second;
+    PidState* pid_state = it->second.get();
     if (pid_state->pid_type() == PidState::kPidAudioPes &&
         (lowest_audio_pid == pids_.end() || pid < lowest_audio_pid->first))
       lowest_audio_pid = it;
     if (pid_state->pid_type() == PidState::kPidVideoPes &&
         (lowest_video_pid == pids_.end() || pid < lowest_video_pid->first))
       lowest_video_pid = it;
   }
 
   // Enable both the lowest audio and video PIDs.
   if (lowest_audio_pid != pids_.end()) {
     DVLOG(1) << "Enable audio pid: " << lowest_audio_pid->first;
     lowest_audio_pid->second->Enable();
     selected_audio_pid_ = lowest_audio_pid->first;
   }
   if (lowest_video_pid != pids_.end()) {
     DVLOG(1) << "Enable video pid: " << lowest_video_pid->first;
     lowest_video_pid->second->Enable();
     selected_video_pid_ = lowest_video_pid->first;
   }
 
   // Disable all the other audio and video PIDs.
-  for (PidMap::iterator it = pids_.begin(); it != pids_.end(); ++it) {
-    PidState* pid_state = it->second;
+  for (auto it = pids_.begin(); it != pids_.end(); ++it) {
+    PidState* pid_state = it->second.get();
     if (it != lowest_audio_pid && it != lowest_video_pid &&
         (pid_state->pid_type() == PidState::kPidAudioPes ||
          pid_state->pid_type() == PidState::kPidVideoPes))
       pid_state->Disable();
   }
 }
 
 void Mp2tStreamParser::OnVideoConfigChanged(
     int pes_pid,
     const VideoDecoderConfig& video_decoder_config) {
@@ skipping 228 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