Remove stl_util's deletion functions from media/.

media/filters/frame_processor.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/filters/frame_processor.h"
 
 #include <stdint.h>
 
 #include <cstdlib>
 
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 const int kMaxDroppedPrerollWarnings = 10;
 const int kMaxDtsBeyondPtsWarnings = 10;
 
 // Helper class to capture per-track details needed by a frame processor. Some
 // of this information may be duplicated in the short-term in the associated
@@ skipping 142 matching lines @@
                                const scoped_refptr<MediaLog>& media_log)
     : group_start_timestamp_(kNoTimestamp),
       update_duration_cb_(update_duration_cb),
       media_log_(media_log) {
   DVLOG(2) << __func__ << "()";
   DCHECK(!update_duration_cb.is_null());
 }
 
 FrameProcessor::~FrameProcessor() {
   DVLOG(2) << __func__ << "()";
-  base::STLDeleteValues(&track_buffers_);
 }
 
 void FrameProcessor::SetSequenceMode(bool sequence_mode) {
   DVLOG(2) << __func__ << "(" << sequence_mode << ")";
   // Per June 9, 2016 MSE spec editor's draft:
   // https://rawgit.com/w3c/media-source/d8f901f22/
   //     index.html#widl-SourceBuffer-mode
   // Step 7: If the new mode equals "sequence", then set the group start
   // timestamp to the group end timestamp.
   if (sequence_mode) {
@@ skipping 67 matching lines @@
   DVLOG(2) << __func__ << "(): id=" << id;
 
   MseTrackBuffer* existing_track = FindTrack(id);
   DCHECK(!existing_track);
   if (existing_track) {
     MEDIA_LOG(ERROR, media_log_) << "Failure adding track with duplicate ID "
                                  << id;
     return false;
   }
 
-  track_buffers_[id] = new MseTrackBuffer(stream);
+  track_buffers_[id] = base::MakeUnique<MseTrackBuffer>(stream);
   return true;
 }
 
 bool FrameProcessor::UpdateTrack(StreamParser::TrackId old_id,
                                  StreamParser::TrackId new_id) {
   DVLOG(2) << __func__ << "() : old_id=" << old_id << ", new_id=" << new_id;
 
   if (old_id == new_id || !FindTrack(old_id) || FindTrack(new_id)) {
     MEDIA_LOG(ERROR, media_log_) << "Failure updating track id from " << old_id
                                  << " to " << new_id;
     return false;
   }
 
-  track_buffers_[new_id] = track_buffers_[old_id];
+  track_buffers_[new_id] = std::move(track_buffers_[old_id]);
   CHECK_EQ(1u, track_buffers_.erase(old_id));
   return true;
 }
 
 void FrameProcessor::SetAllTrackBuffersNeedRandomAccessPoint() {
-  for (TrackBufferMap::iterator itr = track_buffers_.begin();
-       itr != track_buffers_.end();
-       ++itr) {
+  for (auto itr = track_buffers_.begin(); itr != track_buffers_.end(); ++itr) {
     itr->second->set_needs_random_access_point(true);
   }
 }
 
 void FrameProcessor::Reset() {
   DVLOG(2) << __func__ << "()";
-  for (TrackBufferMap::iterator itr = track_buffers_.begin();
-       itr != track_buffers_.end(); ++itr) {
+  for (auto itr = track_buffers_.begin(); itr != track_buffers_.end(); ++itr) {
     itr->second->Reset();
   }
 
   // Maintain current |coded_frame_group_last_dts_| state for Reset() during
   // sequence mode. Reset it here only if in segments mode. In sequence mode,
   // the current coded frame group may be continued across Reset() operations to
-  // allow the stream to coaelesce what might otherwise be gaps in the buffered
+  // allow the stream to coalesce what might otherwise be gaps in the buffered
   // ranges. See also the declaration for |coded_frame_group_last_dts_|.
   if (!sequence_mode_) {
     coded_frame_group_last_dts_ = kNoDecodeTimestamp();
     return;
   }
 
   // Sequence mode
   DCHECK(kNoTimestamp != group_end_timestamp_);
   group_start_timestamp_ = group_end_timestamp_;
 }
 
 void FrameProcessor::OnPossibleAudioConfigUpdate(
     const AudioDecoderConfig& config) {
   DCHECK(config.IsValidConfig());
 
   // Always clear the preroll buffer when a config update is received.
   audio_preroll_buffer_ = NULL;
 
   if (config.Matches(current_audio_config_))
     return;
 
   current_audio_config_ = config;
   sample_duration_ = base::TimeDelta::FromSecondsD(
       1.0 / current_audio_config_.samples_per_second());
 }
 
 MseTrackBuffer* FrameProcessor::FindTrack(StreamParser::TrackId id) {
-  TrackBufferMap::iterator itr = track_buffers_.find(id);
+  auto itr = track_buffers_.find(id);
   if (itr == track_buffers_.end())
     return NULL;
 
-  return itr->second;
+  return itr->second.get();
 }
 
 void FrameProcessor::NotifyStartOfCodedFrameGroup(
     DecodeTimestamp start_timestamp) {
   DVLOG(2) << __func__ << "(" << start_timestamp.InSecondsF() << ")";
 
-  for (TrackBufferMap::iterator itr = track_buffers_.begin();
-       itr != track_buffers_.end();
-       ++itr) {
+  for (auto itr = track_buffers_.begin(); itr != track_buffers_.end(); ++itr) {
     itr->second->stream()->OnStartOfCodedFrameGroup(start_timestamp);
   }
 }
 
 bool FrameProcessor::FlushProcessedFrames() {
   DVLOG(2) << __func__ << "()";
 
   bool result = true;
-  for (TrackBufferMap::iterator itr = track_buffers_.begin();
-       itr != track_buffers_.end();
-       ++itr) {
+  for (auto itr = track_buffers_.begin(); itr != track_buffers_.end(); ++itr) {
     if (!itr->second->FlushProcessedFrames())
       result = false;
   }
 
   return result;
 }
 
 bool FrameProcessor::HandlePartialAppendWindowTrimming(
     base::TimeDelta append_window_start,
     base::TimeDelta append_window_end,
@@ skipping 383 matching lines @@
     // Step 21 is currently handled differently. See MediaSourceState's
     // |auto_update_timestamp_offset_|.
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace media