s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

third_party/WebKit/Source/platform/audio/HRTFElevation.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 243 matching lines @@
     const String& subjectName,
     int elevation,
     float sampleRate) {
   bool isElevationGood =
       elevation >= -45 && elevation <= 90 && (elevation / 15) * 15 == elevation;
   ASSERT(isElevationGood);
   if (!isElevationGood)
     return nullptr;
 
   std::unique_ptr<HRTFKernelList> kernelListL =
-      makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
+      WTF::makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
   std::unique_ptr<HRTFKernelList> kernelListR =
-      makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
+      WTF::makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
 
   // Load convolution kernels from HRTF files.
   int interpolatedIndex = 0;
   for (unsigned rawIndex = 0; rawIndex < NumberOfRawAzimuths; ++rawIndex) {
     // Don't let elevation exceed maximum for this azimuth.
     int maxElevation = maxElevations[rawIndex];
     int actualElevation = std::min(elevation, maxElevation);
 
     bool success = calculateKernelsForAzimuthElevation(
         rawIndex * AzimuthSpacing, actualElevation, sampleRate, subjectName,
@@ skipping 13 matching lines @@
       float x =
           float(jj) / float(InterpolationFactor);  // interpolate from 0 -> 1
 
       (*kernelListL)[i + jj] = HRTFKernel::createInterpolatedKernel(
           kernelListL->at(i).get(), kernelListL->at(j).get(), x);
       (*kernelListR)[i + jj] = HRTFKernel::createInterpolatedKernel(
           kernelListR->at(i).get(), kernelListR->at(j).get(), x);
     }
   }
 
-  std::unique_ptr<HRTFElevation> hrtfElevation = wrapUnique(new HRTFElevation(
-      std::move(kernelListL), std::move(kernelListR), elevation, sampleRate));
+  std::unique_ptr<HRTFElevation> hrtfElevation = WTF::wrapUnique(
+      new HRTFElevation(std::move(kernelListL), std::move(kernelListR),
+                        elevation, sampleRate));
   return hrtfElevation;
 }
 
 std::unique_ptr<HRTFElevation> HRTFElevation::createByInterpolatingSlices(
     HRTFElevation* hrtfElevation1,
     HRTFElevation* hrtfElevation2,
     float x,
     float sampleRate) {
   ASSERT(hrtfElevation1 && hrtfElevation2);
   if (!hrtfElevation1 || !hrtfElevation2)
     return nullptr;
 
   ASSERT(x >= 0.0 && x < 1.0);
 
   std::unique_ptr<HRTFKernelList> kernelListL =
-      makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
+      WTF::makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
   std::unique_ptr<HRTFKernelList> kernelListR =
-      makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
+      WTF::makeUnique<HRTFKernelList>(NumberOfTotalAzimuths);
 
   HRTFKernelList* kernelListL1 = hrtfElevation1->kernelListL();
   HRTFKernelList* kernelListR1 = hrtfElevation1->kernelListR();
   HRTFKernelList* kernelListL2 = hrtfElevation2->kernelListL();
   HRTFKernelList* kernelListR2 = hrtfElevation2->kernelListR();
 
   // Interpolate kernels of corresponding azimuths of the two elevations.
   for (unsigned i = 0; i < NumberOfTotalAzimuths; ++i) {
     (*kernelListL)[i] = HRTFKernel::createInterpolatedKernel(
         kernelListL1->at(i).get(), kernelListL2->at(i).get(), x);
     (*kernelListR)[i] = HRTFKernel::createInterpolatedKernel(
         kernelListR1->at(i).get(), kernelListR2->at(i).get(), x);
   }
 
   // Interpolate elevation angle.
   double angle = (1.0 - x) * hrtfElevation1->elevationAngle() +
                  x * hrtfElevation2->elevationAngle();
 
-  std::unique_ptr<HRTFElevation> hrtfElevation = wrapUnique(
+  std::unique_ptr<HRTFElevation> hrtfElevation = WTF::wrapUnique(
       new HRTFElevation(std::move(kernelListL), std::move(kernelListR),
                         static_cast<int>(angle), sampleRate));
   return hrtfElevation;
 }
 
 void HRTFElevation::getKernelsFromAzimuth(double azimuthBlend,
                                           unsigned azimuthIndex,
                                           HRTFKernel*& kernelL,
                                           HRTFKernel*& kernelR,
                                           double& frameDelayL,
@@ skipping 25 matching lines @@
   double frameDelay2R = m_kernelListR->at(azimuthIndex2)->frameDelay();
 
   // Linearly interpolate delays.
   frameDelayL =
       (1.0 - azimuthBlend) * frameDelayL + azimuthBlend * frameDelay2L;
   frameDelayR =
       (1.0 - azimuthBlend) * frameDelayR + azimuthBlend * frameDelay2R;
 }
 
 }  // namespace blink