Use C++11 features in core/html

Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 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 107 matching lines @@
 // Default to not logging warnings about excessive drift in the cached media time because it adds a
 // fair amount of overhead and logging.
 #define LOG_CACHED_TIME_WARNINGS 0
 #endif
 
 // URL protocol used to signal that the media source API is being used.
 static const char mediaSourceBlobProtocol[] = "blob";
 
 using namespace HTMLNames;
 
-typedef WillBeHeapHashSet<RawPtrWillBeWeakMember<HTMLMediaElement> > WeakMediaElementSet;
+typedef WillBeHeapHashSet<RawPtrWillBeWeakMember<HTMLMediaElement>> WeakMediaElementSet;
 typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<Document>, WeakMediaElementSet> DocumentElementSetMap;
 static DocumentElementSetMap& documentToElementSetMap()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<DocumentElementSetMap>, map, (adoptPtrWillBeNoop(new DocumentElementSetMap())));
     return *map;
 }
 
 static void addElementToDocumentMap(HTMLMediaElement* element, Document* document)
 {
     DocumentElementSetMap& map = documentToElementSetMap();
@@ skipping 181 matching lines @@
     , m_volume(1.0f)
     , m_lastSeekTime(0)
     , m_previousProgressTime(std::numeric_limits<double>::max())
     , m_duration(std::numeric_limits<double>::quiet_NaN())
     , m_lastTimeUpdateEventWallTime(0)
     , m_lastTimeUpdateEventMovieTime(0)
     , m_defaultPlaybackStartPosition(0)
     , m_loadState(WaitingForSource)
     , m_deferredLoadState(NotDeferred)
     , m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired)
-    , m_webLayer(0)
+    , m_webLayer(nullptr)
     , m_preload(MediaPlayer::Auto)
     , m_displayMode(Unknown)
     , m_cachedTime(MediaPlayer::invalidTime())
     , m_fragmentEndTime(MediaPlayer::invalidTime())
     , m_pendingActionFlags(0)
     , m_userGestureRequiredForPlay(false)
     , m_playing(false)
     , m_shouldDelayLoadEvent(false)
     , m_haveFiredLoadedData(false)
     , m_active(true)
@@ skipping 840 matching lines @@
     // 4 - If the current playback position has, since the last time this
     // algorithm was run, only changed through its usual monotonic increase
     // during normal playback, then let missed cues be the list of cues in other
     // cues whose start times are greater than or equal to last time and whose
     // end times are less than or equal to the current playback position.
     // Otherwise, let missed cues be an empty list.
     if (lastTime >= 0 && m_lastSeekTime < movieTime) {
         CueList potentiallySkippedCues =
             m_cueTree.allOverlaps(m_cueTree.createInterval(lastTime, movieTime));
 
-        for (size_t i = 0; i < potentiallySkippedCues.size(); ++i) {
-            double cueStartTime = potentiallySkippedCues[i].low();
-            double cueEndTime = potentiallySkippedCues[i].high();
-
+        for (CueInterval cue : potentiallySkippedCues) {
             // Consider cues that may have been missed since the last seek time.
-            if (cueStartTime > std::max(m_lastSeekTime, lastTime) && cueEndTime < movieTime)
-                missedCues.append(potentiallySkippedCues[i]);
+            if (cue.low() > std::max(m_lastSeekTime, lastTime) && cue.high() < movieTime)
+                missedCues.append(cue);
         }
     }
 
     m_lastTextTrackUpdateTime = movieTime;
 
     // 5 - If the time was reached through the usual monotonic increase of the
     // current playback position during normal playback, and if the user agent
     // has not fired a timeupdate event at the element in the past 15 to 250ms
     // and is not still running event handlers for such an event, then the user
     // agent must queue a task to fire a simple event named timeupdate at the
@@ skipping 11 matching lines @@
     // 6 - If all of the cues in current cues have their text track cue active
     // flag set, none of the cues in other cues have their text track cue active
     // flag set, and missed cues is empty, then abort these steps.
     bool activeSetChanged = missedCuesSize;
 
     for (size_t i = 0; !activeSetChanged && i < previousCuesSize; ++i) {
         if (!currentCues.contains(previousCues[i]) && previousCues[i].data()->isActive())
             activeSetChanged = true;
     }
 
-    for (size_t i = 0; i < currentCuesSize; ++i) {
-        currentCues[i].data()->updateDisplayTree(movieTime);
+    for (CueInterval currentCue : currentCues) {
+        currentCue.data()->updateDisplayTree(movieTime);
 
-        if (!currentCues[i].data()->isActive())
+        if (!currentCue.data()->isActive())
             activeSetChanged = true;
     }
 
     if (!activeSetChanged)
         return;
 
     // 7 - If the time was reached through the usual monotonic increase of the
     // current playback position during normal playback, and there are cues in
     // other cues that have their text track cue pause-on-exi flag set and that
     // either have their text track cue active flag set or are also in missed
     // cues, then immediately pause the media element.
     for (size_t i = 0; !m_paused && i < previousCuesSize; ++i) {
         if (previousCues[i].data()->pauseOnExit()
             && previousCues[i].data()->isActive()
             && !currentCues.contains(previousCues[i]))
             pause();
     }
 
     for (size_t i = 0; !m_paused && i < missedCuesSize; ++i) {
         if (missedCues[i].data()->pauseOnExit())
             pause();
     }
 
     // 8 - Let events be a list of tasks, initially empty. Each task in this
     // list will be associated with a text track, a text track cue, and a time,
     // which are used to sort the list before the tasks are queued.
-    WillBeHeapVector<std::pair<double, RawPtrWillBeMember<TextTrackCue> > > eventTasks;
+    WillBeHeapVector<std::pair<double, RawPtrWillBeMember<TextTrackCue>>> eventTasks;
 
     // 8 - Let affected tracks be a list of text tracks, initially empty.
-    WillBeHeapVector<RawPtrWillBeMember<TextTrack> > affectedTracks;
+    WillBeHeapVector<RawPtrWillBeMember<TextTrack>> affectedTracks;
 
     for (size_t i = 0; i < missedCuesSize; ++i) {
         // 9 - For each text track cue in missed cues, prepare an event named enter
         // for the TextTrackCue object with the text track cue start time.
         eventTasks.append(std::make_pair(missedCues[i].data()->startTime(),
                                          missedCues[i].data()));
 
         // 10 - For each text track [...] in missed cues, prepare an event
         // named exit for the TextTrackCue object with the  with the later of
         // the text track cue end time and the text track cue start time.
@@ skipping 1514 matching lines @@
     return textTrackLanguageSelectionScore(track);
 }
 
 void HTMLMediaElement::configureTextTrackGroup(const TrackGroup& group)
 {
     ASSERT(group.tracks.size());
 
     WTF_LOG(Media, "HTMLMediaElement::configureTextTrackGroup(%p, %d)", this, group.kind);
 
     // First, find the track in the group that should be enabled (if any).
-    WillBeHeapVector<RefPtrWillBeMember<TextTrack> > currentlyEnabledTracks;
+    WillBeHeapVector<RefPtrWillBeMember<TextTrack>> currentlyEnabledTracks;
     RefPtrWillBeRawPtr<TextTrack> trackToEnable = nullptr;
     RefPtrWillBeRawPtr<TextTrack> defaultTrack = nullptr;
     RefPtrWillBeRawPtr<TextTrack> fallbackTrack = nullptr;
     int highestTrackScore = 0;
     for (size_t i = 0; i < group.tracks.size(); ++i) {
         RefPtrWillBeRawPtr<TextTrack> textTrack = group.tracks[i];
 
         if (m_processingPreferenceChange && textTrack->mode() == TextTrack::showingKeyword())
             currentlyEnabledTracks.append(textTrack);
 
@@ skipping 975 matching lines @@
         if (kind == TextTrack::subtitlesKeyword() || kind == TextTrack::captionsKeyword())
             textTrack->setHasBeenConfigured(false);
     }
 }
 
 void* HTMLMediaElement::preDispatchEventHandler(Event* event)
 {
     if (event && event->type() == EventTypeNames::webkitfullscreenchange)
         configureMediaControls();
 
-    return 0;
+    return nullptr;
 }
 
 void HTMLMediaElement::createMediaPlayer()
 {
     AudioSourceProviderClientLockScope scope(*this);
 
     closeMediaSource();
 
     m_player = MediaPlayer::create(this);
 
@@ skipping 17 matching lines @@
     AudioSourceProviderClientLockScope scope(*this);
     if (audioSourceProvider())
         audioSourceProvider()->setClient(m_audioSourceNode);
 }
 
 AudioSourceProvider* HTMLMediaElement::audioSourceProvider()
 {
     if (m_player)
         return m_player->audioSourceProvider();
 
-    return 0;
+    return nullptr;
 }
 #endif
 
 const AtomicString& HTMLMediaElement::mediaGroup() const
 {
     return fastGetAttribute(mediagroupAttr);
 }
 
 void HTMLMediaElement::setMediaGroup(const AtomicString& group)
 {
     // When a media element is created with a mediagroup attribute, and when a media element's mediagroup
     // attribute is set, changed, or removed, the user agent must run the following steps:
     // 1. Let _R [this] be the media element in question.
     // 2. Let m have no current media controller, if it currently has one.
     setControllerInternal(nullptr);
 
     // 3. If m's mediagroup attribute is being removed, then abort these steps.
     if (group.isNull() || group.isEmpty())
         return;
 
     // 4. If there is another media element whose Document is the same as m's Document (even if one or both
     // of these elements are not actually in the Document),
     WeakMediaElementSet elements = documentToElementSetMap().get(&document());
-    for (WeakMediaElementSet::iterator i = elements.begin(); i != elements.end(); ++i) {
-        if (*i == this)
+    for (const auto& element : elements) {
+        if (element == this)
             continue;
 
         // and which also has a mediagroup attribute, and whose mediagroup attribute has the same value as
         // the new value of m's mediagroup attribute,
-        if ((*i)->mediaGroup() == group) {
+        if (element->mediaGroup() == group) {
             //  then let controller be that media element's current media controller.
-            setControllerInternal((*i)->controller());
+            setControllerInternal(element->controller());
             return;
         }
     }
 
     // Otherwise, let controller be a newly created MediaController.
     setControllerInternal(MediaController::create(Node::executionContext()));
 }
 
 MediaController* HTMLMediaElement::controller() const
 {
@@ skipping 153 matching lines @@
 
     // Select the first video track if a video track hasn't been selected yet.
     if (videoTracks().length() > 0 && videoTracks().selectedIndex() == -1)
         videoTracks().anonymousIndexedGetter(0)->setSelected(true);
 }
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!visitor->isAlive(m_audioSourceNode) && audioSourceProvider())
-        audioSourceProvider()->setClient(0);
+        audioSourceProvider()->setClient(nullptr);
 }
 #endif
 
 }