media_recorder_handler: Changed deprecated ScopedVector to std::vector

content/renderer/media/media_recorder_handler.cc

 // Copyright 2015 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 "content/renderer/media/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 181 matching lines @@
         << "Recording multiple video tracks is not implemented. "
         << "Only recording first video track.";
     const blink::WebMediaStreamTrack& video_track = video_tracks[0];
     if (video_track.isNull())
       return false;
 
     const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedVideo, weak_factory_.GetWeakPtr()));
 
-    video_recorders_.push_back(new VideoTrackRecorder(
+    video_recorders_.emplace_back(new VideoTrackRecorder(
         codec_id_, video_track, on_encoded_video_cb, video_bits_per_second_));
   }
 
   if (use_audio_tracks) {
     // TODO(ajose): The muxer API supports only one audio track. Extend it to
     // several tracks.
     LOG_IF(WARNING, audio_tracks.size() > 1u)
         << "Recording multiple audio"
         << " tracks is not implemented.  Only recording first audio track.";
     const blink::WebMediaStreamTrack& audio_track = audio_tracks[0];
     if (audio_track.isNull())
       return false;
 
     const AudioTrackRecorder::OnEncodedAudioCB on_encoded_audio_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedAudio, weak_factory_.GetWeakPtr()));
 
-    audio_recorders_.push_back(new AudioTrackRecorder(
+    audio_recorders_.emplace_back(new AudioTrackRecorder(
         audio_track, on_encoded_audio_cb, audio_bits_per_second_));
   }
 
   recording_ = true;
   return true;
 }
 
 void MediaRecorderHandler::stop() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Don't check |recording_| since we can go directly from pause() to stop().
 
   recording_ = false;
   timeslice_ = TimeDelta::FromMilliseconds(0);
   video_recorders_.clear();
   audio_recorders_.clear();
   webm_muxer_.reset();
 }
 
 void MediaRecorderHandler::pause() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(recording_);
   recording_ = false;
-  for (auto* video_recorder : video_recorders_)
+  for (const auto& video_recorder : video_recorders_)
     video_recorder->Pause();
-  for (auto* audio_recorder : audio_recorders_)
+  for (const auto& audio_recorder : audio_recorders_)
     audio_recorder->Pause();
   webm_muxer_->Pause();
 }
 
 void MediaRecorderHandler::resume() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   recording_ = true;
-  for (auto* video_recorder : video_recorders_)
+  for (const auto& video_recorder : video_recorders_)
     video_recorder->Resume();
-  for (auto* audio_recorder : audio_recorders_)
+  for (const auto& audio_recorder : audio_recorders_)
     audio_recorder->Resume();
   webm_muxer_->Resume();
 }
 
 void MediaRecorderHandler::OnEncodedVideo(
     const scoped_refptr<media::VideoFrame>& video_frame,
     std::unique_ptr<std::string> encoded_data,
     TimeTicks timestamp,
     bool is_key_frame) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
@@ skipping 24 matching lines @@
   const bool last_in_slice = now > slice_origin_timestamp_ + timeslice_;
   DVLOG_IF(1, last_in_slice) << "Slice finished @ " << now;
   if (last_in_slice)
     slice_origin_timestamp_ = now;
   client_->writeData(data.data(), data.length(), last_in_slice);
 }
 
 void MediaRecorderHandler::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     const TimeTicks& timestamp) {
-  for (auto* recorder : video_recorders_)
+  for (const auto& recorder : video_recorders_)
     recorder->OnVideoFrameForTesting(frame, timestamp);
 }
 
 void MediaRecorderHandler::OnAudioBusForTesting(
     const media::AudioBus& audio_bus,
     const base::TimeTicks& timestamp) {
-  for (auto* recorder : audio_recorders_)
+  for (const auto& recorder : audio_recorders_)
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
-  for (auto* recorder : audio_recorders_)
+  for (const auto& recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content