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

Source/platform/Timer.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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 17 matching lines @@
 #include "platform/Timer.h"
 
 #include "platform/PlatformThreadData.h"
 #include "platform/ThreadTimers.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashSet.h"
 #include <limits.h>
 #include <math.h>
 #include <limits>
 
-using namespace std;
-
 namespace blink {
 
 class TimerHeapReference;
 
 // Timers are stored in a heap data structure, used to implement a priority queue.
 // This allows us to efficiently determine which timer needs to fire the soonest.
 // Then we set a single shared system timer to fire at that time.
 //
 // When a timer's "next fire time" changes, we need to move it around in the priority queue.
 static Vector<TimerBase*>& threadGlobalTimerHeap()
@@ skipping 49 matching lines @@
 
     // Invoke the assignment operator, since that takes care of updating m_heapIndex.
     a = timerB;
     b = timerA;
 }
 
 // ----------------
 
 // Class to represent iterators in the heap when calling the standard library heap algorithms.
 // Uses a custom pointer and reference type that update indices for pointers in the heap.
-class TimerHeapIterator : public iterator<random_access_iterator_tag, TimerBase*, ptrdiff_t, TimerHeapPointer, TimerHeapReference> {
+class TimerHeapIterator : public std::iterator<std::random_access_iterator_tag, TimerBase*, ptrdiff_t, TimerHeapPointer, TimerHeapReference> {
 public:
     explicit TimerHeapIterator(TimerBase** pointer) : m_pointer(pointer) { checkConsistency(); }
 
     TimerHeapIterator& operator++() { checkConsistency(); ++m_pointer; checkConsistency(); return *this; }
     TimerHeapIterator operator++(int) { checkConsistency(1); return TimerHeapIterator(m_pointer++); }
 
     TimerHeapIterator& operator--() { checkConsistency(); --m_pointer; checkConsistency(); return *this; }
     TimerHeapIterator operator--(int) { checkConsistency(-1); return TimerHeapIterator(m_pointer--); }
 
     TimerHeapIterator& operator+=(ptrdiff_t i) { checkConsistency(); m_pointer += i; checkConsistency(); return *this; }
@@ skipping 53 matching lines @@
     // The comparisons below are "backwards" because the heap puts the largest
     // element first and we want the lowest time to be the first one in the heap.
     double aFireTime = a->m_nextFireTime;
     double bFireTime = b->m_nextFireTime;
     if (bFireTime != aFireTime)
         return bFireTime < aFireTime;
 
     // We need to look at the difference of the insertion orders instead of comparing the two
     // outright in case of overflow.
     unsigned difference = a->m_heapInsertionOrder - b->m_heapInsertionOrder;
-    return difference < numeric_limits<unsigned>::max() / 2;
+    return difference < std::numeric_limits<unsigned>::max() / 2;
 }
 
 // ----------------
 
 TimerBase::TimerBase()
     : m_nextFireTime(0)
     , m_unalignedNextFireTime(0)
     , m_repeatInterval(0)
     , m_heapIndex(-1)
     , m_cachedThreadGlobalTimerHeap(0)
@@ skipping 93 matching lines @@
     ASSERT(!inHeap());
     timerHeap().append(this);
     m_heapIndex = timerHeap().size() - 1;
     heapDecreaseKey();
 }
 
 inline void TimerBase::heapPop()
 {
     // Temporarily force this timer to have the minimum key so we can pop it.
     double fireTime = m_nextFireTime;
-    m_nextFireTime = -numeric_limits<double>::infinity();
+    m_nextFireTime = -std::numeric_limits<double>::infinity();
     heapDecreaseKey();
     heapPopMin();
     m_nextFireTime = fireTime;
 }
 
 void TimerBase::heapPopMin()
 {
     ASSERT(this == timerHeap().first());
     checkHeapIndex();
     Vector<TimerBase*>& heap = timerHeap();
@@ skipping 94 matching lines @@
 }
 
 void TimerBase::didChangeAlignmentInterval()
 {
     setNextFireTime(m_unalignedNextFireTime);
 }
 
 double TimerBase::nextUnalignedFireInterval() const
 {
     ASSERT(isActive());
-    return max(m_unalignedNextFireTime - monotonicallyIncreasingTime(), 0.0);
+    return std::max(m_unalignedNextFireTime - monotonicallyIncreasingTime(), 0.0);
 }
 
 } // namespace blink