Oilpan: have MediaController weakly refer to its media elements.

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 WebCore;
 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)
     , m_volume(1)
     , m_position(MediaPlayer::invalidTime())
@@ skipping 12 matching lines @@
 
 MediaController::~MediaController()
 {
 }
 
 void MediaController::addMediaElement(HTMLMediaElement* element)
 {
     ASSERT(element);
     ASSERT(!m_mediaElements.contains(element));
 
-    m_mediaElements.append(element);
+    m_mediaElements.add(element);
     bringElementUpToSpeed(element);
 }
 
 void MediaController::removeMediaElement(HTMLMediaElement* element)
 {
     ASSERT(element);
     ASSERT(m_mediaElements.contains(element));
     m_mediaElements.remove(m_mediaElements.find(element));
 }
 
 PassRefPtr<TimeRanges> MediaController::buffered() const
 {
     if (m_mediaElements.isEmpty())
         return TimeRanges::create();
 
     // The buffered attribute must return a new static normalized TimeRanges object that represents
     // the intersection of the ranges of the media resources of the slaved media elements that the
     // user agent has buffered, at the time the attribute is evaluated.
-    RefPtr<TimeRanges> bufferedRanges = m_mediaElements.first()->buffered();
-    for (size_t index = 1; index < m_mediaElements.size(); ++index)
-        bufferedRanges->intersectWith(m_mediaElements[index]->buffered().get());
+    MediaElementSequence::const_iterator it = m_mediaElements.begin();
+    RefPtr<TimeRanges> bufferedRanges = (*it)->buffered();
+    for (++it; it != m_mediaElements.end(); ++it)
+        bufferedRanges->intersectWith((*it)->buffered().get());
     return bufferedRanges;
 }
 
 PassRefPtr<TimeRanges> MediaController::seekable() const
 {
     if (m_mediaElements.isEmpty())
         return TimeRanges::create();
 
     // The seekable attribute must return a new static normalized TimeRanges object that represents
     // the intersection of the ranges of the media resources of the slaved media elements that the
     // user agent is able to seek to, at the time the attribute is evaluated.
-    RefPtr<TimeRanges> seekableRanges = m_mediaElements.first()->seekable();
-    for (size_t index = 1; index < m_mediaElements.size(); ++index)
-        seekableRanges->intersectWith(m_mediaElements[index]->seekable().get());
+    MediaElementSequence::const_iterator it = m_mediaElements.begin();
+    RefPtr<TimeRanges> seekableRanges = (*it)->seekable();
+    for (++it; it != m_mediaElements.end(); ++it)
+        seekableRanges->intersectWith((*it)->seekable().get());
     return seekableRanges;
 }
 
 PassRefPtr<TimeRanges> MediaController::played()
 {
     if (m_mediaElements.isEmpty())
         return TimeRanges::create();
 
     // The played attribute must return a new static normalized TimeRanges object that represents
     // the union of the ranges of the media resources of the slaved media elements that the
     // user agent has so far rendered, at the time the attribute is evaluated.
-    RefPtr<TimeRanges> playedRanges = m_mediaElements.first()->played();
-    for (size_t index = 1; index < m_mediaElements.size(); ++index)
-        playedRanges->unionWith(m_mediaElements[index]->played().get());
+    MediaElementSequence::const_iterator it = m_mediaElements.begin();
+    RefPtr<TimeRanges> playedRanges = (*it)->played();
+    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 (size_t index = 0; index < m_mediaElements.size(); ++index) {
-        double duration = m_mediaElements[index]->duration();
+    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);
     }
     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 = 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 (size_t index = 0; index < m_mediaElements.size(); ++index)
-        m_mediaElements[index]->seek(time, exceptionState);
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
+        (*it)->seek(time, exceptionState);
 
     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 (size_t index = 0; index < m_mediaElements.size(); ++index)
-        m_mediaElements[index]->play();
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
+        (*it)->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 (size_t index = 0; index < m_mediaElements.size(); ++index)
-        m_mediaElements[index]->updatePlaybackRate();
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
+        (*it)->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 (size_t index = 0; index < m_mediaElements.size(); ++index)
-        m_mediaElements[index]->updateVolume();
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
+        (*it)->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 (size_t index = 0; index < m_mediaElements.size(); ++index)
-        m_mediaElements[index]->updateVolume();
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
+        (*it)->updateVolume();
 }
 
 static const AtomicString& playbackStateWaiting()
 {
     DEFINE_STATIC_LOCAL(AtomicString, waiting, ("waiting", AtomicString::ConstructFromLiteral));
     return waiting;
 }
 
 static const AtomicString& playbackStatePlaying()
 {
@@ skipping 51 matching lines @@
 {
     ReadyState oldReadyState = m_readyState;
     ReadyState newReadyState;
 
     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.
-        newReadyState = m_mediaElements.first()->readyState();
-        for (size_t index = 1; index < m_mediaElements.size(); ++index)
-            newReadyState = min(newReadyState, m_mediaElements[index]->readyState());
+        MediaElementSequence::const_iterator it = m_mediaElements.begin();
+        newReadyState = (*it)->readyState();
+        for (++it; it != m_mediaElements.end(); ++it)
+            newReadyState = 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 87 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 (size_t index = 0; index < m_mediaElements.size(); ++index)
-        m_mediaElements[index]->updatePlayState();
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it)
+        (*it)->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(), IGNORE_EXCEPTION);
 }
 
 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 (size_t index = 0; index < m_mediaElements.size(); ++index) {
-        HTMLMediaElement* element = m_mediaElements[index];
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
+        HTMLMediaElement* element = *it;
 
         // and none of its slaved media elements are blocked media elements,
         if (element->isBlocked())
             return false;
 
         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 (size_t index = 0; index < m_mediaElements.size(); ++index) {
-        HTMLMediaElement* element = m_mediaElements[index];
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
+        HTMLMediaElement* element = *it;
 
         // 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;
 
@@ skipping 10 matching lines @@
     // 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 (size_t index = 0; index < m_mediaElements.size(); ++index) {
-        if (!m_mediaElements[index]->ended())
+    for (MediaElementSequence::const_iterator it = m_mediaElements.begin(); it != m_mediaElements.end(); ++it) {
+        if (!(*it)->ended())
             allHaveEnded = false;
     }
     return allHaveEnded;
 }
 
 void MediaController::scheduleEvent(const AtomicString& eventName)
 {
     m_pendingEventsQueue->enqueueEvent(Event::createCancelable(eventName));
 }
 
@@ skipping 28 matching lines @@
 {
     double now = WTF::currentTime();
     double timedelta = now - m_previousTimeupdateTime;
 
     if (timedelta < maxTimeupdateEventFrequency)
         return;
 
     scheduleEvent(EventTypeNames::timeupdate);
     m_previousTimeupdateTime = now;
 }
+
+void MediaController::trace(Visitor* visitor)
+{
+    visitor->trace(m_mediaElements);
+    EventTargetWithInlineData::trace(visitor);
+}
+
+}