Remove stl_util's deletion functions from media/.

media/filters/chunk_demuxer.cc

 // Copyright (c) 2012 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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mime_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_codecs.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/frame_processor.h"
@@ skipping 587 matching lines @@
   std::string expected_mss_codecs = codecs;
   if (codecs == "" && type == "audio/aac")
     expected_mss_codecs = "aac";
   if (codecs == "" && (type == "audio/mpeg" || type == "audio/mp3"))
     expected_mss_codecs = "mp3";
 
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this), id),
       expected_mss_codecs, encrypted_media_init_data_cb_, new_text_track_cb);
 
-  source_state_map_[id] = source_state.release();
+  source_state_map_[id] = std::move(source_state);
   return kOk;
 }
 
 void ChunkDemuxer::SetTracksWatcher(
     const std::string& id,
     const MediaTracksUpdatedCB& tracks_updated_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
   source_state_map_[id]->SetTracksWatcher(tracks_updated_cb);
 }
 
 void ChunkDemuxer::RemoveId(const std::string& id) {
   DVLOG(1) << __func__ << " id=" << id;
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
 
-  delete source_state_map_[id];
   source_state_map_.erase(id);
   pending_source_init_ids_.erase(id);
   // Remove demuxer streams created for this id.
   for (const ChunkDemuxerStream* s : id_to_streams_map_[id]) {
     bool stream_found = false;
     for (size_t i = 0; i < audio_streams_.size(); ++i) {
       if (audio_streams_[i].get() == s) {
         stream_found = true;
         removed_streams_.push_back(std::move(audio_streams_[i]));
         audio_streams_.erase(audio_streams_.begin() + i);
@@ skipping 12 matching lines @@
     }
     CHECK(stream_found);
   }
   id_to_streams_map_.erase(id);
 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
 
-  MediaSourceStateMap::const_iterator itr = source_state_map_.find(id);
+  auto itr = source_state_map_.find(id);
 
   DCHECK(itr != source_state_map_.end());
   return itr->second->GetBufferedRanges(duration_, state_ == ENDED);
 }
 
 base::TimeDelta ChunkDemuxer::GetHighestPresentationTimestamp(
     const std::string& id) const {
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
 
-  MediaSourceStateMap::const_iterator itr = source_state_map_.find(id);
+  auto itr = source_state_map_.find(id);
 
   DCHECK(itr != source_state_map_.end());
   return itr->second->GetHighestPresentationTimestamp();
 }
 
 void ChunkDemuxer::OnEnabledAudioTracksChanged(
     const std::vector<MediaTrack::Id>& track_ids,
     base::TimeDelta currTime) {
   base::AutoLock auto_lock(lock_);
   std::set<DemuxerStream*> enabled_streams;
@@ skipping 54 matching lines @@
            << " newDataSize=" << newDataSize;
   base::AutoLock auto_lock(lock_);
 
   // Note: The direct conversion from PTS to DTS is safe here, since we don't
   // need to know currentTime precisely for GC. GC only needs to know which GOP
   // currentTime points to.
   DecodeTimestamp media_time_dts =
       DecodeTimestamp::FromPresentationTime(currentMediaTime);
 
   DCHECK(!id.empty());
-  MediaSourceStateMap::const_iterator itr = source_state_map_.find(id);
+  auto itr = source_state_map_.find(id);
   if (itr == source_state_map_.end()) {
     LOG(WARNING) << __func__ << " stream " << id << " not found";
     return false;
   }
   return itr->second->EvictCodedFrames(media_time_dts, newDataSize);
 }
 
 bool ChunkDemuxer::AppendData(const std::string& id,
                               const uint8_t* data,
                               size_t length,
@@ skipping 146 matching lines @@
     duration_td = TimeDelta::FromMicroseconds(
         duration * base::Time::kMicrosecondsPerSecond);
   }
 
   DCHECK(duration_td > TimeDelta());
 
   user_specified_duration_ = duration;
   duration_ = duration_td;
   host_->SetDuration(duration_);
 
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->OnSetDuration(duration_);
   }
 }
 
 bool ChunkDemuxer::IsParsingMediaSegment(const std::string& id) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "IsParsingMediaSegment(" << id << ")";
   CHECK(IsValidId(id));
 
   return source_state_map_[id]->parsing_media_segment();
@@ skipping 31 matching lines @@
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return;
 
   if (state_ == INITIALIZING) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   bool old_waiting_for_data = IsSeekWaitingForData_Locked();
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->MarkEndOfStream();
   }
 
   CompletePendingReadsIfPossible();
 
   // Give a chance to resume the pending seek process.
   if (status != PIPELINE_OK) {
     DCHECK(status == CHUNK_DEMUXER_ERROR_EOS_STATUS_DECODE_ERROR ||
            status == CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR);
     ReportError_Locked(status);
     return;
   }
 
   ChangeState_Locked(ENDED);
   DecreaseDurationIfNecessary();
 
   if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
       !seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   }
 }
 
 void ChunkDemuxer::UnmarkEndOfStream() {
   DVLOG(1) << "UnmarkEndOfStream()";
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, ENDED);
 
   ChangeState_Locked(INITIALIZED);
 
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->UnmarkEndOfStream();
   }
 }
 
 void ChunkDemuxer::Shutdown() {
   DVLOG(1) << "Shutdown()";
   base::AutoLock auto_lock(lock_);
 
   if (state_ == SHUTDOWN)
     return;
 
   ShutdownAllStreams();
 
   ChangeState_Locked(SHUTDOWN);
 
   if (!seek_cb_.is_null())
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_ERROR_ABORT);
 }
 
 void ChunkDemuxer::SetMemoryLimitsForTest(DemuxerStream::Type type,
                                           size_t memory_limit) {
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->SetMemoryLimits(type, memory_limit);
   }
 }
 
 void ChunkDemuxer::ChangeState_Locked(State new_state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxer::ChangeState_Locked() : "
            << state_ << " -> " << new_state;
   state_ = new_state;
 }
 
 ChunkDemuxer::~ChunkDemuxer() {
   DCHECK_NE(state_, INITIALIZED);
-
-  base::STLDeleteValues(&source_state_map_);
 }
 
 void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   DVLOG(1) << "ReportError_Locked(" << error << ")";
   lock_.AssertAcquired();
   DCHECK_NE(error, PIPELINE_OK);
 
   ChangeState_Locked(PARSE_ERROR);
 
   PipelineStatusCB cb;
@@ skipping 11 matching lines @@
     cb.Run(error);
     return;
   }
 
   base::AutoUnlock auto_unlock(lock_);
   host_->OnDemuxerError(error);
 }
 
 bool ChunkDemuxer::IsSeekWaitingForData_Locked() const {
   lock_.AssertAcquired();
-  for (MediaSourceStateMap::const_iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     if (itr->second->IsSeekWaitingForData())
       return true;
   }
 
   return false;
 }
 
 void ChunkDemuxer::OnSourceInitDone(
     const std::string& source_id,
     const StreamParser::InitParameters& params) {
@@ skipping 74 matching lines @@
 ChunkDemuxerStream* ChunkDemuxer::CreateDemuxerStream(
     const std::string& source_id,
     DemuxerStream::Type type) {
   // New ChunkDemuxerStreams can be created only during initialization segment
   // processing, which happens when a new chunk of data is appended and the
   // lock_ must be held by ChunkDemuxer::AppendData.
   lock_.AssertAcquired();
 
   MediaTrack::Id media_track_id = GenerateMediaTrackId();
 
+  OwnedChunkDemuxerStreamVector* owning_vector = nullptr;
   switch (type) {
-    case DemuxerStream::AUDIO: {
-      std::unique_ptr<ChunkDemuxerStream> audio_stream(new ChunkDemuxerStream(
-          DemuxerStream::AUDIO, splice_frames_enabled_, media_track_id));
-      DCHECK(track_id_to_demux_stream_map_.find(media_track_id) ==
-             track_id_to_demux_stream_map_.end());
-      track_id_to_demux_stream_map_[media_track_id] = audio_stream.get();
-      id_to_streams_map_[source_id].push_back(audio_stream.get());
-      audio_streams_.push_back(std::move(audio_stream));
-      return audio_streams_.back().get();
-    }
-    case DemuxerStream::VIDEO: {
-      std::unique_ptr<ChunkDemuxerStream> video_stream(new ChunkDemuxerStream(
-          DemuxerStream::VIDEO, splice_frames_enabled_, media_track_id));
-      DCHECK(track_id_to_demux_stream_map_.find(media_track_id) ==
-             track_id_to_demux_stream_map_.end());
-      track_id_to_demux_stream_map_[media_track_id] = video_stream.get();
-      id_to_streams_map_[source_id].push_back(video_stream.get());
-      video_streams_.push_back(std::move(video_stream));
-      return video_streams_.back().get();
-    }
-    case DemuxerStream::TEXT: {
-      ChunkDemuxerStream* text_stream = new ChunkDemuxerStream(
-          DemuxerStream::TEXT, splice_frames_enabled_, media_track_id);
-      id_to_streams_map_[source_id].push_back(text_stream);
-      return text_stream;
-    }
+    case DemuxerStream::AUDIO:
+      owning_vector = &audio_streams_;
+      break;
+
+    case DemuxerStream::VIDEO:
+      owning_vector = &video_streams_;
+      break;
+
+    case DemuxerStream::TEXT:
+      owning_vector = &text_streams_;
+      break;
+
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
-      return NULL;
+      return nullptr;
   }
-  NOTREACHED();
-  return NULL;
+
+  std::unique_ptr<ChunkDemuxerStream> stream =
+      base::MakeUnique<ChunkDemuxerStream>(type, splice_frames_enabled_,
+                                           media_track_id);
+  DCHECK(track_id_to_demux_stream_map_.find(media_track_id) ==
+         track_id_to_demux_stream_map_.end());
+  track_id_to_demux_stream_map_[media_track_id] = stream.get();
+  id_to_streams_map_[source_id].push_back(stream.get());
+  owning_vector->push_back(std::move(stream));
+  return owning_vector->back().get();
 }
 
 void ChunkDemuxer::OnNewTextTrack(ChunkDemuxerStream* text_stream,
                                   const TextTrackConfig& config) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
   host_->AddTextStream(text_stream, config);
 }
 
 bool ChunkDemuxer::IsValidId(const std::string& source_id) const {
@@ skipping 26 matching lines @@
            << " -> " << new_duration.InSecondsF();
 
   UpdateDuration(new_duration);
 }
 
 void ChunkDemuxer::DecreaseDurationIfNecessary() {
   lock_.AssertAcquired();
 
   TimeDelta max_duration;
 
-  for (MediaSourceStateMap::const_iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     max_duration = std::max(max_duration,
                             itr->second->GetMaxBufferedDuration());
   }
 
   if (max_duration.is_zero())
     return;
 
   if (max_duration < duration_)
     UpdateDuration(max_duration);
 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   base::AutoLock auto_lock(lock_);
   return GetBufferedRanges_Locked();
 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges_Locked() const {
   lock_.AssertAcquired();
 
   bool ended = state_ == ENDED;
   // TODO(acolwell): When we start allowing SourceBuffers that are not active,
   // we'll need to update this loop to only add ranges from active sources.
   MediaSourceState::RangesList ranges_list;
-  for (MediaSourceStateMap::const_iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     ranges_list.push_back(itr->second->GetBufferedRanges(duration_, ended));
   }
 
   return MediaSourceState::ComputeRangesIntersection(ranges_list, ended);
 }
 
 void ChunkDemuxer::StartReturningData() {
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->StartReturningData();
   }
 }
 
 void ChunkDemuxer::AbortPendingReads_Locked() {
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->AbortReads();
   }
 }
 
 void ChunkDemuxer::SeekAllSources(TimeDelta seek_time) {
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->Seek(seek_time);
   }
 }
 
 void ChunkDemuxer::CompletePendingReadsIfPossible() {
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->CompletePendingReadIfPossible();
   }
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
-  for (MediaSourceStateMap::iterator itr = source_state_map_.begin();
-       itr != source_state_map_.end(); ++itr) {
+  for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
+       ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media