Remove OwnPtr from Blink.

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

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 15 matching lines @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/AudioFileReader.h"
 #include "platform/audio/DenormalDisabler.h"
 #include "platform/audio/SincResampler.h"
 #include "platform/audio/VectorMath.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioBus.h"
-#include "wtf/OwnPtr.h"
+#include "wtf/PtrUtil.h"
+#include <algorithm>
 #include <assert.h>
 #include <math.h>
-#include <algorithm>
+#include <memory>
 
 namespace blink {
 
 using namespace VectorMath;
 
 const unsigned MaxBusChannels = 32;
 
 PassRefPtr<AudioBus> AudioBus::create(unsigned numberOfChannels, size_t length, bool allocate)
 {
     ASSERT(numberOfChannels <= MaxBusChannels);
     if (numberOfChannels > MaxBusChannels)
         return nullptr;
 
     return adoptRef(new AudioBus(numberOfChannels, length, allocate));
 }
 
 AudioBus::AudioBus(unsigned numberOfChannels, size_t length, bool allocate)
     : m_length(length)
     , m_busGain(1)
     , m_isFirstTime(true)
     , m_sampleRate(0)
 {
     m_channels.reserveInitialCapacity(numberOfChannels);
 
     for (unsigned i = 0; i < numberOfChannels; ++i) {
-        PassOwnPtr<AudioChannel> channel = allocate ? adoptPtr(new AudioChannel(length)) : adoptPtr(new AudioChannel(0, length));
+        std::unique_ptr<AudioChannel> channel = allocate ? wrapUnique(new AudioChannel(length)) : wrapUnique(new AudioChannel(0, length));
         m_channels.append(std::move(channel));
     }
 
     m_layout = LayoutCanonical; // for now this is the only layout we define
 }
 
 void AudioBus::setChannelMemory(unsigned channelIndex, float* storage, size_t length)
 {
     if (channelIndex < m_channels.size()) {
         channel(channelIndex)->set(storage, length);
@@ skipping 406 matching lines @@
     // FIXME: this value may need tweaking.
     const float epsilon = 0.001f;
     float gainDiff = fabs(totalDesiredGain - gain);
 
     // Number of frames to de-zipper before we are close enough to the target gain.
     // FIXME: framesToDezipper could be smaller when target gain is close enough within this process loop.
     unsigned framesToDezipper = (gainDiff < epsilon) ? 0 : framesToProcess;
 
     if (framesToDezipper) {
         if (!m_dezipperGainValues.get() || m_dezipperGainValues->size() < framesToDezipper)
-            m_dezipperGainValues = adoptPtr(new AudioFloatArray(framesToDezipper));
+            m_dezipperGainValues = wrapUnique(new AudioFloatArray(framesToDezipper));
 
         float* gainValues = m_dezipperGainValues->data();
         for (unsigned i = 0; i < framesToDezipper; ++i) {
             gain += (totalDesiredGain - gain) * DezipperRate;
 
             // FIXME: If we are clever enough in calculating the framesToDezipper value, we can probably get
             // rid of this DenormalDisabler::flushDenormalFloatToZero() call.
             gain = DenormalDisabler::flushDenormalFloatToZero(gain);
             *gainValues++ = gain;
         }
@@ skipping 202 matching lines @@
 
     // If the bus needs no conversion then return as is.
     if ((!mixToMono || audioBus->numberOfChannels() == 1) && audioBus->sampleRate() == sampleRate)
         return audioBus;
 
     return AudioBus::createBySampleRateConverting(audioBus.get(), mixToMono, sampleRate);
 }
 
 } // namespace blink