Removing "using" declarations that import names in the C++ Standard library.(Source/platform/audio)

Source/platform/audio/SincResampler.cpp

 /*
  * Copyright (C) 2011 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 22 matching lines @@
 #include "platform/audio/SincResampler.h"
 
 #include "platform/audio/AudioBus.h"
 #include "wtf/CPU.h"
 #include "wtf/MathExtras.h"
 
 #if CPU(X86) || CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
-using namespace std;
-
 // Input buffer layout, dividing the total buffer into regions (r0 - r5):
 //
 // |----------------|----------------------------------------------------------------|----------------|
 //
 //                                              blockSize + kernelSize / 2
 //                   <-------------------------------------------------------------------------------->
 //                                                  r0
 //
 //   kernelSize / 2   kernelSize / 2                                 kernelSize / 2     kernelSize / 2
 // <---------------> <--------------->                              <---------------> <--------------->
@@ skipping 53 matching lines @@
     int halfSize = n / 2;
 
     // Generates a set of windowed sinc() kernels.
     // We generate a range of sub-sample offsets from 0.0 to 1.0.
     for (unsigned offsetIndex = 0; offsetIndex <= m_numberOfKernelOffsets; ++offsetIndex) {
         double subsampleOffset = static_cast<double>(offsetIndex) / m_numberOfKernelOffsets;
 
         for (int i = 0; i < n; ++i) {
             // Compute the sinc() with offset.
             double s = sincScaleFactor * piDouble * (i - halfSize - subsampleOffset);
-            double sinc = !s ? 1.0 : sin(s) / s;
+            double sinc = !s ? 1.0 : std::sin(s) / s;
             sinc *= sincScaleFactor;
 
             // Compute Blackman window, matching the offset of the sinc().
             double x = (i - subsampleOffset) / n;
-            double window = a0 - a1 * cos(twoPiDouble * x) + a2 * cos(twoPiDouble * 2.0 * x);
+            double window = a0 - a1 * std::cos(twoPiDouble * x) + a2 * std::cos(twoPiDouble * 2.0 * x);
 
             // Window the sinc() function and store at the correct offset.
             m_kernelStorage[i + offsetIndex * m_kernelSize] = sinc * window;
         }
     }
 }
 
 void SincResampler::consumeSource(float* buffer, unsigned numberOfSourceFrames)
 {
     ASSERT(m_sourceProvider);
@@ skipping 24 matching lines @@
     // Consumes samples from the in-memory buffer.
     virtual void provideInput(AudioBus* bus, size_t framesToProcess) OVERRIDE
     {
         ASSERT(m_source && bus);
         if (!m_source || !bus)
             return;
 
         float* buffer = bus->channel(0)->mutableData();
 
         // Clamp to number of frames available and zero-pad.
-        size_t framesToCopy = min(m_sourceFramesAvailable, framesToProcess);
+        size_t framesToCopy = std::min(m_sourceFramesAvailable, framesToProcess);
         memcpy(buffer, m_source, sizeof(float) * framesToCopy);
 
         // Zero-pad if necessary.
         if (framesToCopy < framesToProcess)
             memset(buffer + framesToCopy, 0, sizeof(float) * (framesToProcess - framesToCopy));
 
         m_sourceFramesAvailable -= framesToCopy;
         m_source += framesToCopy;
     }
 
 private:
     const float* m_source;
     size_t m_sourceFramesAvailable;
 };
 
 } // namespace
 
 void SincResampler::process(const float* source, float* destination, unsigned numberOfSourceFrames)
 {
     // Resample an in-memory buffer using an AudioSourceProvider.
     BufferSourceProvider sourceProvider(source, numberOfSourceFrames);
 
     unsigned numberOfDestinationFrames = static_cast<unsigned>(numberOfSourceFrames / m_scaleFactor);
     unsigned remaining = numberOfDestinationFrames;
 
     while (remaining) {
-        unsigned framesThisTime = min(remaining, m_blockSize);
+        unsigned framesThisTime = std::min(remaining, m_blockSize);
         process(&sourceProvider, destination, framesThisTime);
 
         destination += framesThisTime;
         remaining -= framesThisTime;
     }
 }
 
 void SincResampler::process(AudioSourceProvider* sourceProvider, float* destination, size_t framesToProcess)
 {
     bool isGood = sourceProvider && m_blockSize > m_kernelSize && m_inputBuffer.size() >= m_blockSize + m_kernelSize && !(m_kernelSize % 2);
@@ skipping 260 matching lines @@
 
         // Step (4)
         // Refresh the buffer with more input.
         consumeSource(r5, m_blockSize);
     }
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)