Remove ScopedVector from content/renderer/.

content/renderer/media/audio_repetition_detector.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/audio_repetition_detector.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 
 namespace {
 
 const float kEpsilon = 4.0f / 32768.0f;
 
 }  // namespace
 
 namespace content {
 
 AudioRepetitionDetector::AudioRepetitionDetector(
@@ skipping 11 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   processing_thread_checker_.DetachFromThread();
 
   // Avoid duplications in |look_back_times| if any.
   std::vector<int> temp(look_back_times);
   std::sort(temp.begin(), temp.end());
   temp.erase(std::unique(temp.begin(), temp.end()), temp.end());
 
   max_look_back_ms_ = temp.back();
   for (int look_back : temp)
-    states_.push_back(new State(look_back));
+    states_.push_back(base::MakeUnique<State>(look_back));
 }
 
 AudioRepetitionDetector::~AudioRepetitionDetector() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 }
 
 void AudioRepetitionDetector::Detect(const float* data, size_t num_frames,
                                      size_t num_channels, int sample_rate) {
   DCHECK(processing_thread_checker_.CalledOnValidThread());
   DCHECK(!states_.empty());
 
   if (num_channels != num_channels_ || sample_rate != sample_rate_)
     Reset(num_channels, sample_rate);
 
   // The maximum number of frames |audio_buffer_| can take in is |max_frames_|.
   // Therefore, input data with larger frames needs be divided into chunks.
   const size_t chunk_size = max_frames_ * num_channels;
   while (num_frames > max_frames_) {
     Detect(data, max_frames_, num_channels, sample_rate);
     data += chunk_size;
     num_frames -= max_frames_;
   }
 
   if (num_frames == 0)
     return;
 
   AddFramesToBuffer(data, num_frames);
 
   for (size_t idx = num_frames; idx > 0; --idx, data += num_channels) {
-    for (State* state : states_) {
+    for (const auto& state : states_) {
       // Look back position depends on the sample rate. It is rounded down to
       // the closest integer.
       const size_t look_back_frames =
           state->look_back_ms() * sample_rate_ / 1000;
       // Equal(data, offset) checks if |data| equals the audio frame located
       // |offset| frames from the end of buffer. Now a full frame has been
       // inserted to the buffer, and thus |offset| should compensate for it.
       if (Equal(data, look_back_frames + idx)) {
         if (!state->reported()) {
           state->Increment(data, num_channels);
-          if (HasValidReport(state)) {
+          if (HasValidReport(state.get())) {
             repetition_callback_.Run(state->look_back_ms());
             state->set_reported(true);
           }
         }
       } else {
         state->Reset();
       }
     }
   }
 }
@@ skipping 36 matching lines @@
 void AudioRepetitionDetector::Reset(size_t num_channels, int sample_rate) {
   DCHECK(processing_thread_checker_.CalledOnValidThread());
   num_channels_ = num_channels;
   sample_rate_ = sample_rate;
 
   // |(xxx + 999) / 1000| is an arithmetic way to round up |xxx / 1000|.
   buffer_size_frames_ =
       (max_look_back_ms_ * sample_rate_ + 999) / 1000 + max_frames_;
 
   audio_buffer_.resize(buffer_size_frames_ * num_channels_);
-  for (State* state : states_)
+  for (const auto& state : states_)
     state->Reset();
 }
 
 void AudioRepetitionDetector::AddFramesToBuffer(const float* data,
                                                 size_t num_frames) {
   DCHECK(processing_thread_checker_.CalledOnValidThread());
   DCHECK_LE(num_frames, buffer_size_frames_);
   const size_t margin = buffer_size_frames_ - buffer_end_index_;
   const auto it = audio_buffer_.begin() + buffer_end_index_ * num_channels_;
   if (num_frames <= margin) {
@@ skipping 16 matching lines @@
   const float* buffer = &audio_buffer_[look_back_index * num_channels_];
   return memcmp(buffer, frame, num_channels_ * sizeof(audio_buffer_[0])) == 0;
 }
 
 bool AudioRepetitionDetector::HasValidReport(const State* state) const {
   return (!state->is_constant() && state->count_frames() >=
       static_cast<size_t>(min_length_ms_ * sample_rate_ / 1000));
 }
 
 }  // namespace content