Removing using declarations that import names in the C++ Standard library.

Source/core/html/MediaController.cpp

 /*
  * Copyright (C) 2011 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/GenericEventQueue.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/TimeRanges.h"
 #include "platform/Clock.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/AtomicString.h"
 
-using namespace std;
-
 namespace WebCore {
 
 PassRefPtrWillBeRawPtr<MediaController> MediaController::create(ExecutionContext* context)
 {
     return adoptRefWillBeRefCountedGarbageCollected(new MediaController(context));
 }
 
 MediaController::MediaController(ExecutionContext* context)
     : m_paused(false)
     , m_defaultPlaybackRate(1)
@@ skipping 79 matching lines @@
 
 double MediaController::duration() const
 {
     // FIXME: Investigate caching the maximum duration and only updating the cached value
     // when the slaved media elements' durations change.
     double maxDuration = 0;
     for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
         double duration = (*it)->duration();
         if (std::isnan(duration))
             continue;
-        maxDuration = max(maxDuration, duration);
+        maxDuration = std::max(maxDuration, duration);
     }
     return maxDuration;
 }
 
 double MediaController::currentTime() const
 {
     if (m_mediaElements.isEmpty())
         return 0;
 
     if (m_position == MediaPlayer::invalidTime()) {
         // Some clocks may return times outside the range of [0..duration].
-        m_position = max(0.0, min(duration(), m_clock->currentTime()));
+        m_position = std::max(0.0, std::min(duration(), m_clock->currentTime()));
         m_clearPositionTimer.startOneShot(0, FROM_HERE);
     }
 
     return m_position;
 }
 
 void MediaController::setCurrentTime(double time, ExceptionState& exceptionState)
 {
     // When the user agent is to seek the media controller to a particular new playback position,
     // it must follow these steps:
     // If the new playback position is less than zero, then set it to zero.
-    time = max(0.0, time);
+    time = std::max(0.0, time);
 
     // If the new playback position is greater than the media controller duration, then set it
     // to the media controller duration.
-    time = min(time, duration());
+    time = std::min(time, duration());
 
     // Set the media controller position to the new playback position.
     m_position = time;
     m_clock->setCurrentTime(time);
 
     // Seek each slaved media element to the new playback position relative to the media element timeline.
     for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
         (*it)->seek(time, exceptionState);
 
     scheduleTimeupdateEvent();
@@ skipping 176 matching lines @@
 
     if (m_mediaElements.isEmpty()) {
         // If the MediaController has no slaved media elements, let new readiness state be 0.
         newReadyState = HTMLMediaElement::HAVE_NOTHING;
     } else {
         // Otherwise, let it have the lowest value of the readyState IDL attributes of all of its
         // slaved media elements.
         MediaElementSequence::const_iterator it = m_mediaElements.begin();
         newReadyState = (*it)->readyState();
         for (++it; it != m_mediaElements.end(); ++it)
-            newReadyState = min(newReadyState, (*it)->readyState());
+            newReadyState = std::min(newReadyState, (*it)->readyState());
     }
 
     if (newReadyState == oldReadyState)
         return;
 
     // If the MediaController's most recently reported readiness state is greater than new readiness
     // state then queue a task to fire a simple event at the MediaController object, whose name is the
     // event name corresponding to the value of new readiness state given in the table below. [omitted]
     if (oldReadyState > newReadyState) {
         scheduleEvent(eventNameForReadyState(newReadyState));
@@ skipping 233 matching lines @@
     m_previousTimeupdateTime = now;
 }
 
 void MediaController::trace(Visitor* visitor)
 {
     visitor->trace(m_mediaElements);
     EventTargetWithInlineData::trace(visitor);
 }
 
 }