Replace base::MakeUnique with std::make_unique in platform/audio of blink

This CL has done below ones,
 - Replacing base::MakeUnique|WTF::MakeUnique with std::make_unique
 - Replacing PtrUtil.h with <memory>

Bug: 755727
Change-Id: I78c514e53fa7902172a6f6b5b5c66d74d8efb0d8
Reviewed-on: https://chromium-review.googlesource.com/687374
Commit-Queue: Gyuyoung Kim <gyuyoung.kim@chromium.org>
Reviewed-by: Hongchan Choi <hongchan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#505341}

third_party/WebKit/Source/platform/audio/AudioBus.cpp

@@ -37,7 +37,6 @@
 #include "platform/audio/DenormalDisabler.h"
 #include "platform/audio/SincResampler.h"
 #include "platform/audio/VectorMath.h"
-#include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioBus.h"
 
@@ -537,9 +536,10 @@ void AudioBus::CopyWithGainFrom(const AudioBus& source_bus,
 
   if (frames_to_dezipper) {
     if (!dezipper_gain_values_.get() ||
-        dezipper_gain_values_->size() < frames_to_dezipper)
+        dezipper_gain_values_->size() < frames_to_dezipper) {
       dezipper_gain_values_ =
-          WTF::MakeUnique<AudioFloatArray>(frames_to_dezipper);
+          std::make_unique<AudioFloatArray>(frames_to_dezipper);
+    }
 
     float* gain_values = dezipper_gain_values_->Data();
     for (unsigned i = 0; i < frames_to_dezipper; ++i) {

third_party/WebKit/Source/platform/audio/AudioResampler.cpp

@@ -25,21 +25,21 @@
 
 #include "platform/audio/AudioResampler.h"
 #include <algorithm>
+#include <memory>
 #include "platform/wtf/MathExtras.h"
-#include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 const double AudioResampler::kMaxRate = 8.0;
 
 AudioResampler::AudioResampler() : rate_(1.0) {
-  kernels_.push_back(WTF::MakeUnique<AudioResamplerKernel>(this));
+  kernels_.push_back(std::make_unique<AudioResamplerKernel>(this));
   source_bus_ = AudioBus::Create(1, 0, false);
 }
 
 AudioResampler::AudioResampler(unsigned number_of_channels) : rate_(1.0) {
   for (unsigned i = 0; i < number_of_channels; ++i)
-    kernels_.push_back(WTF::MakeUnique<AudioResamplerKernel>(this));
+    kernels_.push_back(std::make_unique<AudioResamplerKernel>(this));
 
   source_bus_ = AudioBus::Create(number_of_channels, 0, false);
 }
@@ -52,7 +52,7 @@ void AudioResampler::ConfigureChannels(unsigned number_of_channels) {
   // First deal with adding or removing kernels.
   if (number_of_channels > current_size) {
     for (unsigned i = current_size; i < number_of_channels; ++i)
-      kernels_.push_back(WTF::MakeUnique<AudioResamplerKernel>(this));
+      kernels_.push_back(std::make_unique<AudioResamplerKernel>(this));
   } else
     kernels_.resize(number_of_channels);
 

third_party/WebKit/Source/platform/audio/DynamicsCompressorKernel.cpp

@@ -76,7 +76,7 @@ void DynamicsCompressorKernel::SetNumberOfChannels(
   pre_delay_buffers_.clear();
   for (unsigned i = 0; i < number_of_channels; ++i) {
     pre_delay_buffers_.push_back(
-        WTF::MakeUnique<AudioFloatArray>(kMaxPreDelayFrames));
+        std::make_unique<AudioFloatArray>(kMaxPreDelayFrames));
   }
 }
 

third_party/WebKit/Source/platform/audio/HRTFElevation.cpp

@@ -33,7 +33,6 @@
 #include <memory>
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/HRTFPanner.h"
-#include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/ThreadingPrimitives.h"
 #include "platform/wtf/text/StringHash.h"
 
@@ -232,9 +231,9 @@ std::unique_ptr<HRTFElevation> HRTFElevation::CreateForSubject(
     return nullptr;
 
   std::unique_ptr<HRTFKernelList> kernel_list_l =
-      WTF::MakeUnique<HRTFKernelList>(kNumberOfTotalAzimuths);
+      std::make_unique<HRTFKernelList>(kNumberOfTotalAzimuths);
   std::unique_ptr<HRTFKernelList> kernel_list_r =
-      WTF::MakeUnique<HRTFKernelList>(kNumberOfTotalAzimuths);
+      std::make_unique<HRTFKernelList>(kNumberOfTotalAzimuths);
 
   // Load convolution kernels from HRTF files.
   int interpolated_index = 0;
@@ -289,9 +288,9 @@ std::unique_ptr<HRTFElevation> HRTFElevation::CreateByInterpolatingSlices(
   DCHECK_LT(x, 1.0);
 
   std::unique_ptr<HRTFKernelList> kernel_list_l =
-      WTF::MakeUnique<HRTFKernelList>(kNumberOfTotalAzimuths);
+      std::make_unique<HRTFKernelList>(kNumberOfTotalAzimuths);
   std::unique_ptr<HRTFKernelList> kernel_list_r =
-      WTF::MakeUnique<HRTFKernelList>(kNumberOfTotalAzimuths);
+      std::make_unique<HRTFKernelList>(kNumberOfTotalAzimuths);
 
   HRTFKernelList* kernel_list_l1 = hrtf_elevation1->KernelListL();
   HRTFKernelList* kernel_list_r1 = hrtf_elevation1->KernelListR();

third_party/WebKit/Source/platform/audio/HRTFKernel.cpp

@@ -97,7 +97,7 @@ HRTFKernel::HRTFKernel(AudioChannel* channel,
     }
   }
 
-  fft_frame_ = WTF::MakeUnique<FFTFrame>(fft_size);
+  fft_frame_ = std::make_unique<FFTFrame>(fft_size);
   fft_frame_->DoPaddedFFT(impulse_response, truncated_response_length);
 }
 

third_party/WebKit/Source/platform/audio/MultiChannelResampler.cpp

@@ -27,8 +27,9 @@
  */
 
 #include "platform/audio/MultiChannelResampler.h"
+
+#include <memory>
 #include "platform/audio/AudioBus.h"
-#include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
@@ -101,7 +102,7 @@ MultiChannelResampler::MultiChannelResampler(double scale_factor,
   // Create each channel's resampler.
   for (unsigned channel_index = 0; channel_index < number_of_channels;
        ++channel_index)
-    kernels_.push_back(WTF::MakeUnique<SincResampler>(scale_factor));
+    kernels_.push_back(std::make_unique<SincResampler>(scale_factor));
 }
 
 void MultiChannelResampler::Process(AudioSourceProvider* provider,

third_party/WebKit/Source/platform/audio/Panner.cpp

@@ -31,7 +31,6 @@
 #include <memory>
 #include "platform/audio/EqualPowerPanner.h"
 #include "platform/audio/HRTFPanner.h"
-#include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
@@ -40,10 +39,10 @@ std::unique_ptr<Panner> Panner::Create(PanningModel model,
                                        HRTFDatabaseLoader* database_loader) {
   switch (model) {
     case kPanningModelEqualPower:
-      return WTF::MakeUnique<EqualPowerPanner>(sample_rate);
+      return std::make_unique<EqualPowerPanner>(sample_rate);
 
     case kPanningModelHRTF:
-      return WTF::MakeUnique<HRTFPanner>(sample_rate, database_loader);
+      return std::make_unique<HRTFPanner>(sample_rate, database_loader);
 
     default:
       NOTREACHED();

third_party/WebKit/Source/platform/audio/PushPullFIFOMultithreadTest.cpp

@@ -12,7 +12,6 @@
 #include "platform/audio/AudioUtilities.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/wtf/Functional.h"
-#include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -29,7 +28,7 @@ class FIFOClient {
       : fifo_(fifo),
         bus_(AudioBus::Create(fifo->NumberOfChannels(), bus_length)),
         client_thread_(Platform::Current()->CreateThread("client thread")),
-        done_event_(WTF::MakeUnique<WaitableEvent>()),
+        done_event_(std::make_unique<WaitableEvent>()),
         jitter_range_ms_(jitter_range_ms) {}
 
   WaitableEvent* Start(double duration_ms, double interval_ms) {

third_party/WebKit/Source/platform/audio/ReverbConvolverStage.cpp

@@ -27,6 +27,8 @@
  */
 
 #include "platform/audio/ReverbConvolverStage.h"
+
+#include <memory>
 #include "platform/audio/ReverbAccumulationBuffer.h"
 #include "platform/audio/ReverbConvolver.h"
 #include "platform/audio/ReverbInputBuffer.h"
@@ -56,16 +58,16 @@ ReverbConvolverStage::ReverbConvolverStage(
   DCHECK(accumulation_buffer);
 
   if (!direct_mode_) {
-    fft_kernel_ = WTF::MakeUnique<FFTFrame>(fft_size);
+    fft_kernel_ = std::make_unique<FFTFrame>(fft_size);
     fft_kernel_->DoPaddedFFT(impulse_response + stage_offset, stage_length);
-    fft_convolver_ = WTF::MakeUnique<FFTConvolver>(fft_size);
+    fft_convolver_ = std::make_unique<FFTConvolver>(fft_size);
   } else {
     DCHECK(!stage_offset);
     DCHECK_LE(stage_length, fft_size / 2);
 
     direct_kernel_ = WTF::WrapUnique(new AudioFloatArray(fft_size / 2));
     direct_kernel_->CopyToRange(impulse_response, 0, stage_length);
-    direct_convolver_ = WTF::MakeUnique<DirectConvolver>(render_slice_size);
+    direct_convolver_ = std::make_unique<DirectConvolver>(render_slice_size);
   }
   temporary_buffer_.Allocate(render_slice_size);