Repaint video controls when buffering during pause.

Source/WebCore/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #if ENABLE(VIDEO)
 #include "HTMLMediaElement.h"
 
 #include "ApplicationCacheHost.h"
 #include "ApplicationCacheResource.h"
 #include "Attribute.h"
@@ skipping 79 matching lines @@
     return url.string().substring(0, maximumURLLengthForLogging) + "...";
 }
 
 static const char* boolString(bool val)
 {
     return val ? "true" : "false";
 }
 #endif
 
 #ifndef LOG_MEDIA_EVENTS
-// Default to not logging events because so many are generated they can overwhelm the rest of 
+// Default to not logging events because so many are generated they can overwhelm the rest of
 // the logging.
 #define LOG_MEDIA_EVENTS 0
 #endif
 
 #ifndef LOG_CACHED_TIME_WARNINGS
 // 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
 
@@ skipping 54 matching lines @@
     , m_loadState(WaitingForSource)
     , m_currentSourceNode(0)
     , m_nextChildNodeToConsider(0)
 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
     , m_proxyWidget(0)
 #endif
     , m_restrictions(RequireUserGestureForFullscreenRestriction | RequirePageConsentToLoadMediaRestriction)
     , m_preload(MediaPlayer::Auto)
     , m_displayMode(Unknown)
     , m_processingMediaPlayerCallback(0)
-#if ENABLE(MEDIA_SOURCE)      
+#if ENABLE(MEDIA_SOURCE)
     , m_sourceState(SOURCE_CLOSED)
 #endif
     , m_cachedTime(invalidMediaTime)
     , m_cachedTimeWallClockUpdateTime(0)
     , m_minimumWallClockTimeToCacheMediaTime(0)
     , m_pendingLoadFlags(0)
     , m_playing(false)
     , m_isWaitingUntilMediaCanStart(false)
     , m_shouldDelayLoadEvent(false)
     , m_haveFiredLoadedData(false)
@@ skipping 19 matching lines @@
     , m_audioSourceNode(0)
 #endif
 #if ENABLE(VIDEO_TRACK)
     , m_textTracks(0)
 #endif
 {
     LOG(Media, "HTMLMediaElement::HTMLMediaElement");
     document->registerForDocumentActivationCallbacks(this);
     document->registerForMediaVolumeCallbacks(this);
     document->registerForPrivateBrowsingStateChangedCallbacks(this);
-    
+
     if (document->settings() && document->settings()->mediaPlaybackRequiresUserGesture())
         addBehaviorRestriction(RequireUserGestureForRateChangeRestriction);
 
 #if ENABLE(MEDIA_SOURCE)
     m_mediaSourceURL.setProtocol(mediaSourceURLProtocol);
     m_mediaSourceURL.setPath(createCanonicalUUIDString());
 #endif
 
     setHasCustomWillOrDidRecalcStyle();
     addElementToDocumentMap(this, document);
@@ skipping 168 matching lines @@
         mediaRenderer->setWidget(m_proxyWidget);
 
         if (Frame* frame = document()->frame())
             frame->loader()->client()->showMediaPlayerProxyPlugin(m_proxyWidget.get());
     }
     return mediaRenderer;
 #else
     return new (arena) RenderMedia(this);
 #endif
 }
- 
+
 void HTMLMediaElement::insertedIntoDocument()
 {
     LOG(Media, "HTMLMediaElement::insertedIntoDocument");
     HTMLElement::insertedIntoDocument();
     if (!getAttribute(srcAttr).isEmpty() && m_networkState == NETWORK_EMPTY)
         scheduleLoad(MediaResource);
 }
 
 void HTMLMediaElement::removedFromDocument()
 {
@@ skipping 32 matching lines @@
 }
 
 void HTMLMediaElement::scheduleLoad(LoadType loadType)
 {
     LOG(Media, "HTMLMediaElement::scheduleLoad");
 
     if ((loadType & MediaResource) && !(m_pendingLoadFlags & MediaResource)) {
 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
         createMediaPlayerProxy();
 #endif
-        
+
         prepareForLoad();
         m_pendingLoadFlags |= MediaResource;
     }
 
 #if ENABLE(VIDEO_TRACK)
     if (loadType & TextTrackResource)
         m_pendingLoadFlags |= TextTrackResource;
 #endif
 
     if (!m_loadTimer.isActive())
@@ skipping 47 matching lines @@
     }
 
 #if ENABLE(VIDEO_TRACK)
     if (m_pendingLoadFlags & TextTrackResource)
         scheduleLoad(TextTrackResource);
 #endif
 
     m_pendingLoadFlags = 0;
 }
 
-PassRefPtr<MediaError> HTMLMediaElement::error() const 
+PassRefPtr<MediaError> HTMLMediaElement::error() const
 {
     return m_error;
 }
 
 void HTMLMediaElement::setSrc(const String& url)
 {
     setAttribute(srcAttr, url);
 }
 
 HTMLMediaElement::NetworkState HTMLMediaElement::networkState() const
@@ skipping 12 matching lines @@
         case MediaPlayer::IsNotSupported:
             canPlay = "";
             break;
         case MediaPlayer::MayBeSupported:
             canPlay = "maybe";
             break;
         case MediaPlayer::IsSupported:
             canPlay = "probably";
             break;
     }
-    
+
     LOG(Media, "HTMLMediaElement::canPlayType(%s) -> %s", mimeType.utf8().data(), canPlay.utf8().data());
 
     return canPlay;
 }
 
 void HTMLMediaElement::load(ExceptionCode& ec)
 {
     LOG(Media, "HTMLMediaElement::load()");
 
     if (userGestureRequiredForLoad() && !ScriptController::processingUserGesture())
@@ skipping 17 matching lines @@
     m_sentStalledEvent = false;
     m_haveFiredLoadedData = false;
     m_completelyLoaded = false;
     m_havePreparedToPlay = false;
     m_displayMode = Unknown;
 
     // 1 - Abort any already-running instance of the resource selection algorithm for this element.
     m_loadState = WaitingForSource;
     m_currentSourceNode = 0;
 
-    // 2 - If there are any tasks from the media element's media element event task source in 
+    // 2 - If there are any tasks from the media element's media element event task source in
     // one of the task queues, then remove those tasks.
     cancelPendingEventsAndCallbacks();
 
     // 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue
     // a task to fire a simple event named abort at the media element.
     if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)
         scheduleEvent(eventNames().abortEvent);
 
 #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)
     createMediaPlayer();
@@ skipping 37 matching lines @@
     // 1 - Set the networkState to NETWORK_NO_SOURCE
     m_networkState = NETWORK_NO_SOURCE;
 
     // 2 - Asynchronously await a stable state.
 
     m_playedTimeRanges = TimeRanges::create();
     m_lastSeekTime = 0;
     m_closedCaptionsVisible = false;
 
     // The spec doesn't say to block the load event until we actually run the asynchronous section
-    // algorithm, but do it now because we won't start that until after the timer fires and the 
+    // algorithm, but do it now because we won't start that until after the timer fires and the
     // event may have already fired by then.
     setShouldDelayLoadEvent(true);
 
     configureMediaControls();
 }
 
 void HTMLMediaElement::loadInternal()
 {
     // If we can't start a load right away, start it later.
     Page* page = document()->page();
     if (pageConsentRequiredForLoad() && page && !page->canStartMedia()) {
         if (m_isWaitingUntilMediaCanStart)
             return;
         document()->addMediaCanStartListener(this);
         m_isWaitingUntilMediaCanStart = true;
         return;
     }
-    
-    // Once the page has allowed an element to load media, it is free to load at will. This allows a 
-    // playlist that starts in a foreground tab to continue automatically if the tab is subsequently 
+
+    // Once the page has allowed an element to load media, it is free to load at will. This allows a
+    // playlist that starts in a foreground tab to continue automatically if the tab is subsequently
     // put in the the background.
     removeBehaviorRestriction(RequirePageConsentToLoadMediaRestriction);
 
     selectMediaResource();
 }
 
 void HTMLMediaElement::selectMediaResource()
 {
     LOG(Media, "HTMLMediaElement::selectMediaResource");
 
     enum Mode { attribute, children };
 
     // 3 - If the media element has a src attribute, then let mode be attribute.
     Mode mode = attribute;
     if (!fastHasAttribute(srcAttr)) {
         Node* node;
         for (node = firstChild(); node; node = node->nextSibling()) {
             if (node->hasTagName(sourceTag))
                 break;
         }
 
-        // Otherwise, if the media element does not have a src attribute but has a source 
-        // element child, then let mode be children and let candidate be the first such 
+        // Otherwise, if the media element does not have a src attribute but has a source
+        // element child, then let mode be children and let candidate be the first such
         // source element child in tree order.
         if (node) {
             mode = children;
             m_nextChildNodeToConsider = 0;
             m_currentSourceNode = 0;
         } else {
-            // Otherwise the media element has neither a src attribute nor a source element 
-            // child: set the networkState to NETWORK_EMPTY, and abort these steps; the 
+            // Otherwise the media element has neither a src attribute nor a source element
+            // child: set the networkState to NETWORK_EMPTY, and abort these steps; the
             // synchronous section ends.
             m_loadState = WaitingForSource;
             setShouldDelayLoadEvent(false);
             m_networkState = NETWORK_EMPTY;
 
             LOG(Media, "HTMLMediaElement::selectMediaResource, nothing to load");
             return;
         }
     }
 
-    // 4 - Set the media element's delaying-the-load-event flag to true (this delays the load event), 
+    // 4 - Set the media element's delaying-the-load-event flag to true (this delays the load event),
     // and set its networkState to NETWORK_LOADING.
     setShouldDelayLoadEvent(true);
     m_networkState = NETWORK_LOADING;
 
     // 5 - Queue a task to fire a simple event named loadstart at the media element.
     scheduleEvent(eventNames().loadstartEvent);
 
     // 6 - If mode is attribute, then run these substeps
     if (mode == attribute) {
         m_loadState = LoadingFromSrcAttr;
@@ skipping 73 matching lines @@
     if (!frame) {
         mediaLoadingFailed(MediaPlayer::FormatError);
         return;
     }
 
     KURL url = initialURL;
     if (!frame->loader()->willLoadMediaElementURL(url)) {
         mediaLoadingFailed(MediaPlayer::FormatError);
         return;
     }
-    
+
 #if ENABLE(MEDIA_SOURCE)
     // If this is a media source URL, make sure it is the one for this media element.
     if (url.protocolIs(mediaSourceURLProtocol) && url != m_mediaSourceURL) {
         mediaLoadingFailed(MediaPlayer::FormatError);
         return;
     }
 #endif
 
-    // The resource fetch algorithm 
+    // The resource fetch algorithm
     m_networkState = NETWORK_LOADING;
 
 #if !PLATFORM(CHROMIUM)
     // If the url should be loaded from the application cache, pass the url of the cached file
     // to the media engine.
     ApplicationCacheHost* cacheHost = frame->loader()->documentLoader()->applicationCacheHost();
     ApplicationCacheResource* resource = 0;
     if (cacheHost && cacheHost->shouldLoadResourceFromApplicationCache(ResourceRequest(url), resource)) {
         // Resources that are not present in the manifest will always fail to load (at least, after the
         // cache has been primed the first time), making the testing of offline applications simpler.
@@ skipping 10 matching lines @@
 
 #if !PLATFORM(CHROMIUM)
     if (resource) {
         url = createFileURLForApplicationCacheResource(resource->path());
         LOG(Media, "HTMLMediaElement::loadResource - will load from app cache -> %s", urlForLogging(url).utf8().data());
     }
 #endif
 
     LOG(Media, "HTMLMediaElement::loadResource - m_currentSrc -> %s", urlForLogging(m_currentSrc).utf8().data());
 
-    if (m_sendProgressEvents) 
+    if (m_sendProgressEvents)
         startProgressEventTimer();
 
     Settings* settings = document()->settings();
     bool privateMode = !settings || settings->privateBrowsingEnabled();
     m_player->setPrivateBrowsingMode(privateMode);
 
     // Reset display mode to force a recalculation of what to show because we are resetting the player.
     setDisplayMode(Unknown);
 
     if (!autoplay())
@@ skipping 14 matching lines @@
     if (renderer())
         renderer()->updateFromElement();
 }
 
 #if ENABLE(VIDEO_TRACK)
 void HTMLMediaElement::updateActiveTextTrackCues(float movieTime)
 {
     Vector<CueIntervalTree::IntervalType> previouslyVisibleCues = m_currentlyVisibleCues;
 
     m_currentlyVisibleCues = m_cueTree.allOverlaps(m_cueTree.createInterval(movieTime, movieTime));
-    
+
     // FIXME(72171): Events need to be sorted and filtered before dispatching.
 
     for (size_t i = 0; i < previouslyVisibleCues.size(); ++i) {
         if (!m_currentlyVisibleCues.contains(previouslyVisibleCues[i]))
             previouslyVisibleCues[i].data()->setIsActive(false);
     }
     for (size_t i = 0; i < m_currentlyVisibleCues.size(); ++i) {
         if (!previouslyVisibleCues.contains(m_currentlyVisibleCues[i]))
             m_currentlyVisibleCues[i].data()->setIsActive(true);
     }
-    
+
     // FIXME(72173): Pause the media element for cues going past their endTime
     // during a monotonic time increase.
 }
 
 void HTMLMediaElement::textTrackReadyStateChanged(TextTrack*)
 {
     // FIXME(62885): Implement.
 }
 
 void HTMLMediaElement::textTrackModeChanged(TextTrack*)
 {
     // FIXME(62885): Implement.
 }
 
 void HTMLMediaElement::textTrackKindChanged(TextTrack*)
 {
     // FIXME(62885): Implement.
 }
 
-void HTMLMediaElement::textTrackAddCues(TextTrack*, const TextTrackCueList* cues) 
+void HTMLMediaElement::textTrackAddCues(TextTrack*, const TextTrackCueList* cues)
 {
     for (size_t i = 0; i < cues->length(); ++i)
         textTrackAddCue(cues->item(i)->track(), cues->item(i));
 }
 
-void HTMLMediaElement::textTrackRemoveCues(TextTrack*, const TextTrackCueList* cues) 
+void HTMLMediaElement::textTrackRemoveCues(TextTrack*, const TextTrackCueList* cues)
 {
     for (size_t i = 0; i < cues->length(); ++i)
         textTrackRemoveCue(cues->item(i)->track(), cues->item(i));
 }
 
 void HTMLMediaElement::textTrackAddCue(TextTrack*, PassRefPtr<TextTrackCue> cue)
 {
     m_cueTree.add(m_cueTree.createInterval(cue->startTime(), cue->endTime(), cue.get()));
 }
 
@@ skipping 58 matching lines @@
 }
 
 void HTMLMediaElement::noneSupported()
 {
     LOG(Media, "HTMLMediaElement::noneSupported");
 
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
     m_currentSourceNode = 0;
 
-    // 4.8.10.5 
-    // 6 - Reaching this step indicates that the media resource failed to load or that the given 
+    // 4.8.10.5
+    // 6 - Reaching this step indicates that the media resource failed to load or that the given
     // URL could not be resolved. In one atomic operation, run the following steps:
 
     // 6.1 - Set the error attribute to a new MediaError object whose code attribute is set to
     // MEDIA_ERR_SRC_NOT_SUPPORTED.
     m_error = MediaError::create(MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED);
 
     // 6.2 - Forget the media element's media-resource-specific text tracks.
 
     // 6.3 - Set the element's networkState attribute to the NETWORK_NO_SOURCE value.
     m_networkState = NETWORK_NO_SOURCE;
 
     // 7 - Queue a task to fire a simple event named error at the media element.
     scheduleEvent(eventNames().errorEvent);
 
     // 8 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
-    // 9 - Abort these steps. Until the load() method is invoked or the src attribute is changed, 
+    // 9 - Abort these steps. Until the load() method is invoked or the src attribute is changed,
     // the element won't attempt to load another resource.
 
     updateDisplayState();
 
     if (renderer())
         renderer()->updateFromElement();
 }
 
 void HTMLMediaElement::mediaEngineError(PassRefPtr<MediaError> err)
 {
     LOG(Media, "HTMLMediaElement::mediaEngineError(%d)", static_cast<int>(err->code()));
 
     // 1 - The user agent should cancel the fetching process.
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
 
-    // 2 - Set the error attribute to a new MediaError object whose code attribute is 
+    // 2 - Set the error attribute to a new MediaError object whose code attribute is
     // set to MEDIA_ERR_NETWORK/MEDIA_ERR_DECODE.
     m_error = err;
 
     // 3 - Queue a task to fire a simple event named error at the media element.
     scheduleEvent(eventNames().errorEvent);
 
 #if ENABLE(MEDIA_SOURCE)
     if (m_sourceState != SOURCE_CLOSED)
         setSourceState(SOURCE_CLOSED);
 #endif
@@ skipping 18 matching lines @@
 
     for (Node* node = firstChild(); node; node = node->nextSibling()) {
         if (node->hasTagName(sourceTag))
             static_cast<HTMLSourceElement*>(node)->cancelPendingErrorEvent();
     }
 }
 
 Document* HTMLMediaElement::mediaPlayerOwningDocument()
 {
     Document* d = document();
-    
+
     if (!d)
         d = ownerDocument();
-    
+
     return d;
 }
 
 void HTMLMediaElement::mediaPlayerNetworkStateChanged(MediaPlayer*)
 {
     beginProcessingMediaPlayerCallback();
     setNetworkState(m_player->networkState());
     endProcessingMediaPlayerCallback();
 }
 
 void HTMLMediaElement::mediaLoadingFailed(MediaPlayer::NetworkState error)
 {
     stopPeriodicTimers();
-    
+
     // If we failed while trying to load a <source> element, the movie was never parsed, and there are more
     // <source> children, schedule the next one
     if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {
-        
+
         if (m_currentSourceNode)
             m_currentSourceNode->scheduleErrorEvent();
         else
             LOG(Media, "HTMLMediaElement::setNetworkState - error event not sent, <source> was removed");
-        
+
         if (havePotentialSourceChild()) {
             LOG(Media, "HTMLMediaElement::setNetworkState - scheduling next <source>");
             scheduleNextSourceChild();
         } else {
             LOG(Media, "HTMLMediaElement::setNetworkState - no more <source> elements, waiting");
             waitForSourceChange();
         }
-        
+
         return;
     }
-    
+
     if (error == MediaPlayer::NetworkError && m_readyState >= HAVE_METADATA)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));
     else if (error == MediaPlayer::DecodeError)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_DECODE));
     else if ((error == MediaPlayer::FormatError || error == MediaPlayer::NetworkError) && m_loadState == LoadingFromSrcAttr)
         noneSupported();
-    
+
     updateDisplayState();
     if (hasMediaControls()) {
         mediaControls()->reset();
         mediaControls()->reportedError();
     }
 }
 
 void HTMLMediaElement::setNetworkState(MediaPlayer::NetworkState state)
 {
     LOG(Media, "HTMLMediaElement::setNetworkState(%d) - current state is %d", static_cast<int>(state), static_cast<int>(m_networkState));
 
     if (state == MediaPlayer::Empty) {
         // Just update the cached state and leave, we can't do anything.
         m_networkState = NETWORK_EMPTY;
         return;
     }
 
     if (state == MediaPlayer::FormatError || state == MediaPlayer::NetworkError || state == MediaPlayer::DecodeError) {
         mediaLoadingFailed(state);
         return;
     }
 
     if (state == MediaPlayer::Idle) {
         if (m_networkState > NETWORK_IDLE) {
             m_progressEventTimer.stop();
+            if (hasMediaControls() && m_player->bytesLoaded() != m_previousProgress)
+                mediaControls()->bufferingProgressed();
+
             scheduleEvent(eventNames().suspendEvent);
             setShouldDelayLoadEvent(false);
         }
         m_networkState = NETWORK_IDLE;
     }
 
     if (state == MediaPlayer::Loading) {
         if (m_networkState < NETWORK_LOADING || m_networkState == NETWORK_NO_SOURCE)
             startProgressEventTimer();
         m_networkState = NETWORK_LOADING;
     }
 
     if (state == MediaPlayer::Loaded) {
         if (m_networkState != NETWORK_IDLE) {
             m_progressEventTimer.stop();
+            if (hasMediaControls() && m_player->bytesLoaded() != m_previousProgress)
+                mediaControls()->bufferingProgressed();
 
             // Schedule one last progress event so we guarantee that at least one is fired
             // for files that load very quickly.
             scheduleEvent(eventNames().progressEvent);
         }
         m_networkState = NETWORK_IDLE;
         m_completelyLoaded = true;
     }
 
     if (hasMediaControls())
@@ skipping 14 matching lines @@
     LOG(Media, "HTMLMediaElement::setReadyState(%d) - current state is %d,", static_cast<int>(state), static_cast<int>(m_readyState));
 
     // Set "wasPotentiallyPlaying" BEFORE updating m_readyState, potentiallyPlaying() uses it
     bool wasPotentiallyPlaying = potentiallyPlaying();
 
     ReadyState oldState = m_readyState;
     m_readyState = static_cast<ReadyState>(state);
 
     if (m_readyState == oldState)
         return;
-    
+
     if (oldState > m_readyStateMaximum)
         m_readyStateMaximum = oldState;
 
     if (m_networkState == NETWORK_EMPTY)
         return;
 
     if (m_seeking) {
         // 4.8.10.9, step 11
         if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA)
             scheduleEvent(eventNames().waitingEvent);
@@ skipping 96 matching lines @@
             m_sentStalledEvent = true;
             setShouldDelayLoadEvent(false);
         }
     } else {
         scheduleEvent(eventNames().progressEvent);
         m_previousProgress = progress;
         m_previousProgressTime = time;
         m_sentStalledEvent = false;
         if (renderer())
             renderer()->updateFromElement();
+        if (hasMediaControls())
+            mediaControls()->bufferingProgressed();
     }
 }
 
 void HTMLMediaElement::rewind(float timeDelta)
 {
     LOG(Media, "HTMLMediaElement::rewind(%f)", timeDelta);
 
     ExceptionCode e;
     setCurrentTime(max(currentTime() - timeDelta, minTimeSeekable()), e);
 }
 
 void HTMLMediaElement::returnToRealtime()
 {
     LOG(Media, "HTMLMediaElement::returnToRealtime");
     ExceptionCode e;
     setCurrentTime(maxTimeSeekable(), e);
-}  
+}
 
 void HTMLMediaElement::addPlayedRange(float start, float end)
 {
     LOG(Media, "HTMLMediaElement::addPlayedRange(%f, %f)", start, end);
     if (!m_playedTimeRanges)
         m_playedTimeRanges = TimeRanges::create();
     m_playedTimeRanges->add(start, end);
-}  
+}
 
 bool HTMLMediaElement::supportsSave() const
 {
     return m_player ? m_player->supportsSave() : false;
 }
 
 bool HTMLMediaElement::supportsScanning() const
 {
     return m_player ? m_player->supportsScanning() : false;
 }
@@ skipping 29 matching lines @@
 
     // 2 - If the element's seeking IDL attribute is true, then another instance of this algorithm is
     // already running. Abort that other instance of the algorithm without waiting for the step that
     // it is running to complete.
     // Nothing specific to be done here.
 
     // 3 - Set the seeking IDL attribute to true.
     // The flag will be cleared when the engine tells us the time has actually changed.
     m_seeking = true;
 
-    // 5 - If the new playback position is later than the end of the media resource, then let it be the end 
+    // 5 - If the new playback position is later than the end of the media resource, then let it be the end
     // of the media resource instead.
     time = min(time, duration());
 
     // 6 - If the new playback position is less than the earliest possible position, let it be that position instead.
     float earliestTime = m_player->startTime();
     time = max(time, earliestTime);
 
     // Ask the media engine for the time value in the movie's time scale before comparing with current time. This
     // is necessary because if the seek time is not equal to currentTime but the delta is less than the movie's
     // time scale, we will ask the media engine to "seek" to the current movie time, which may be a noop and
-    // not generate a timechanged callback. This means m_seeking will never be cleared and we will never 
+    // not generate a timechanged callback. This means m_seeking will never be cleared and we will never
     // fire a 'seeked' event.
 #if !LOG_DISABLED
     float mediaTime = m_player->mediaTimeForTimeValue(time);
     if (time != mediaTime)
         LOG(Media, "HTMLMediaElement::seek(%f) - media timeline equivalent is %f", time, mediaTime);
 #endif
     time = m_player->mediaTimeForTimeValue(time);
 
-    // 7 - If the (possibly now changed) new playback position is not in one of the ranges given in the 
-    // seekable attribute, then let it be the position in one of the ranges given in the seekable attribute 
+    // 7 - If the (possibly now changed) new playback position is not in one of the ranges given in the
+    // seekable attribute, then let it be the position in one of the ranges given in the seekable attribute
     // that is the nearest to the new playback position. ... If there are no ranges given in the seekable
     // attribute then set the seeking IDL attribute to false and abort these steps.
     RefPtr<TimeRanges> seekableRanges = seekable();
 
     // Short circuit seeking to the current time by just firing the events if no seek is required.
-    // Don't skip calling the media engine if we are in poster mode because a seek should always 
+    // Don't skip calling the media engine if we are in poster mode because a seek should always
     // cancel poster display.
     bool noSeekRequired = !seekableRanges->length() || (time == now && displayMode() != Poster);
 
 #if ENABLE(MEDIA_SOURCE)
     // Always notify the media engine of a seek if the source is not closed. This ensures that the source is
     // always in a flushed state when the 'seeking' event fires.
     if (m_sourceState != SOURCE_CLOSED)
       noSeekRequired = false;
 #endif
 
@@ skipping 191 matching lines @@
 }
 
 float HTMLMediaElement::playbackRate() const
 {
     return m_playbackRate;
 }
 
 void HTMLMediaElement::setPlaybackRate(float rate)
 {
     LOG(Media, "HTMLMediaElement::setPlaybackRate(%f)", rate);
-    
+
     if (m_playbackRate != rate) {
         m_playbackRate = rate;
         invalidateCachedTime();
         scheduleEvent(eventNames().ratechangeEvent);
     }
 
     if (m_player && potentiallyPlaying() && m_player->rate() != rate && !m_mediaController)
         m_player->setRate(rate);
 }
 
 void HTMLMediaElement::updatePlaybackRate()
 {
     float effectiveRate = m_mediaController ? m_mediaController->playbackRate() : m_playbackRate;
     if (m_player && potentiallyPlaying() && m_player->rate() != effectiveRate && !m_mediaController)
         m_player->setRate(effectiveRate);
 }
 
 bool HTMLMediaElement::webkitPreservesPitch() const
 {
     return m_webkitPreservesPitch;
 }
 
 void HTMLMediaElement::setWebkitPreservesPitch(bool preservesPitch)
 {
     LOG(Media, "HTMLMediaElement::setWebkitPreservesPitch(%s)", boolString(preservesPitch));
 
     m_webkitPreservesPitch = preservesPitch;
-    
+
     if (!m_player)
         return;
 
     m_player->setPreservesPitch(preservesPitch);
 }
 
 bool HTMLMediaElement::ended() const
 {
     // 4.8.10.8 Playing the media resource
-    // The ended attribute must return true if the media element has ended 
+    // The ended attribute must return true if the media element has ended
     // playback and the direction of playback is forwards, and false otherwise.
     return endedPlayback() && m_playbackRate > 0;
 }
 
 bool HTMLMediaElement::autoplay() const
 {
     return fastHasAttribute(autoplayAttr);
 }
 
 void HTMLMediaElement::setAutoplay(bool b)
@@ skipping 91 matching lines @@
 
 void HTMLMediaElement::pauseInternal()
 {
     LOG(Media, "HTMLMediaElement::pauseInternal");
 
     // 4.8.10.9. Playing the media resource
     if (!m_player || m_networkState == NETWORK_EMPTY)
         scheduleLoad(MediaResource);
 
     m_autoplaying = false;
-    
+
     if (!m_paused) {
         m_paused = true;
         scheduleTimeupdateEvent(false);
         scheduleEvent(eventNames().pauseEvent);
     }
 
     updatePlayState();
 }
 
 #if ENABLE(MEDIA_SOURCE)
@@ skipping 110 matching lines @@
 }
 
 void HTMLMediaElement::setVolume(float vol, ExceptionCode& ec)
 {
     LOG(Media, "HTMLMediaElement::setVolume(%f)", vol);
 
     if (vol < 0.0f || vol > 1.0f) {
         ec = INDEX_SIZE_ERR;
         return;
     }
-    
+
     if (m_volume != vol) {
         m_volume = vol;
         updateVolume();
         scheduleEvent(eventNames().volumechangeEvent);
     }
 }
 
 bool HTMLMediaElement::muted() const
 {
     return m_muted;
@@ skipping 19 matching lines @@
 
 void HTMLMediaElement::togglePlayState()
 {
     LOG(Media, "HTMLMediaElement::togglePlayState - canPlay() is %s", boolString(canPlay()));
 
     // We can safely call the internal play/pause methods, which don't check restrictions, because
     // this method is only called from the built-in media controller
     if (canPlay()) {
         updatePlaybackRate();
         playInternal();
-    } else 
+    } else
         pauseInternal();
 }
 
 void HTMLMediaElement::beginScrubbing()
 {
     LOG(Media, "HTMLMediaElement::beginScrubbing - paused() is %s", boolString(paused()));
 
     if (!paused()) {
         if (ended()) {
-            // Because a media element stays in non-paused state when it reaches end, playback resumes 
-            // when the slider is dragged from the end to another position unless we pause first. Do 
+            // Because a media element stays in non-paused state when it reaches end, playback resumes
+            // when the slider is dragged from the end to another position unless we pause first. Do
             // a "hard pause" so an event is generated, since we want to stay paused after scrubbing finishes.
             pause();
         } else {
             // Not at the end but we still want to pause playback so the media engine doesn't try to
-            // continue playing during scrubbing. Pause without generating an event as we will 
+            // continue playing during scrubbing. Pause without generating an event as we will
             // unpause after scrubbing finishes.
             setPausedInternal(true);
         }
     }
 }
 
 void HTMLMediaElement::endScrubbing()
 {
     LOG(Media, "HTMLMediaElement::endScrubbing - m_pausedInternal is %s", boolString(m_pausedInternal));
 
@@ skipping 20 matching lines @@
 void HTMLMediaElement::playbackProgressTimerFired(Timer<HTMLMediaElement>*)
 {
     ASSERT(m_player);
     if (!m_playbackRate)
         return;
 
     scheduleTimeupdateEvent(true);
     if (hasMediaControls())
         mediaControls()->playbackProgressed();
     // FIXME: deal with cue ranges here
-    
+
 #if ENABLE(VIDEO_TRACK)
     updateActiveTextTrackCues(currentTime());
 #endif
 }
 
 void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent)
 {
     double now = WTF::currentTime();
     double timedelta = now - m_lastTimeUpdateEventWallTime;
 
@@ skipping 37 matching lines @@
 }
 
 #if ENABLE(VIDEO_TRACK)
 PassRefPtr<TextTrack> HTMLMediaElement::addTrack(const String& kind, const String& label, const String& language, ExceptionCode& ec)
 {
     if (!RuntimeEnabledFeatures::webkitVideoTrackEnabled())
         return 0;
 
     // 4.8.10.12.4 Text track API
     // The addTextTrack(kind, label, language) method of media elements, when invoked, must run the following steps:
-    
+
     // 1. If kind is not one of the following strings, then throw a SyntaxError exception and abort these steps
     if (!TextTrack::isValidKindKeyword(kind)) {
         ec = SYNTAX_ERR;
         return 0;
     }
 
     // 2. If the label argument was omitted, let label be the empty string.
     // 3. If the language argument was omitted, let language be the empty string.
     // 4. Create a new TextTrack object.
     RefPtr<TextTrack> textTrack = TextTrack::create(ActiveDOMObject::scriptExecutionContext(), this, kind, label, language);
 
-    // 5. Create a new text track corresponding to the new object, and set its text track kind to kind, its text 
+    // 5. Create a new text track corresponding to the new object, and set its text track kind to kind, its text
     // track label to label, its text track language to language, its text track readiness state to the text track
     // loaded state, its text track mode to the text track hidden mode, and its text track list of cues to an empty list.
-    
+
     // 6. Add the new text track to the media element's list of text tracks.
     addTextTrack(textTrack);
 
     return textTrack.release();
 }
 
 void HTMLMediaElement::addTextTrack(PassRefPtr<TextTrack> track)
 {
     textTracks()->append(track);
     configureTextTracks();
 }
 
 void HTMLMediaElement::configureTextTracks()
 {
     if (!RuntimeEnabledFeatures::webkitVideoTrackEnabled())
         return;
 
     // 4.8.10.12.3 Sourcing out-of-band text tracks
-    
+
     // When a text track corresponding to a track element is added to a media element's list of text tracks,
     // the user agent must set the text track mode appropriately, as determined by the following conditions:
-    
+
     // * If the text track kind is subtitles or captions and the user has indicated an interest in having a
     // track with this text track kind, text track language, and text track label enabled, and there is no
     // other text track in the media element's list of text tracks with a text track kind of either subtitles
     // or captions whose text track mode is showing
-    // * If the text track kind is descriptions and the user has indicated an interest in having text 
-    // descriptions with this text track language and text track label enabled, and there is no other text 
-    // track in the media element's list of text tracks with a text track kind of descriptions whose text 
+    // * If the text track kind is descriptions and the user has indicated an interest in having text
+    // descriptions with this text track language and text track label enabled, and there is no other text
+    // track in the media element's list of text tracks with a text track kind of descriptions whose text
     // track mode is showing
     //    Let the text track mode be showing.
-    //    If there is a text track in the media element's list of text tracks whose text track mode is showing 
+    //    If there is a text track in the media element's list of text tracks whose text track mode is showing
     //    by default, the user agent must furthermore change that text track's text track mode to hidden.
-    
+
     // * If the text track kind is chapters and the text track language is one that the user agent has reason
     // to believe is appropriate for the user, and there is no other text track in the media element's list of
     // text tracks with a text track kind of chapters whose text track mode is showing
     //    Let the text track mode be showing.
-    
+
     // * If the track element has a default attribute specified, and there is no other text track in the media
     // element's list of text tracks whose text track mode is showing or showing by default
     //    Let the text track mode be showing by default.
-    
+
     // Otherwise
     //    Let the text track mode be disabled.
-    
+
     // FIXME(71123): Until the above logic has been implemented, just tell all text tracks to load.
     for (Node* node = firstChild(); node; node = node->nextSibling()) {
         if (node->hasTagName(trackTag))
             static_cast<HTMLTrackElement*>(node)->scheduleLoad();
     }
 }
 
-TextTrackList* HTMLMediaElement::textTracks() 
+TextTrackList* HTMLMediaElement::textTracks()
 {
     if (!RuntimeEnabledFeatures::webkitVideoTrackEnabled())
         return 0;
 
     if (!m_textTracks)
         m_textTracks = TextTrackList::create(this, ActiveDOMObject::scriptExecutionContext());
 
     return m_textTracks.get();
 }
 
 void HTMLMediaElement::trackWasAdded(HTMLTrackElement* trackElement)
 {
     if (!RuntimeEnabledFeatures::webkitVideoTrackEnabled())
         return;
 
 #if !LOG_DISABLED
     if (trackElement->hasTagName(trackTag)) {
         KURL url = trackElement->getNonEmptyURLAttribute(srcAttr);
         LOG(Media, "HTMLMediaElement::trackWasAdded - 'src' is %s", urlForLogging(url).utf8().data());
     }
 #endif
 
     // 4.8.10.12.3 Sourcing out-of-band text tracks
-    // When a track element's parent element changes and the new parent is a media element, 
-    // then the user agent must add the track element's corresponding text track to the 
+    // When a track element's parent element changes and the new parent is a media element,
+    // then the user agent must add the track element's corresponding text track to the
     // media element's list of text tracks ... [continues in TextTrackList::append]
     RefPtr<TextTrack> textTrack = trackElement->track();
     if (!textTrack)
         return;
-    addTextTrack(textTrack);    
+    addTextTrack(textTrack);
     scheduleLoad(TextTrackResource);
 }
- 
+
 void HTMLMediaElement::trackWillBeRemoved(HTMLTrackElement* trackElement)
 {
 #if !LOG_DISABLED
     if (trackElement->hasTagName(trackTag)) {
         KURL url = trackElement->getNonEmptyURLAttribute(srcAttr);
         LOG(Media, "HTMLMediaElement::trackWillBeRemoved - 'src' is %s", urlForLogging(url).utf8().data());
     }
 #endif
 
     RefPtr<TextTrack> textTrack = trackElement->track();
     if (!textTrack)
         return;
 
     // 4.8.10.12.3 Sourcing out-of-band text tracks
-    // When a track element's parent element changes and the old parent was a media element, 
-    // then the user agent must remove the track element's corresponding text track from the 
+    // When a track element's parent element changes and the old parent was a media element,
+    // then the user agent must remove the track element's corresponding text track from the
     // media element's list of text tracks.
     m_textTracks->remove(textTrack);
 }
 #endif
 
 bool HTMLMediaElement::havePotentialSourceChild()
 {
     // Stash the current <source> node and next nodes so we can restore them after checking
     // to see there is another potential.
     HTMLSourceElement* currentSourceNode = m_currentSourceNode;
@@ skipping 27 matching lines @@
     KURL mediaURL;
     Node* node;
     HTMLSourceElement* source = 0;
     bool lookingForStartNode = m_nextChildNodeToConsider;
     bool canUse = false;
 
     for (node = firstChild(); !canUse && node; node = node->nextSibling()) {
         if (lookingForStartNode && m_nextChildNodeToConsider != node)
             continue;
         lookingForStartNode = false;
-        
+
         if (!node->hasTagName(sourceTag))
             continue;
 
         source = static_cast<HTMLSourceElement*>(node);
 
         // If candidate does not have a src attribute, or if its src attribute's value is the empty string ... jump down to the failed step below
         mediaURL = source->getNonEmptyURLAttribute(srcAttr);
 #if !LOG_DISABLED
         if (shouldLog)
             LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'src' is %s", urlForLogging(mediaURL).utf8().data());
 #endif
         if (mediaURL.isEmpty())
             goto check_again;
-        
+
         if (source->fastHasAttribute(mediaAttr)) {
             MediaQueryEvaluator screenEval("screen", document()->frame(), renderer() ? renderer()->style() : 0);
             RefPtr<MediaList> media = MediaList::createAllowingDescriptionSyntax(source->media());
 #if !LOG_DISABLED
             if (shouldLog)
                 LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'media' is %s", source->media().utf8().data());
 #endif
-            if (!screenEval.eval(media.get())) 
+            if (!screenEval.eval(media.get()))
                 goto check_again;
         }
 
         if (source->fastHasAttribute(typeAttr)) {
 #if !LOG_DISABLED
             if (shouldLog)
                 LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'type' is %s", source->type().utf8().data());
 #endif
             if (!MediaPlayer::supportsType(ContentType(source->type())))
                 goto check_again;
@@ skipping 33 matching lines @@
 void HTMLMediaElement::sourceWasAdded(HTMLSourceElement* source)
 {
     LOG(Media, "HTMLMediaElement::sourceWasAdded(%p)", source);
 
 #if !LOG_DISABLED
     if (source->hasTagName(sourceTag)) {
         KURL url = source->getNonEmptyURLAttribute(srcAttr);
         LOG(Media, "HTMLMediaElement::sourceWasAdded - 'src' is %s", urlForLogging(url).utf8().data());
     }
 #endif
-    
+
     // We should only consider a <source> element when there is not src attribute at all.
     if (fastHasAttribute(srcAttr))
         return;
 
-    // 4.8.8 - If a source element is inserted as a child of a media element that has no src 
-    // attribute and whose networkState has the value NETWORK_EMPTY, the user agent must invoke 
+    // 4.8.8 - If a source element is inserted as a child of a media element that has no src
+    // attribute and whose networkState has the value NETWORK_EMPTY, the user agent must invoke
     // the media element's resource selection algorithm.
     if (networkState() == HTMLMediaElement::NETWORK_EMPTY) {
         scheduleLoad(MediaResource);
         return;
     }
 
     if (m_currentSourceNode && source == m_currentSourceNode->nextSibling()) {
         LOG(Media, "HTMLMediaElement::sourceWasAdded - <source> inserted immediately after current source");
         m_nextChildNodeToConsider = source;
         return;
     }
 
     if (m_nextChildNodeToConsider != sourceChildEndOfListValue())
         return;
-    
+
     // 4.8.9.5, resource selection algorithm, source elements section:
     // 20 - Wait until the node after pointer is a node other than the end of the list. (This step might wait forever.)
     // 21 - Asynchronously await a stable state...
-    // 22 - Set the element's delaying-the-load-event flag back to true (this delays the load event again, in case 
+    // 22 - Set the element's delaying-the-load-event flag back to true (this delays the load event again, in case
     // it hasn't been fired yet).
     setShouldDelayLoadEvent(true);
 
     // 23 - Set the networkState back to NETWORK_LOADING.
     m_networkState = NETWORK_LOADING;
-    
+
     // 24 - Jump back to the find next candidate step above.
     m_nextChildNodeToConsider = source;
     scheduleNextSourceChild();
 }
 
 void HTMLMediaElement::sourceWillBeRemoved(HTMLSourceElement* source)
 {
     LOG(Media, "HTMLMediaElement::sourceWillBeRemoved(%p)", source);
 
 #if !LOG_DISABLED
     if (source->hasTagName(sourceTag)) {
         KURL url = source->getNonEmptyURLAttribute(srcAttr);
         LOG(Media, "HTMLMediaElement::sourceWillBeRemoved - 'src' is %s", urlForLogging(url).utf8().data());
     }
 #endif
 
     if (source != m_currentSourceNode && source != m_nextChildNodeToConsider)
         return;
 
     if (source == m_nextChildNodeToConsider) {
         m_nextChildNodeToConsider = m_nextChildNodeToConsider->nextSibling();
         if (!m_nextChildNodeToConsider)
             m_nextChildNodeToConsider = sourceChildEndOfListValue();
         LOG(Media, "HTMLMediaElement::sourceRemoved - m_nextChildNodeToConsider set to %p", m_nextChildNodeToConsider);
     } else if (source == m_currentSourceNode) {
         // Clear the current source node pointer, but don't change the movie as the spec says:
-        // 4.8.8 - Dynamically modifying a source element and its attribute when the element is already 
+        // 4.8.8 - Dynamically modifying a source element and its attribute when the element is already
         // inserted in a video or audio element will have no effect.
         m_currentSourceNode = 0;
         LOG(Media, "HTMLMediaElement::sourceRemoved - m_currentSourceNode set to 0");
     }
 }
 
 void HTMLMediaElement::mediaPlayerTimeChanged(MediaPlayer*)
 {
     LOG(Media, "HTMLMediaElement::mediaPlayerTimeChanged");
 
     beginProcessingMediaPlayerCallback();
 
     invalidateCachedTime();
 
     // 4.8.10.9 step 14 & 15.  Needed if no ReadyState change is associated with the seek.
     if (m_seeking && m_readyState >= HAVE_CURRENT_DATA)
         finishSeek();
-    
-    // Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity, 
+
+    // Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity,
     // it will only queue a 'timeupdate' event if we haven't already posted one at the current
     // movie time.
     scheduleTimeupdateEvent(false);
 
     float now = currentTime();
     float dur = duration();
-    
+
     // When the current playback position reaches the end of the media resource when the direction of
     // playback is forwards, then the user agent must follow these steps:
     if (!isnan(dur) && dur && now >= dur && m_playbackRate > 0) {
         // If the media element has a loop attribute specified and does not have a current media controller,
         if (loop() && !m_mediaController) {
             ExceptionCode ignoredException;
             m_sentEndEvent = false;
             //  then seek to the earliest possible position of the media resource and abort these steps.
             seek(startTime(), ignoredException);
         } else {
@@ skipping 160 matching lines @@
 #if USE(ACCELERATED_COMPOSITING)
         mediaPlayerRenderingModeChanged(m_player.get());
 #endif
     }
     endProcessingMediaPlayerCallback();
 }
 
 void HTMLMediaElement::mediaPlayerCharacteristicChanged(MediaPlayer*)
 {
     LOG(Media, "HTMLMediaElement::mediaPlayerCharacteristicChanged");
-    
+
     beginProcessingMediaPlayerCallback();
     if (hasMediaControls())
         mediaControls()->reset();
     if (renderer())
         renderer()->updateFromElement();
     endProcessingMediaPlayerCallback();
 }
 
 PassRefPtr<TimeRanges> HTMLMediaElement::buffered() const
 {
@@ skipping 36 matching lines @@
 }
 
 bool HTMLMediaElement::endedPlayback() const
 {
     float dur = duration();
     if (!m_player || isnan(dur))
         return false;
 
     // 4.8.10.8 Playing the media resource
 
-    // A media element is said to have ended playback when the element's 
-    // readyState attribute is HAVE_METADATA or greater, 
+    // A media element is said to have ended playback when the element's
+    // readyState attribute is HAVE_METADATA or greater,
     if (m_readyState < HAVE_METADATA)
         return false;
 
     // and the current playback position is the end of the media resource and the direction
     // of playback is forwards, Either the media element does not have a loop attribute specified,
     // or the media element has a current media controller.
     float now = currentTime();
     if (m_playbackRate > 0)
         return dur > 0 && now >= dur && (!loop() || m_mediaController);
 
-    // or the current playback position is the earliest possible position and the direction 
+    // or the current playback position is the earliest possible position and the direction
     // of playback is backwards
     if (m_playbackRate < 0)
         return now <= 0;
 
     return false;
 }
 
 bool HTMLMediaElement::stoppedDueToErrors() const
 {
     if (m_readyState >= HAVE_METADATA && m_error) {
         RefPtr<TimeRanges> seekableRanges = seekable();
         if (!seekableRanges->contain(currentTime()))
             return true;
     }
-    
+
     return false;
 }
 
 bool HTMLMediaElement::pausedForUserInteraction() const
 {
 //    return !paused() && m_readyState >= HAVE_FUTURE_DATA && [UA requires a decitions from the user]
     return false;
 }
 
 float HTMLMediaElement::minTimeSeekable() const
 {
     return 0;
 }
 
 float HTMLMediaElement::maxTimeSeekable() const
 {
     return m_player ? m_player->maxTimeSeekable() : 0;
 }
-    
+
 void HTMLMediaElement::updateVolume()
 {
     if (!m_player)
         return;
 
     // Avoid recursion when the player reports volume changes.
     if (!processingMediaPlayerCallback()) {
         Page* page = document()->page();
         float volumeMultiplier = page ? page->mediaVolume() : 1;
         bool shouldMute = m_muted;
@@ skipping 18 matching lines @@
 
     if (m_pausedInternal) {
         if (!m_player->paused())
             m_player->pause();
         refreshCachedTime();
         m_playbackProgressTimer.stop();
         if (hasMediaControls())
             mediaControls()->playbackStopped();
         return;
     }
-    
+
     bool shouldBePlaying = potentiallyPlaying();
     bool playerPaused = m_player->paused();
 
-    LOG(Media, "HTMLMediaElement::updatePlayState - shouldBePlaying = %s, playerPaused = %s", 
+    LOG(Media, "HTMLMediaElement::updatePlayState - shouldBePlaying = %s, playerPaused = %s",
         boolString(shouldBePlaying), boolString(playerPaused));
 
     if (shouldBePlaying) {
         setDisplayMode(Video);
         invalidateCachedTime();
 
         if (playerPaused) {
             if (!m_isFullscreen && isVideo() && document() && document()->page() && document()->page()->chrome()->requiresFullscreenForVideoPlayback())
                 enterFullscreen();
 
@@ skipping 67 matching lines @@
     m_error = MediaError::create(MediaError::MEDIA_ERR_ABORTED);
 
     // 3 - Queue a task to fire a simple event named error at the media element.
     scheduleEvent(eventNames().abortEvent);
 
 #if ENABLE(MEDIA_SOURCE)
     if (m_sourceState != SOURCE_CLOSED)
         setSourceState(SOURCE_CLOSED);
 #endif
 
-    // 4 - If the media element's readyState attribute has a value equal to HAVE_NOTHING, set the 
-    // element's networkState attribute to the NETWORK_EMPTY value and queue a task to fire a 
-    // simple event named emptied at the element. Otherwise, set the element's networkState 
+    // 4 - If the media element's readyState attribute has a value equal to HAVE_NOTHING, set the
+    // element's networkState attribute to the NETWORK_EMPTY value and queue a task to fire a
+    // simple event named emptied at the element. Otherwise, set the element's networkState
     // attribute to the NETWORK_IDLE value.
     if (m_readyState == HAVE_NOTHING) {
         m_networkState = NETWORK_EMPTY;
         scheduleEvent(eventNames().emptiedEvent);
     }
     else
         m_networkState = NETWORK_IDLE;
 
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
     m_currentSourceNode = 0;
 
     // Reset m_readyState since m_player is gone.
     m_readyState = HAVE_NOTHING;
     updateMediaController();
 }
 
 bool HTMLMediaElement::canSuspend() const
 {
-    return true; 
+    return true;
 }
 
 void HTMLMediaElement::stop()
 {
     LOG(Media, "HTMLMediaElement::stop");
     if (m_isFullscreen)
         exitFullscreen();
-    
+
     m_inActiveDocument = false;
     userCancelledLoad();
-    
+
     // Stop the playback without generating events
     setPausedInternal(true);
-    
+
     if (renderer())
         renderer()->updateFromElement();
-    
+
     stopPeriodicTimers();
     cancelPendingEventsAndCallbacks();
 }
 
 void HTMLMediaElement::suspend(ReasonForSuspension why)
 {
     LOG(Media, "HTMLMediaElement::suspend");
-    
+
     switch (why)
     {
         case DocumentWillBecomeInactive:
             stop();
             break;
         case JavaScriptDebuggerPaused:
         case WillShowDialog:
             // Do nothing, we don't pause media playback in these cases.
             break;
     }
@@ skipping 14 matching lines @@
         ExceptionCode ec;
         load(ec);
     }
 
     if (renderer())
         renderer()->updateFromElement();
 }
 
 bool HTMLMediaElement::hasPendingActivity() const
 {
-    // Return true when we have pending events so we can't fire events after the JS 
+    // Return true when we have pending events so we can't fire events after the JS
     // object gets collected.
     bool pending = m_pendingEvents.size();
     LOG(Media, "HTMLMediaElement::hasPendingActivity -> %s", boolString(pending));
     return pending;
 }
 
 void HTMLMediaElement::mediaVolumeDidChange()
 {
     LOG(Media, "HTMLMediaElement::mediaVolumeDidChange");
     updateVolume();
@@ skipping 85 matching lines @@
     if (!frame)
         return;
 
     LOG(Media, "HTMLMediaElement::createMediaPlayerProxy");
 
     KURL url;
     Vector<String> paramNames;
     Vector<String> paramValues;
 
     getPluginProxyParams(url, paramNames, paramValues);
-    
+
     // Hang onto the proxy widget so it won't be destroyed if the plug-in is set to
     // display:none
     m_proxyWidget = frame->loader()->subframeLoader()->loadMediaPlayerProxyPlugin(this, url, paramNames, paramValues);
     if (m_proxyWidget)
         m_needWidgetUpdate = false;
 }
 
 void HTMLMediaElement::updateWidget(PluginCreationOption)
 {
     mediaElement->setNeedWidgetUpdate(false);
 
     Vector<String> paramNames;
     Vector<String> paramValues;
     // FIXME: Rename kurl to something more sensible.
     KURL kurl;
 
     mediaElement->getPluginProxyParams(kurl, paramNames, paramValues);
     // FIXME: What if document()->frame() is 0?
     SubframeLoader* loader = document()->frame()->loader()->subframeLoader();
     loader->loadMediaPlayerProxyPlugin(mediaElement, kurl, paramNames, paramValues);
 }
 
 #endif // ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 
 bool HTMLMediaElement::isFullscreen() const
 {
     if (m_isFullscreen)
         return true;
-    
+
 #if ENABLE(FULLSCREEN_API)
     if (document()->webkitIsFullScreen() && document()->webkitCurrentFullScreenElement() == this)
         return true;
 #endif
-    
+
     return false;
 }
 
 void HTMLMediaElement::enterFullscreen()
 {
     LOG(Media, "HTMLMediaElement::enterFullscreen");
 
 #if ENABLE(FULLSCREEN_API)
     if (document() && document()->settings() && document()->settings()->fullScreenEnabled()) {
         document()->requestFullScreenForElement(this, 0, Document::ExemptIFrameAllowFulScreenRequirement);
@@ skipping 132 matching lines @@
         return;
 
     LOG(Media, "HTMLMediaElement::setShouldDelayLoadEvent(%s)", boolString(shouldDelay));
 
     m_shouldDelayLoadEvent = shouldDelay;
     if (shouldDelay)
         document()->incrementLoadEventDelayCount();
     else
         document()->decrementLoadEventDelayCount();
 }
-    
+
 
 void HTMLMediaElement::getSitesInMediaCache(Vector<String>& sites)
 {
     MediaPlayer::getSitesInMediaCache(sites);
 }
 
 void HTMLMediaElement::clearMediaCache()
 {
     MediaPlayer::clearMediaCache();
 }
@@ skipping 70 matching lines @@
 
     return 0;
 }
 
 void HTMLMediaElement::createMediaPlayer()
 {
 #if ENABLE(WEB_AUDIO)
     if (m_audioSourceNode)
         m_audioSourceNode->lock();
 #endif
-        
+
     m_player = MediaPlayer::create(this);
 
 #if ENABLE(WEB_AUDIO)
     if (m_audioSourceNode) {
         // When creating the player, make sure its AudioSourceProvider knows about the MediaElementAudioSourceNode.
         if (audioSourceProvider())
             audioSourceProvider()->setClient(m_audioSourceNode);
 
         m_audioSourceNode->unlock();
     }
@@ skipping 34 matching lines @@
 {
     return m_mediaGroup;
 }
 
 void HTMLMediaElement::setMediaGroup(const String& group)
 {
     if (m_mediaGroup == group)
         return;
     m_mediaGroup = group;
 
-    // When a media element is created with a mediagroup attribute, and when a media element's mediagroup 
+    // 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 m [this] be the media element in question.
     // 2. Let m have no current media controller, if it currently has one.
     setController(0);
 
     // 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), 
+    // of these elements are not actually in the Document),
     HashSet<HTMLMediaElement*> elements = documentToElementSetMap().get(document());
     for (HashSet<HTMLMediaElement*>::iterator i = elements.begin(); i != elements.end(); ++i) {
         if (*i == 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,        
+        // the new value of m's mediagroup attribute,
         if ((*i)->mediaGroup() == group) {
             //  then let controller be that media element's current media controller.
             setController((*i)->controller());
             return;
         }
     }
 
     // Otherwise, let controller be a newly created MediaController.
     setController(MediaController::create(Node::scriptExecutionContext()));
 }
@@ skipping 29 matching lines @@
 
     // or if the element has paused for user interaction.
     return pausedForUserInteraction();
 }
 
 bool HTMLMediaElement::isBlockedOnMediaController() const
 {
     if (!m_mediaController)
         return false;
 
-    // A media element is blocked on its media controller if the MediaController is a blocked 
+    // A media element is blocked on its media controller if the MediaController is a blocked
     // media controller,
     if (m_mediaController->isBlocked())
         return true;
 
-    // or if its media controller position is either before the media resource's earliest possible 
-    // position relative to the MediaController's timeline or after the end of the media resource 
+    // or if its media controller position is either before the media resource's earliest possible
+    // position relative to the MediaController's timeline or after the end of the media resource
     // relative to the MediaController's timeline.
     float mediaControllerPosition = m_mediaController->currentTime();
     if (mediaControllerPosition < startTime() || mediaControllerPosition > startTime() + duration())
         return true;
 
     return false;
 }
 
 }
 
 #endif