Update all float attributes in HTMLMediaElement and related objects to double

Source/WebCore/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 234 matching lines @@
     , m_playbackRate(1.0f)
     , m_defaultPlaybackRate(1.0f)
     , m_webkitPreservesPitch(true)
     , m_networkState(NETWORK_EMPTY)
     , m_readyState(HAVE_NOTHING)
     , m_readyStateMaximum(HAVE_NOTHING)
     , m_volume(1.0f)
     , m_lastSeekTime(0)
     , m_previousProgressTime(numeric_limits<double>::max())
     , m_lastTimeUpdateEventWallTime(0)
-    , m_lastTimeUpdateEventMovieTime(numeric_limits<float>::max())
+    , m_lastTimeUpdateEventMovieTime(numeric_limits<double>::max())
     , m_loadState(WaitingForSource)
 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
     , m_proxyWidget(0)
 #endif
     , m_restrictions(RequireUserGestureForFullscreenRestriction | RequirePageConsentToLoadMediaRestriction)
     , m_preload(MediaPlayer::Auto)
     , m_displayMode(Unknown)
     , m_processingMediaPlayerCallback(0)
     , m_cachedTime(MediaPlayer::invalidTime())
     , m_cachedTimeWallClockUpdateTime(0)
@@ skipping 812 matching lines @@
     if (a.second->track() != b.second->track())
         return trackIndexCompare(a.second->track(), b.second->track());
 
     // 12 - Further sort tasks in events that have the same time by the
     // relative text track cue order of the text track cues associated
     // with these tasks.
     return a.second->cueIndex() - b.second->cueIndex() < 0;
 }
 
 
-void HTMLMediaElement::updateActiveTextTrackCues(float movieTime)
+void HTMLMediaElement::updateActiveTextTrackCues(double movieTime)
 {
     LOG(Media, "HTMLMediaElement::updateActiveTextTracks");
 
     // 4.8.10.8 Playing the media resource
 
     //  If the current playback position changes while the steps are running,
     //  then the user agent must wait for the steps to complete, and then must
     //  immediately rerun the steps.
     if (ignoreTrackDisplayUpdateRequests())
         return;
@@ skipping 14 matching lines @@
     CueList missedCues;
 
     // 2 - Let other cues be a list of cues, initialized to contain all the cues
     // of hidden, showing, and showing by default text tracks of the media
     // element that are not present in current cues.
     previousCues = m_currentlyActiveCues;
 
     // 3 - Let last time be the current playback position at the time this
     // algorithm was last run for this media element, if this is not the first
     // time it has run.
-    float lastTime = m_lastTextTrackUpdateTime;
+    double lastTime = m_lastTextTrackUpdateTime;
 
     // 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) {
-            float cueStartTime = potentiallySkippedCues[i].low();
-            float cueEndTime = potentiallySkippedCues[i].high();
+            double cueStartTime = potentiallySkippedCues[i].low();
+            double cueEndTime = potentiallySkippedCues[i].high();
 
             // Consider cues that may have been missed since the last seek time.
             if (cueStartTime > max(m_lastSeekTime, lastTime) && cueEndTime < movieTime)
                 missedCues.append(potentiallySkippedCues[i]);
         }
     }
 
     m_lastTextTrackUpdateTime = movieTime;
 
     // 5 - If the time was reached through the usual monotonic increase of the
@@ skipping 819 matching lines @@
             renderer()->updateFromElement();
         if (hasMediaControls())
             mediaControls()->bufferingProgressed();
     } else if (timedelta > 3.0 && !m_sentStalledEvent) {
         scheduleEvent(eventNames().stalledEvent);
         m_sentStalledEvent = true;
         setShouldDelayLoadEvent(false);
     }
 }
 
-void HTMLMediaElement::rewind(float timeDelta)
+void HTMLMediaElement::rewind(double timeDelta)
 {
     LOG(Media, "HTMLMediaElement::rewind(%f)", timeDelta);
     setCurrentTime(max(currentTime() - timeDelta, minTimeSeekable()), IGNORE_EXCEPTION);
 }
 
 void HTMLMediaElement::returnToRealtime()
 {
     LOG(Media, "HTMLMediaElement::returnToRealtime");
     setCurrentTime(maxTimeSeekable(), IGNORE_EXCEPTION);
 }
 
-void HTMLMediaElement::addPlayedRange(float start, float end)
+void HTMLMediaElement::addPlayedRange(double start, double 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;
 }
 
 void HTMLMediaElement::prepareToPlay()
 {
     LOG(Media, "HTMLMediaElement::prepareToPlay(%p)", this);
     if (m_havePreparedToPlay)
         return;
     m_havePreparedToPlay = true;
     m_player->prepareToPlay();
 }
 
-void HTMLMediaElement::seek(float time, ExceptionCode& ec)
+void HTMLMediaElement::seek(double time, ExceptionCode& ec)
 {
     LOG(Media, "HTMLMediaElement::seek(%f)", time);
 
     // 4.8.9.9 Seeking
 
     // 1 - If the media element's readyState is HAVE_NOTHING, then raise an INVALID_STATE_ERR exception.
     if (m_readyState == HAVE_NOTHING || !m_player) {
         ec = INVALID_STATE_ERR;
         return;
     }
 
     // If the media engine has been told to postpone loading data, let it go ahead now.
     if (m_preload < MediaPlayer::Auto && m_readyState < HAVE_FUTURE_DATA)
         prepareToPlay();
 
     // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.
     refreshCachedTime();
-    float now = currentTime();
+    double now = currentTime();
 
     // 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 
     // 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();
+    double 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 
     // fire a 'seeked' event.
 #if !LOG_DISABLED
-    float mediaTime = m_player->mediaTimeForTimeValue(time);
+    double 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 
     // 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();
@@ skipping 86 matching lines @@
     // Don't try to cache movie time when playback first starts as the time reported by the engine
     // sometimes fluctuates for a short amount of time, so the cached time will be off if we take it
     // too early.
     static const double minimumTimePlayingBeforeCacheSnapshot = 0.5;
 
     m_minimumWallClockTimeToCacheMediaTime = WTF::currentTime() + minimumTimePlayingBeforeCacheSnapshot;
     m_cachedTime = MediaPlayer::invalidTime();
 }
 
 // playback state
-float HTMLMediaElement::currentTime() const
+double HTMLMediaElement::currentTime() const
 {
 #if LOG_CACHED_TIME_WARNINGS
     static const double minCachedDeltaForWarning = 0.01;
 #endif
 
     if (!m_player)
         return 0;
 
     if (m_seeking) {
         LOG(Media, "HTMLMediaElement::currentTime - seeking, returning %f", m_lastSeekTime);
         return m_lastSeekTime;
     }
 
     if (m_cachedTime != MediaPlayer::invalidTime() && m_paused) {
 #if LOG_CACHED_TIME_WARNINGS
-        float delta = m_cachedTime - m_player->currentTime();
+        double delta = m_cachedTime - m_player->currentTime();
         if (delta > minCachedDeltaForWarning)
             LOG(Media, "HTMLMediaElement::currentTime - WARNING, cached time is %f seconds off of media time when paused", delta);
 #endif
         return m_cachedTime;
     }
 
     // Is it too soon use a cached time?
     double now = WTF::currentTime();
     double maximumDurationToCacheMediaTime = m_player->maximumDurationToCacheMediaTime();
 
     if (maximumDurationToCacheMediaTime && m_cachedTime != MediaPlayer::invalidTime() && !m_paused && now > m_minimumWallClockTimeToCacheMediaTime) {
         double wallClockDelta = now - m_cachedTimeWallClockUpdateTime;
 
         // Not too soon, use the cached time only if it hasn't expired.
         if (wallClockDelta < maximumDurationToCacheMediaTime) {
-            float adjustedCacheTime = static_cast<float>(m_cachedTime + (m_playbackRate * wallClockDelta));
+            double adjustedCacheTime = m_cachedTime + (m_playbackRate * wallClockDelta);
 
 #if LOG_CACHED_TIME_WARNINGS
-            float delta = adjustedCacheTime - m_player->currentTime();
+            double delta = adjustedCacheTime - m_player->currentTime();
             if (delta > minCachedDeltaForWarning)
                 LOG(Media, "HTMLMediaElement::currentTime - WARNING, cached time is %f seconds off of media time when playing", delta);
 #endif
             return adjustedCacheTime;
         }
     }
 
 #if LOG_CACHED_TIME_WARNINGS
     if (maximumDurationToCacheMediaTime && now > m_minimumWallClockTimeToCacheMediaTime && m_cachedTime != MediaPlayer::invalidTime()) {
         double wallClockDelta = now - m_cachedTimeWallClockUpdateTime;
-        float delta = m_cachedTime + (m_playbackRate * wallClockDelta) - m_player->currentTime();
+        double delta = m_cachedTime + (m_playbackRate * wallClockDelta) - m_player->currentTime();
         LOG(Media, "HTMLMediaElement::currentTime - cached time was %f seconds off of media time when it expired", delta);
     }
 #endif
 
     refreshCachedTime();
 
     return m_cachedTime;
 }
 
-void HTMLMediaElement::setCurrentTime(float time, ExceptionCode& ec)
+void HTMLMediaElement::setCurrentTime(double time, ExceptionCode& ec)
 {
     if (m_mediaController) {
         ec = INVALID_STATE_ERR;
         return;
     }
     seek(time, ec);
 }
 
-float HTMLMediaElement::startTime() const
+double HTMLMediaElement::startTime() const
 {
     if (!m_player)
         return 0;
     return m_player->startTime();
 }
 
 double HTMLMediaElement::initialTime() const
 {
     if (m_fragmentStartTime != MediaPlayer::invalidTime())
         return m_fragmentStartTime;
 
     if (!m_player)
         return 0;
 
     return m_player->initialTime();
 }
 
-float HTMLMediaElement::duration() const
+double HTMLMediaElement::duration() const
 {
     if (m_player && m_readyState >= HAVE_METADATA)
         return m_player->duration();
 
-    return numeric_limits<float>::quiet_NaN();
+    return numeric_limits<double>::quiet_NaN();
 }
 
 bool HTMLMediaElement::paused() const
 {
     return m_paused;
 }
 
-float HTMLMediaElement::defaultPlaybackRate() const
+double HTMLMediaElement::defaultPlaybackRate() const
 {
     return m_defaultPlaybackRate;
 }
 
-void HTMLMediaElement::setDefaultPlaybackRate(float rate)
+void HTMLMediaElement::setDefaultPlaybackRate(double rate)
 {
     if (m_defaultPlaybackRate != rate) {
         m_defaultPlaybackRate = rate;
         scheduleEvent(eventNames().ratechangeEvent);
     }
 }
 
-float HTMLMediaElement::playbackRate() const
+double HTMLMediaElement::playbackRate() const
 {
     return m_playbackRate;
 }
 
-void HTMLMediaElement::setPlaybackRate(float rate)
+void HTMLMediaElement::setPlaybackRate(double 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;
+    double effectiveRate = m_mediaController ? m_mediaController->playbackRate() : m_playbackRate;
     if (m_player && potentiallyPlaying() && m_player->rate() != effectiveRate)
         m_player->setRate(effectiveRate);
 }
 
 bool HTMLMediaElement::webkitPreservesPitch() const
 {
     return m_webkitPreservesPitch;
 }
 
 void HTMLMediaElement::setWebkitPreservesPitch(bool preservesPitch)
@@ skipping 275 matching lines @@
 
     return fastHasAttribute(controlsAttr);
 }
 
 void HTMLMediaElement::setControls(bool b)
 {
     LOG(Media, "HTMLMediaElement::setControls(%s)", boolString(b));
     setBooleanAttribute(controlsAttr, b);
 }
 
-float HTMLMediaElement::volume() const
+double HTMLMediaElement::volume() const
 {
     return m_volume;
 }
 
-void HTMLMediaElement::setVolume(float vol, ExceptionCode& ec)
+void HTMLMediaElement::setVolume(double 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;
@@ skipping 108 matching lines @@
 {
     double now = WTF::currentTime();
     double timedelta = now - m_lastTimeUpdateEventWallTime;
 
     // throttle the periodic events
     if (periodicEvent && timedelta < maxTimeupdateEventFrequency)
         return;
 
     // Some media engines make multiple "time changed" callbacks at the same time, but we only want one
     // event at a given time so filter here
-    float movieTime = currentTime();
+    double movieTime = currentTime();
     if (movieTime != m_lastTimeUpdateEventMovieTime) {
         scheduleEvent(eventNames().timeupdateEvent);
         m_lastTimeUpdateEventWallTime = now;
         m_lastTimeUpdateEventMovieTime = movieTime;
     }
 }
 
 bool HTMLMediaElement::canPlay() const
 {
     return paused() || ended() || m_readyState < HAVE_METADATA;
 }
 
-float HTMLMediaElement::percentLoaded() const
+double HTMLMediaElement::percentLoaded() const
 {
     if (!m_player)
         return 0;
-    float duration = m_player->duration();
+    double duration = m_player->duration();
 
     if (!duration || std::isinf(duration))
         return 0;
 
-    float buffered = 0;
+    double buffered = 0;
     RefPtr<TimeRanges> timeRanges = m_player->buffered();
     for (unsigned i = 0; i < timeRanges->length(); ++i) {
-        float start = timeRanges->start(i, IGNORE_EXCEPTION);
-        float end = timeRanges->end(i, IGNORE_EXCEPTION);
+        double start = timeRanges->start(i, IGNORE_EXCEPTION);
+        double end = timeRanges->end(i, IGNORE_EXCEPTION);
         buffered += end - start;
     }
     return buffered / duration;
 }
 
 #if ENABLE(VIDEO_TRACK)
 
 void HTMLMediaElement::mediaPlayerDidAddTrack(PassRefPtr<InbandTextTrackPrivate> prpTrack)
 {
     if (!RuntimeEnabledFeatures::webkitVideoTrackEnabled())
@@ skipping 649 matching lines @@
 
     // 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 && !m_player->seeking())
         finishSeek();
     
     // 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();
+    double now = currentTime();
+    double 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 (!std::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) {
             m_sentEndEvent = false;
             //  then seek to the earliest possible position of the media resource and abort these steps.
             seek(startTime(), IGNORE_EXCEPTION);
         } else {
@@ skipping 21 matching lines @@
     updatePlayState();
     endProcessingMediaPlayerCallback();
 }
 
 void HTMLMediaElement::mediaPlayerVolumeChanged(MediaPlayer*)
 {
     LOG(Media, "HTMLMediaElement::mediaPlayerVolumeChanged");
 
     beginProcessingMediaPlayerCallback();
     if (m_player) {
-        float vol = m_player->volume();
+        double vol = m_player->volume();
         if (vol != m_volume) {
             m_volume = vol;
             updateVolume();
             scheduleEvent(eventNames().volumechangeEvent);
         }
     }
     endProcessingMediaPlayerCallback();
 }
 
 void HTMLMediaElement::mediaPlayerMuteChanged(MediaPlayer*)
 {
     LOG(Media, "HTMLMediaElement::mediaPlayerMuteChanged");
 
     beginProcessingMediaPlayerCallback();
     if (m_player)
         setMuted(m_player->muted());
     endProcessingMediaPlayerCallback();
 }
 
 void HTMLMediaElement::mediaPlayerDurationChanged(MediaPlayer* player)
 {
     LOG(Media, "HTMLMediaElement::mediaPlayerDurationChanged");
 
     beginProcessingMediaPlayerCallback();
 
     scheduleEvent(eventNames().durationchangeEvent);
     mediaPlayerCharacteristicChanged(player);
 
-    float now = currentTime();
-    float dur = duration();
+    double now = currentTime();
+    double dur = duration();
     if (now > dur)
         seek(dur, IGNORE_EXCEPTION);
 
     endProcessingMediaPlayerCallback();
 }
 
 void HTMLMediaElement::mediaPlayerRateChanged(MediaPlayer*)
 {
     LOG(Media, "HTMLMediaElement::mediaPlayerRateChanged");
 
@@ skipping 134 matching lines @@
 PassRefPtr<TimeRanges> HTMLMediaElement::buffered() const
 {
     if (!m_player)
         return TimeRanges::create();
     return m_player->buffered();
 }
 
 PassRefPtr<TimeRanges> HTMLMediaElement::played()
 {
     if (m_playing) {
-        float time = currentTime();
+        double time = currentTime();
         if (time > m_lastSeekTime)
             addPlayedRange(m_lastSeekTime, time);
     }
 
     if (!m_playedTimeRanges)
         m_playedTimeRanges = TimeRanges::create();
 
     return m_playedTimeRanges->copy();
 }
 
@@ skipping 11 matching lines @@
     return (pausedToBuffer || m_readyState >= HAVE_FUTURE_DATA) && couldPlayIfEnoughData() && !isBlockedOnMediaController();
 }
 
 bool HTMLMediaElement::couldPlayIfEnoughData() const
 {
     return !paused() && !endedPlayback() && !stoppedDueToErrors() && !pausedForUserInteraction();
 }
 
 bool HTMLMediaElement::endedPlayback() const
 {
-    float dur = duration();
+    double dur = duration();
     if (!m_player || std::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, 
     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();
+    double 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 
     // 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
+double HTMLMediaElement::minTimeSeekable() const
 {
     return 0;
 }
 
-float HTMLMediaElement::maxTimeSeekable() const
+double 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;
+        double volumeMultiplier = page ? page->mediaVolume() : 1;
         bool shouldMute = m_muted;
 
         if (m_mediaController) {
             volumeMultiplier *= m_mediaController->volume();
             shouldMute = m_mediaController->muted();
         }
 
         m_player->setMuted(shouldMute);
         m_player->setVolume(m_volume * volumeMultiplier);
     }
@@ skipping 44 matching lines @@
         startPlaybackProgressTimer();
         m_playing = true;
 
     } else { // Should not be playing right now
         if (!playerPaused)
             m_player->pause();
         refreshCachedTime();
 
         m_playbackProgressTimer.stop();
         m_playing = false;
-        float time = currentTime();
+        double time = currentTime();
         if (time > m_lastSeekTime)
             addPlayedRange(m_lastSeekTime, time);
 
         if (couldPlayIfEnoughData())
             prepareToPlay();
 
         if (hasMediaControls())
             mediaControls()->playbackStopped();
     }
 
@@ skipping 819 matching lines @@
         return false;
 
     // 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 
     // relative to the MediaController's timeline.
-    float mediaControllerPosition = m_mediaController->currentTime();
+    double mediaControllerPosition = m_mediaController->currentTime();
     if (mediaControllerPosition < startTime() || mediaControllerPosition > startTime() + duration())
         return true;
 
     return false;
 }
 
 void HTMLMediaElement::prepareMediaFragmentURI()
 {
     MediaFragmentURIParser fragmentParser(m_currentSrc);
-    float dur = duration();
+    double dur = duration();
     
     double start = fragmentParser.startTime();
     if (start != MediaFragmentURIParser::invalidTimeValue() && start > 0) {
         m_fragmentStartTime = start;
         if (m_fragmentStartTime > dur)
             m_fragmentStartTime = dur;
     } else
         m_fragmentStartTime = MediaPlayer::invalidTime();
     
     double end = fragmentParser.endTime();
@@ skipping 182 matching lines @@
     info.addMember(m_sleepDisabler, "sleepDisabler");
 #endif
 #if ENABLE(WEB_AUDIO)
     info.addMember(m_audioSourceNode, "audioSourceNode");
 #endif
 
 }
 
 }
 #endif