Update all float attributes in HTMLMediaElement and related objects to double

Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "WebMediaPlayerClientImpl.h"
 
 #if ENABLE(VIDEO)
 
 #include "AudioBus.h"
@@ skipping 98 matching lines @@
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->networkStateChanged();
 }
 
 void WebMediaPlayerClientImpl::readyStateChanged()
 {
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->readyStateChanged();
 }
 
-void WebMediaPlayerClientImpl::volumeChanged(float newVolume)
+void WebMediaPlayerClientImpl::volumeChanged(double newVolume)
 {
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->volumeChanged(newVolume);
 }
 
 void WebMediaPlayerClientImpl::muteChanged(bool newMute)
 {
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->muteChanged(newMute);
 }
@@ skipping 38 matching lines @@
         m_videoLayer->setOpaque(m_opaque);
 #endif
 }
 
 void WebMediaPlayerClientImpl::sawUnsupportedTracks()
 {
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->mediaPlayerClient()->mediaPlayerSawUnsupportedTracks(m_mediaPlayer);
 }
 
-float WebMediaPlayerClientImpl::volume() const
+double WebMediaPlayerClientImpl::volume() const
 {
     if (m_mediaPlayer)
         return m_mediaPlayer->volume();
-    return 0.0f;
+    return 0.0;
 }
 
 void WebMediaPlayerClientImpl::playbackStateChanged()
 {
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->playbackStateChanged();
 }
 
 WebMediaPlayer::Preload WebMediaPlayerClientImpl::preload() const
 {
@@ skipping 270 matching lines @@
         return m_webMediaPlayer->hasAudio();
     return false;
 }
 
 void WebMediaPlayerClientImpl::setVisible(bool visible)
 {
     if (m_webMediaPlayer)
         m_webMediaPlayer->setVisible(visible);
 }
 
-float WebMediaPlayerClientImpl::duration() const
+double WebMediaPlayerClientImpl::duration() const
 {
     if (m_webMediaPlayer)
-        return m_webMediaPlayer->duration();
+        return m_webMediaPlayer->durationFloat();
     return 0.0f;
 }
 
-float WebMediaPlayerClientImpl::currentTime() const
+double WebMediaPlayerClientImpl::currentTime() const
 {
     if (m_webMediaPlayer)
-        return m_webMediaPlayer->currentTime();
+        return m_webMediaPlayer->currentTimeFloat();
     return 0.0f;
 }
 
-void WebMediaPlayerClientImpl::seek(float time)
+void WebMediaPlayerClientImpl::seek(double time)
 {
     if (m_webMediaPlayer)
-        m_webMediaPlayer->seek(time);
+        m_webMediaPlayer->seekFloat(time);
 }
 
 bool WebMediaPlayerClientImpl::seeking() const
 {
     if (m_webMediaPlayer)
         return m_webMediaPlayer->seeking();
     return false;
 }
 
-void WebMediaPlayerClientImpl::setEndTime(float time)
+void WebMediaPlayerClientImpl::setEndTime(double time)
 {
     if (m_webMediaPlayer)
-        m_webMediaPlayer->setEndTime(time);
+        m_webMediaPlayer->setEndTimeFloat(time);
 }
 
-void WebMediaPlayerClientImpl::setRate(float rate)
+void WebMediaPlayerClientImpl::setRate(double rate)
 {
     if (m_webMediaPlayer)
-        m_webMediaPlayer->setRate(rate);
+        m_webMediaPlayer->setRateFloat(rate);
 }
 
 bool WebMediaPlayerClientImpl::paused() const
 {
     if (m_webMediaPlayer)
         return m_webMediaPlayer->paused();
     return false;
 }
 
 bool WebMediaPlayerClientImpl::supportsFullscreen() const
 {
     if (m_webMediaPlayer)
         return m_webMediaPlayer->supportsFullscreen();
     return false;
 }
 
 bool WebMediaPlayerClientImpl::supportsSave() const
 {
     if (m_webMediaPlayer)
         return m_webMediaPlayer->supportsSave();
     return false;
 }
 
-void WebMediaPlayerClientImpl::setVolume(float volume)
+void WebMediaPlayerClientImpl::setVolume(double volume)
 {
     if (m_webMediaPlayer)
-        m_webMediaPlayer->setVolume(volume);
+        m_webMediaPlayer->setVolumeFloat(volume);
 }
 
 MediaPlayer::NetworkState WebMediaPlayerClientImpl::networkState() const
 {
     if (m_webMediaPlayer)
         return static_cast<MediaPlayer::NetworkState>(m_webMediaPlayer->networkState());
     return MediaPlayer::Empty;
 }
 
 MediaPlayer::ReadyState WebMediaPlayerClientImpl::readyState() const
 {
     if (m_webMediaPlayer)
         return static_cast<MediaPlayer::ReadyState>(m_webMediaPlayer->readyState());
     return MediaPlayer::HaveNothing;
 }
 
-float WebMediaPlayerClientImpl::maxTimeSeekable() const
+double WebMediaPlayerClientImpl::maxTimeSeekable() const
 {
     if (m_webMediaPlayer)
-        return m_webMediaPlayer->maxTimeSeekable();
-    return 0.0f;
+        return m_webMediaPlayer->maxTimeSeekableFloat();
+    return 0.0;
 }
 
 PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const
 {
     if (m_webMediaPlayer) {
         const WebTimeRanges& webRanges = m_webMediaPlayer->buffered();
 
         // FIXME: Save the time ranges in a member variable and update it when needed.
         RefPtr<TimeRanges> ranges = TimeRanges::create();
         for (size_t i = 0; i < webRanges.size(); ++i)
@@ skipping 93 matching lines @@
 }
 
 MediaPlayer::MovieLoadType WebMediaPlayerClientImpl::movieLoadType() const
 {
     if (m_webMediaPlayer)
         return static_cast<MediaPlayer::MovieLoadType>(
             m_webMediaPlayer->movieLoadType());
     return MediaPlayer::Unknown;
 }
 
-float WebMediaPlayerClientImpl::mediaTimeForTimeValue(float timeValue) const
+double WebMediaPlayerClientImpl::mediaTimeForTimeValue(double timeValue) const
 {
     if (m_webMediaPlayer)
-        return m_webMediaPlayer->mediaTimeForTimeValue(timeValue);
+        return m_webMediaPlayer->mediaTimeForTimeValueFloat(timeValue);
     return timeValue;
 }
 
 unsigned WebMediaPlayerClientImpl::decodedFrameCount() const
 {
     if (m_webMediaPlayer)
         return m_webMediaPlayer->decodedFrameCount();
     return 0;
 }
 
@@ skipping 144 matching lines @@
 {
     if (m_client)
         m_client->setFormat(numberOfChannels, sampleRate);
 }
 
 #endif
 
 } // namespace WebKit
 
 #endif  // ENABLE(VIDEO)