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 264 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);

[eseidel, 2013/04/06 04:04:46]

Float?

[acolwell GONE FROM CHROMIUM, 2013/04/06 04:17:06]

Yes. These are the new temporary method names. The plan is to move the calls
over to these methods temporarily so that things continue to work and then
implement setVolume(double) and finally change the code back to use setVolume().


For this method at least I could provide a setVolume(double) if we are ok
temporarily having overloads. Would that be a preferred route?

 }
 
 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();

[eseidel, 2013/04/06 04:04:46]

Float?

[acolwell GONE FROM CHROMIUM, 2013/04/06 04:17:06]

Yes. The idea here is the same as above. In this case, I have to use a different
name because only the return type is different. 

+    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);

[eseidel, 2013/04/06 04:04:46]

This looks wrong?

[acolwell GONE FROM CHROMIUM, 2013/04/06 04:17:06]

No. Same reasoning as above.

     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)