Remove stl_util's deletion functions from media/.

media/filters/media_source_state.cc

 // Copyright 2016 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/media_source_state.h"
 
 #include <set>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/media_switches.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mime_util.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/frame_processor.h"
 #include "media/filters/source_buffer_stream.h"
 
 namespace media {
@@ skipping 37 matching lines @@
 }  // namespace
 
 // List of time ranges for each SourceBuffer.
 // static
 Ranges<TimeDelta> MediaSourceState::ComputeRangesIntersection(
     const RangesList& active_ranges,
     bool ended) {
   // TODO(servolk): Perhaps this can be removed in favor of blink implementation
   // (MediaSource::buffered)? Currently this is only used on Android and for
   // updating DemuxerHost's buffered ranges during AppendData() as well as
-  // SourceBuffer.buffered property implemetation.
+  // SourceBuffer.buffered property implementation.
   // Implementation of HTMLMediaElement.buffered algorithm in MSE spec.
   // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#dom-htmlmediaelement.buffered
 
   // Step 1: If activeSourceBuffers.length equals 0 then return an empty
   //  TimeRanges object and abort these steps.
   if (active_ranges.empty())
     return Ranges<TimeDelta>();
 
   // Step 2: Let active ranges be the ranges returned by buffered for each
   //  SourceBuffer object in activeSourceBuffers.
@@ skipping 48 matching lines @@
       frame_processor_(frame_processor.release()),
       media_log_(media_log),
       state_(UNINITIALIZED),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
 MediaSourceState::~MediaSourceState() {
   Shutdown();
-
-  base::STLDeleteValues(&text_stream_map_);
 }
 
 void MediaSourceState::Init(
     const StreamParser::InitCB& init_cb,
     const std::string& expected_codecs,
     const StreamParser::EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewTextTrackCB& new_text_track_cb) {
   DCHECK_EQ(state_, UNINITIALIZED);
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
@@ skipping 97 matching lines @@
                               TimeDelta end,
                               TimeDelta duration) {
   for (const auto& it : audio_streams_) {
     it.second->Remove(start, end, duration);
   }
 
   for (const auto& it : video_streams_) {
     it.second->Remove(start, end, duration);
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->Remove(start, end, duration);
+  for (const auto& it : text_streams_) {
+    it.second->Remove(start, end, duration);
   }
 }
 
 bool MediaSourceState::EvictCodedFrames(DecodeTimestamp media_time,
                                         size_t newDataSize) {
   size_t total_buffered_size = 0;
   for (const auto& it : audio_streams_)
     total_buffered_size += it.second->GetBufferedSize();
   for (const auto& it : video_streams_)
     total_buffered_size += it.second->GetBufferedSize();
-  for (const auto& it : text_stream_map_)
+  for (const auto& it : text_streams_)
     total_buffered_size += it.second->GetBufferedSize();
 
   DVLOG(3) << __func__ << " media_time=" << media_time.InSecondsF()
            << " newDataSize=" << newDataSize
            << " total_buffered_size=" << total_buffered_size;
 
   if (total_buffered_size == 0)
     return true;
 
   bool success = true;
   for (const auto& it : audio_streams_) {
     uint64_t curr_size = it.second->GetBufferedSize();
     if (curr_size == 0)
       continue;
     uint64_t estimated_new_size = newDataSize * curr_size / total_buffered_size;
     DCHECK_LE(estimated_new_size, SIZE_MAX);
     success &= it.second->EvictCodedFrames(
         media_time, static_cast<size_t>(estimated_new_size));
   }
   for (const auto& it : video_streams_) {
     uint64_t curr_size = it.second->GetBufferedSize();
     if (curr_size == 0)
       continue;
     uint64_t estimated_new_size = newDataSize * curr_size / total_buffered_size;
     DCHECK_LE(estimated_new_size, SIZE_MAX);
     success &= it.second->EvictCodedFrames(
         media_time, static_cast<size_t>(estimated_new_size));
   }
-  for (const auto& it : text_stream_map_) {
+  for (const auto& it : text_streams_) {
     uint64_t curr_size = it.second->GetBufferedSize();
     if (curr_size == 0)
       continue;
     uint64_t estimated_new_size = newDataSize * curr_size / total_buffered_size;
     DCHECK_LE(estimated_new_size, SIZE_MAX);
     success &= it.second->EvictCodedFrames(
         media_time, static_cast<size_t>(estimated_new_size));
   }
 
   DVLOG(3) << __func__ << " success=" << success;
   return success;
 }
 
 Ranges<TimeDelta> MediaSourceState::GetBufferedRanges(TimeDelta duration,
                                                       bool ended) const {
   RangesList ranges_list;
   for (const auto& it : audio_streams_)
     ranges_list.push_back(it.second->GetBufferedRanges(duration));
 
   for (const auto& it : video_streams_)
     ranges_list.push_back(it.second->GetBufferedRanges(duration));
 
-  for (TextStreamMap::const_iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    ranges_list.push_back(itr->second->GetBufferedRanges(duration));
-  }
+  for (const auto& it : text_streams_)
+    ranges_list.push_back(it.second->GetBufferedRanges(duration));
 
   return ComputeRangesIntersection(ranges_list, ended);
 }
 
 TimeDelta MediaSourceState::GetHighestPresentationTimestamp() const {
   TimeDelta max_pts;
 
   for (const auto& it : audio_streams_) {
     max_pts = std::max(max_pts, it.second->GetHighestPresentationTimestamp());
   }
 
   for (const auto& it : video_streams_) {
     max_pts = std::max(max_pts, it.second->GetHighestPresentationTimestamp());
   }
 
-  for (TextStreamMap::const_iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    max_pts = std::max(max_pts, itr->second->GetHighestPresentationTimestamp());
+  for (const auto& it : text_streams_) {
+    max_pts = std::max(max_pts, it.second->GetHighestPresentationTimestamp());
   }
 
   return max_pts;
 }
 
 TimeDelta MediaSourceState::GetMaxBufferedDuration() const {
   TimeDelta max_duration;
 
   for (const auto& it : audio_streams_) {
     max_duration = std::max(max_duration, it.second->GetBufferedDuration());
   }
 
   for (const auto& it : video_streams_) {
     max_duration = std::max(max_duration, it.second->GetBufferedDuration());
   }
 
-  for (TextStreamMap::const_iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    max_duration = std::max(max_duration, itr->second->GetBufferedDuration());
+  for (const auto& it : text_streams_) {
+    max_duration = std::max(max_duration, it.second->GetBufferedDuration());
   }
 
   return max_duration;
 }
 
 void MediaSourceState::StartReturningData() {
   for (const auto& it : audio_streams_) {
     it.second->StartReturningData();
   }
 
   for (const auto& it : video_streams_) {
     it.second->StartReturningData();
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->StartReturningData();
+  for (const auto& it : text_streams_) {
+    it.second->StartReturningData();
   }
 }
 
 void MediaSourceState::AbortReads() {
   for (const auto& it : audio_streams_) {
     it.second->AbortReads();
   }
 
   for (const auto& it : video_streams_) {
     it.second->AbortReads();
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->AbortReads();
+  for (const auto& it : text_streams_) {
+    it.second->AbortReads();
   }
 }
 
 void MediaSourceState::Seek(TimeDelta seek_time) {
   for (const auto& it : audio_streams_) {
     it.second->Seek(seek_time);
   }
 
   for (const auto& it : video_streams_) {
     it.second->Seek(seek_time);
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->Seek(seek_time);
+  for (const auto& it : text_streams_) {
+    it.second->Seek(seek_time);
   }
 }
 
 void MediaSourceState::CompletePendingReadIfPossible() {
   for (const auto& it : audio_streams_) {
     it.second->CompletePendingReadIfPossible();
   }
 
   for (const auto& it : video_streams_) {
     it.second->CompletePendingReadIfPossible();
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->CompletePendingReadIfPossible();
+  for (const auto& it : text_streams_) {
+    it.second->CompletePendingReadIfPossible();
   }
 }
 
 void MediaSourceState::OnSetDuration(TimeDelta duration) {
   for (const auto& it : audio_streams_) {
     it.second->OnSetDuration(duration);
   }
 
   for (const auto& it : video_streams_) {
     it.second->OnSetDuration(duration);
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->OnSetDuration(duration);
+  for (const auto& it : text_streams_) {
+    it.second->OnSetDuration(duration);
   }
 }
 
 void MediaSourceState::MarkEndOfStream() {
   for (const auto& it : audio_streams_) {
     it.second->MarkEndOfStream();
   }
 
   for (const auto& it : video_streams_) {
     it.second->MarkEndOfStream();
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->MarkEndOfStream();
+  for (const auto& it : text_streams_) {
+    it.second->MarkEndOfStream();
   }
 }
 
 void MediaSourceState::UnmarkEndOfStream() {
   for (const auto& it : audio_streams_) {
     it.second->UnmarkEndOfStream();
   }
 
   for (const auto& it : video_streams_) {
     it.second->UnmarkEndOfStream();
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->UnmarkEndOfStream();
+  for (const auto& it : text_streams_) {
+    it.second->UnmarkEndOfStream();
   }
 }
 
 void MediaSourceState::Shutdown() {
   for (const auto& it : audio_streams_) {
     it.second->Shutdown();
   }
 
   for (const auto& it : video_streams_) {
     it.second->Shutdown();
   }
 
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->Shutdown();
+  for (const auto& it : text_streams_) {
+    it.second->Shutdown();
   }
 }
 
 void MediaSourceState::SetMemoryLimits(DemuxerStream::Type type,
                                        size_t memory_limit) {
   switch (type) {
     case DemuxerStream::AUDIO:
       for (const auto& it : audio_streams_) {
         it.second->SetStreamMemoryLimit(memory_limit);
       }
       break;
     case DemuxerStream::VIDEO:
       for (const auto& it : video_streams_) {
         it.second->SetStreamMemoryLimit(memory_limit);
       }
       break;
     case DemuxerStream::TEXT:
-      for (TextStreamMap::iterator itr = text_stream_map_.begin();
-           itr != text_stream_map_.end(); ++itr) {
-        itr->second->SetStreamMemoryLimit(memory_limit);
+      for (const auto& it : text_streams_) {
+        it.second->SetStreamMemoryLimit(memory_limit);
       }
       break;
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       break;
   }
 }
 
 bool MediaSourceState::IsSeekWaitingForData() const {
@@ skipping 79 matching lines @@
         media_log_->SetBooleanProperty("found_audio_stream", true);
         media_log_->SetStringProperty("audio_codec_name",
                                       GetCodecName(audio_config.codec()));
       } else {
         if (audio_streams_.size() > 1) {
           auto it = audio_streams_.find(track_id);
           if (it != audio_streams_.end())
             stream = it->second;
         } else {
           // If there is only one audio track then bytestream id might change in
-          // a new init segment. So update our state and nofity frame processor.
+          // a new init segment. So update our state and notify frame processor.
           const auto& it = audio_streams_.begin();
           if (it != audio_streams_.end()) {
             stream = it->second;
             if (it->first != track_id) {
               frame_processor_->UpdateTrack(it->first, track_id);
               audio_streams_[track_id] = stream;
               audio_streams_.erase(it->first);
             }
           }
         }
@@ skipping 35 matching lines @@
         media_log_->SetBooleanProperty("found_video_stream", true);
         media_log_->SetStringProperty("video_codec_name",
                                       GetCodecName(video_config.codec()));
       } else {
         if (video_streams_.size() > 1) {
           auto it = video_streams_.find(track_id);
           if (it != video_streams_.end())
             stream = it->second;
         } else {
           // If there is only one video track then bytestream id might change in
-          // a new init segment. So update our state and nofity frame processor.
+          // a new init segment. So update our state and notify frame processor.
           const auto& it = video_streams_.begin();
           if (it != video_streams_.end()) {
             stream = it->second;
             if (it->first != track_id) {
               frame_processor_->UpdateTrack(it->first, track_id);
               video_streams_[track_id] = stream;
               video_streams_.erase(it->first);
             }
           }
         }
@@ skipping 18 matching lines @@
       MEDIA_LOG(ERROR, media_log_) << "Initialization segment misses expected "
                                    << GetCodecName(acodec) << " track.";
     }
     for (const auto& vcodec : expected_vcodecs) {
       MEDIA_LOG(ERROR, media_log_) << "Initialization segment misses expected "
                                    << GetCodecName(vcodec) << " track.";
     }
     return false;
   }
 
-  typedef StreamParser::TextTrackConfigMap::const_iterator TextConfigItr;
-  if (text_stream_map_.empty()) {
-    for (TextConfigItr itr = text_configs.begin(); itr != text_configs.end();
-         ++itr) {
+  if (text_streams_.empty()) {
+    for (auto itr = text_configs.begin(); itr != text_configs.end(); ++itr) {
       ChunkDemuxerStream* const text_stream =
           create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
       if (!frame_processor_->AddTrack(itr->first, text_stream)) {
         success &= false;
         MEDIA_LOG(ERROR, media_log_) << "Failed to add text track ID "
                                      << itr->first << " to frame processor.";
         break;
       }
       text_stream->UpdateTextConfig(itr->second, media_log_);
-      text_stream_map_[itr->first] = text_stream;
+      text_streams_[itr->first] = text_stream;
       new_text_track_cb_.Run(text_stream, itr->second);
     }
   } else {
-    const size_t text_count = text_stream_map_.size();
+    const size_t text_count = text_streams_.size();
     if (text_configs.size() != text_count) {
       success &= false;
       MEDIA_LOG(ERROR, media_log_)
           << "The number of text track configs changed.";
     } else if (text_count == 1) {
-      TextConfigItr config_itr = text_configs.begin();
-      TextStreamMap::iterator stream_itr = text_stream_map_.begin();
+      auto config_itr = text_configs.begin();
+      auto stream_itr = text_streams_.begin();
       ChunkDemuxerStream* text_stream = stream_itr->second;
       TextTrackConfig old_config = text_stream->text_track_config();
       TextTrackConfig new_config(
           config_itr->second.kind(), config_itr->second.label(),
           config_itr->second.language(), old_config.id());
       if (!new_config.Matches(old_config)) {
         success &= false;
         MEDIA_LOG(ERROR, media_log_)
             << "New text track config does not match old one.";
       } else {
         StreamParser::TrackId old_id = stream_itr->first;
         StreamParser::TrackId new_id = config_itr->first;
         if (new_id != old_id) {
           if (frame_processor_->UpdateTrack(old_id, new_id)) {
-            text_stream_map_.clear();
-            text_stream_map_[config_itr->first] = text_stream;
+            text_streams_.clear();
+            text_streams_[config_itr->first] = text_stream;
           } else {
             success &= false;
             MEDIA_LOG(ERROR, media_log_)
                 << "Error remapping single text track number";
           }
         }
       }
     } else {
-      for (TextConfigItr config_itr = text_configs.begin();
+      for (auto config_itr = text_configs.begin();
            config_itr != text_configs.end(); ++config_itr) {
-        TextStreamMap::iterator stream_itr =
-            text_stream_map_.find(config_itr->first);
-        if (stream_itr == text_stream_map_.end()) {
+        auto stream_itr = text_streams_.find(config_itr->first);
+        if (stream_itr == text_streams_.end()) {
           success &= false;
           MEDIA_LOG(ERROR, media_log_)
               << "Unexpected text track configuration for track ID "
               << config_itr->first;
           break;
         }
 
         const TextTrackConfig& new_config = config_itr->second;
         ChunkDemuxerStream* stream = stream_itr->second;
         TextTrackConfig old_config = stream->text_track_config();
@@ skipping 145 matching lines @@
 }
 void MediaSourceState::OnSourceInitDone(
     const StreamParser::InitParameters& params) {
   DCHECK_EQ(state_, PENDING_PARSER_INIT);
   state_ = PARSER_INITIALIZED;
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(params);
 }
 
 }  // namespace media