Convert //media/filters from scoped_ptr to std::unique_ptr

media/filters/wsola_internals.cc

 // Copyright 2013 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "media/filters/wsola_internals.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
+#include <memory>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "media/base/audio_bus.h"
 
 namespace media {
 
 namespace internal {
 
 bool InInterval(int n, Interval q) {
   return n >= q.first && n <= q.second;
 }
 
@@ skipping 81 matching lines @@
 
 int DecimatedSearch(int decimation,
                     Interval exclude_interval,
                     const AudioBus* target_block,
                     const AudioBus* search_segment,
                     const float* energy_target_block,
                     const float* energy_candidate_blocks) {
   int channels = search_segment->channels();
   int block_size = target_block->frames();
   int num_candidate_blocks = search_segment->frames() - (block_size - 1);
-  scoped_ptr<float[]> dot_prod(new float[channels]);
+  std::unique_ptr<float[]> dot_prod(new float[channels]);
   float similarity[3];  // Three elements for cubic interpolation.
 
   int n = 0;
   MultiChannelDotProduct(target_block, 0, search_segment, n, block_size,
                          dot_prod.get());
   similarity[0] = MultiChannelSimilarityMeasure(
       dot_prod.get(), energy_target_block,
       &energy_candidate_blocks[n * channels], channels);
 
   // Set the starting point as optimal point.
@@ skipping 57 matching lines @@
 
 int FullSearch(int low_limit,
                int high_limit,
                Interval exclude_interval,
                const AudioBus* target_block,
                const AudioBus* search_block,
                const float* energy_target_block,
                const float* energy_candidate_blocks) {
   int channels = search_block->channels();
   int block_size = target_block->frames();
-  scoped_ptr<float[]> dot_prod(new float[channels]);
+  std::unique_ptr<float[]> dot_prod(new float[channels]);
 
   float best_similarity = std::numeric_limits<float>::min();
   int optimal_index = 0;
 
   for (int n = low_limit; n <= high_limit; ++n) {
     if (InInterval(n, exclude_interval)) {
       continue;
     }
     MultiChannelDotProduct(target_block, 0, search_block, n, block_size,
                            dot_prod.get());
@@ skipping 20 matching lines @@
   int num_candidate_blocks = search_block->frames() - (target_size - 1);
 
   // This is a compromise between complexity reduction and search accuracy. I
   // don't have a proof that down sample of order 5 is optimal. One can compute
   // a decimation factor that minimizes complexity given the size of
   // |search_block| and |target_block|. However, my experiments show the rate of
   // missing the optimal index is significant. This value is chosen
   // heuristically based on experiments.
   const int kSearchDecimation = 5;
 
-  scoped_ptr<float[]> energy_target_block(new float[channels]);
-  scoped_ptr<float[]> energy_candidate_blocks(
+  std::unique_ptr<float[]> energy_target_block(new float[channels]);
+  std::unique_ptr<float[]> energy_candidate_blocks(
       new float[channels * num_candidate_blocks]);
 
   // Energy of all candid frames.
   MultiChannelMovingBlockEnergies(search_block, target_size,
                                   energy_candidate_blocks.get());
 
   // Energy of target frame.
   MultiChannelDotProduct(target_block, 0, target_block, 0,
                          target_size, energy_target_block.get());
 
@@ skipping 13 matching lines @@
 void GetSymmetricHanningWindow(int window_length, float* window) {
   const float scale = 2.0f * M_PI / window_length;
   for (int n = 0; n < window_length; ++n)
     window[n] = 0.5f * (1.0f - cosf(n * scale));
 }
 
 }  // namespace internal
 
 }  // namespace media