Simplify MediaController with C++11 range-base for loops

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 116 matching lines @@
     for (++it; it != m_mediaElements.end(); ++it)
         playedRanges->unionWith((*it)->played().get());
     return playedRanges;
 }
 
 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();
+    for (const HTMLMediaElement* element : m_mediaElements) {
+        double duration = element->duration();
         if (std::isnan(duration))
             continue;
         maxDuration = std::max(maxDuration, duration);
     }
     return maxDuration;
 }
 
 double MediaController::currentTime() const
 {
     if (m_mediaElements.isEmpty())
@@ skipping 17 matching lines @@
 
     // If the new playback position is greater than the media controller duration, then set it
     // to the media controller 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);
+    for (HTMLMediaElement* element : m_mediaElements)
+        element->seek(time);
 
     scheduleTimeupdateEvent();
 }
 
 void MediaController::unpause()
 {
     // When the unpause() method is invoked, if the MediaController is a paused media controller,
     if (!m_paused)
         return;
 
     // the user agent must change the MediaController into a playing media controller,
     m_paused = false;
     // queue a task to fire a simple event named play at the MediaController,
     scheduleEvent(EventTypeNames::play);
     // and then report the controller state of the MediaController.
     reportControllerState();
 }
 
 void MediaController::play()
 {
     // When the play() method is invoked, the user agent must invoke the play method of each
     // slaved media element in turn,
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
-        (*it)->play();
+    for (HTMLMediaElement* element : m_mediaElements)
+        element->play();
 
     // and then invoke the unpause method of the MediaController.
     unpause();
 }
 
 void MediaController::pause()
 {
     // When the pause() method is invoked, if the MediaController is a playing media controller,
     if (m_paused)
         return;
@@ skipping 26 matching lines @@
 
 void MediaController::setPlaybackRate(double rate)
 {
     if (m_clock->playRate() == rate)
         return;
 
     // The playbackRate attribute, on setting, must set the MediaController's media controller
     // playback rate to the new value,
     m_clock->setPlayRate(rate);
 
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
-        (*it)->updatePlaybackRate();
+    for (HTMLMediaElement* element : m_mediaElements)
+        element->updatePlaybackRate();
 
     // then queue a task to fire a simple event named ratechange at the MediaController.
     scheduleEvent(EventTypeNames::ratechange);
 }
 
 void MediaController::setVolume(double level, ExceptionState& exceptionState)
 {
     if (m_volume == level)
         return;
 
     // If the new value is outside the range 0.0 to 1.0 inclusive, then, on setting, an
     // IndexSizeError exception must be raised instead.
     if (level < 0 || level > 1) {
         exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexOutsideRange("volume", level, 0.0, ExceptionMessages::InclusiveBound, 1.0, ExceptionMessages::InclusiveBound));
         return;
     }
 
     // The volume attribute, on setting, if the new value is in the range 0.0 to 1.0 inclusive,
     // must set the MediaController's media controller volume multiplier to the new value
     m_volume = level;
 
     // and queue a task to fire a simple event named volumechange at the MediaController.
     scheduleEvent(EventTypeNames::volumechange);
 
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
-        (*it)->updateVolume();
+    for (HTMLMediaElement* element : m_mediaElements)
+        element->updateVolume();
 }
 
 void MediaController::setMuted(bool flag)
 {
     if (m_muted == flag)
         return;
 
     // The muted attribute, on setting, must set the MediaController's media controller mute override
     // to the new value
     m_muted = flag;
 
     // and queue a task to fire a simple event named volumechange at the MediaController.
     scheduleEvent(EventTypeNames::volumechange);
 
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
-        (*it)->updateVolume();
+    for (HTMLMediaElement* element : m_mediaElements)
+        element->updateVolume();
 }
 
 static const AtomicString& playbackStateWaiting()
 {
     DEFINE_STATIC_LOCAL(AtomicString, waiting, ("waiting", AtomicString::ConstructFromLiteral));
     return waiting;
 }
 
 static const AtomicString& playbackStatePlaying()
 {
@@ skipping 162 matching lines @@
     scheduleEvent(eventName);
 
     // Let the MediaController's most recently reported playback state be new playback state.
     m_playbackState = newPlaybackState;
 
     updateMediaElements();
 }
 
 void MediaController::updateMediaElements()
 {
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
-        (*it)->updatePlayState();
+    for (HTMLMediaElement* element : m_mediaElements)
+        element->updatePlayState();
 }
 
 void MediaController::bringElementUpToSpeed(HTMLMediaElement* element)
 {
     ASSERT(element);
     ASSERT(m_mediaElements.contains(element));
 
     // When the user agent is to bring a media element up to speed with its new media controller,
     // it must seek that media element to the MediaController's media controller position relative
     // to the media element's timeline.
     element->seek(currentTime());
 
     // Update volume to take controller volume and mute into account.
     element->updateVolume();
 }
 
 bool MediaController::isRestrained() const
 {
     ASSERT(!m_mediaElements.isEmpty());
 
     // A MediaController is a restrained media controller if the MediaController is a playing media
     // controller,
     if (m_paused)
         return false;
 
     bool anyAutoplayingAndPaused = false;
     bool allPaused = true;
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
-        HTMLMediaElement* element = *it;
-
+    for (const HTMLMediaElement* element : m_mediaElements) {
         if (element->isAutoplaying() && element->paused())
             anyAutoplayingAndPaused = true;
 
         if (!element->paused())
             allPaused = false;
     }
 
     // but either at least one of its slaved media elements whose autoplaying flag is true still has
     // its paused attribute set to true, or, all of its slaved media elements have their paused
     // attribute set to true.
     return anyAutoplayingAndPaused || allPaused;
 }
 
 bool MediaController::isBlocked() const
 {
     ASSERT(!m_mediaElements.isEmpty());
 
     // A MediaController is a blocked media controller if the MediaController is a paused media
     // controller,
     if (m_paused)
         return true;
 
     bool allPaused = true;
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
-        HTMLMediaElement* element = *it;
-
+    for (const HTMLMediaElement* element : m_mediaElements) {
         // or if any of its slaved media elements are blocked media elements,
         if (element->isBlocked())
             return true;
 
         // or if any of its slaved media elements whose autoplaying flag is true still have their
         // paused attribute set to true,
         if (element->isAutoplaying() && element->paused())
             return true;
 
         if (!element->paused())
             allPaused = false;
     }
 
     // or if all of its slaved media elements have their paused attribute set to true.
     return allPaused;
 }
 
 bool MediaController::hasEnded() const
 {
     // If the ... media controller playback rate is positive or zero
     if (m_clock->playRate() < 0)
         return false;
 
     // [and] all of the MediaController's slaved media elements have ended playback ... let new
     // playback state be ended.
     if (m_mediaElements.isEmpty())
         return false;
 
     bool allHaveEnded = true;
-    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
-        if (!(*it)->ended())
+    for (const HTMLMediaElement* element : m_mediaElements) {
+        if (!element->ended())
             allHaveEnded = false;
     }
     return allHaveEnded;
 }
 
 void MediaController::scheduleEvent(const AtomicString& eventName)
 {
     m_pendingEventsQueue->enqueueEvent(Event::createCancelable(eventName));
 }
 
@@ skipping 40 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_mediaElements);
     visitor->trace(m_pendingEventsQueue);
     visitor->trace(m_executionContext);
 #endif
     EventTargetWithInlineData::trace(visitor);
 }
 
 }