Update all float attributes in HTMLMediaElement and related objects to double

Source/WebCore/platform/graphics/MediaPlayer.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 67 matching lines @@
     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
     virtual PlatformLayer* platformLayer() const { return 0; }
 
     virtual IntSize naturalSize() const { return IntSize(0, 0); }
 
     virtual bool hasVideo() const { return false; }
     virtual bool hasAudio() const { return false; }
 
     virtual void setVisible(bool) { }
 
-    virtual float duration() const { return 0; }
+    virtual double duration() const { return 0; }
 
-    virtual float currentTime() const { return 0; }
-    virtual void seek(float) { }
+    virtual double currentTime() const { return 0; }
+    virtual void seek(double) { }
     virtual bool seeking() const { return false; }
 
-    virtual void setRate(float) { }
+    virtual void setRate(double) { }
     virtual void setPreservesPitch(bool) { }
     virtual bool paused() const { return false; }
 
-    virtual void setVolume(float) { }
+    virtual void setVolume(double) { }
 
     virtual bool supportsMuting() const { return false; }
     virtual void setMuted(bool) { }
 
     virtual bool hasClosedCaptions() const { return false; }
     virtual void setClosedCaptionsVisible(bool) { };
 
     virtual MediaPlayer::NetworkState networkState() const { return MediaPlayer::Empty; }
     virtual MediaPlayer::ReadyState readyState() const { return MediaPlayer::HaveNothing; }
 
-    virtual float maxTimeSeekable() const { return 0; }
+    virtual double maxTimeSeekable() const { return 0; }
     virtual PassRefPtr<TimeRanges> buffered() const { return TimeRanges::create(); }
 
     virtual unsigned totalBytes() const { return 0; }
     virtual bool didLoadingProgress() const { return false; }
 
     virtual void setSize(const IntSize&) { }
 
     virtual void paint(GraphicsContext*, const IntRect&) { }
 
     virtual bool canLoadPoster() const { return false; }
@@ skipping 334 matching lines @@
 {
     return m_private->addKey(keySystem.lower(), key, keyLength, initData, initDataLength, sessionId);
 }
 
 MediaPlayer::MediaKeyException MediaPlayer::cancelKeyRequest(const String& keySystem, const String& sessionId)
 {
     return m_private->cancelKeyRequest(keySystem.lower(), sessionId);
 }
 #endif
 
-float MediaPlayer::duration() const
+double MediaPlayer::duration() const
 {
     return m_private->duration();
 }
 
-float MediaPlayer::startTime() const
+double MediaPlayer::startTime() const
 {
     return m_private->startTime();
 }
 
 double MediaPlayer::initialTime() const
 {
     return m_private->initialTime();
 }
 
-float MediaPlayer::currentTime() const
+double MediaPlayer::currentTime() const
 {
     return m_private->currentTime();
 }
 
-void MediaPlayer::seek(float time)
+void MediaPlayer::seek(double time)
 {
     m_private->seek(time);
 }
 
 bool MediaPlayer::paused() const
 {
     return m_private->paused();
 }
 
 bool MediaPlayer::seeking() const
@@ skipping 52 matching lines @@
 MediaPlayer::NetworkState MediaPlayer::networkState()
 {
     return m_private->networkState();
 }
 
 MediaPlayer::ReadyState MediaPlayer::readyState()
 {
     return m_private->readyState();
 }
 
-float MediaPlayer::volume() const
+double MediaPlayer::volume() const
 {
     return m_volume;
 }
 
-void MediaPlayer::setVolume(float volume)
+void MediaPlayer::setVolume(double volume)
 {
     m_volume = volume;
 
     if (m_private->supportsMuting() || !m_muted)
         m_private->setVolume(volume);
 }
 
 bool MediaPlayer::muted() const
 {
     return m_muted;
@@ skipping 12 matching lines @@
 bool MediaPlayer::hasClosedCaptions() const
 {
     return m_private->hasClosedCaptions();
 }
 
 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
 {
     m_private->setClosedCaptionsVisible(closedCaptionsVisible);
 }
 
-float MediaPlayer::rate() const
+double MediaPlayer::rate() const
 {
     return m_rate;
 }
 
-void MediaPlayer::setRate(float rate)
+void MediaPlayer::setRate(double rate)
 {
     m_rate = rate;
-    m_private->setRate(rate);   
+    m_private->setRate(rate);
 }
 
 bool MediaPlayer::preservesPitch() const
 {
     return m_preservesPitch;
 }
 
 void MediaPlayer::setPreservesPitch(bool preservesPitch)
 {
     m_preservesPitch = preservesPitch;
     m_private->setPreservesPitch(preservesPitch);
 }
 
 PassRefPtr<TimeRanges> MediaPlayer::buffered()
 {
     return m_private->buffered();
 }
 
 PassRefPtr<TimeRanges> MediaPlayer::seekable()
 {
     return m_private->seekable();
 }
 
-float MediaPlayer::maxTimeSeekable()
+double MediaPlayer::maxTimeSeekable()
 {
     return m_private->maxTimeSeekable();
 }
 
 bool MediaPlayer::didLoadingProgress()
 {
     return m_private->didLoadingProgress();
 }
 
 void MediaPlayer::setSize(const IntSize& size)
@@ skipping 138 matching lines @@
 bool MediaPlayer::didPassCORSAccessCheck() const
 {
     return m_private->didPassCORSAccessCheck();
 }
 
 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
 {
     return m_private->movieLoadType();
 }
 
-float MediaPlayer::mediaTimeForTimeValue(float timeValue) const
+double MediaPlayer::mediaTimeForTimeValue(double timeValue) const
 {
     return m_private->mediaTimeForTimeValue(timeValue);
 }
 
 double MediaPlayer::maximumDurationToCacheMediaTime() const
 {
     return m_private->maximumDurationToCacheMediaTime();
 }
 
 unsigned MediaPlayer::decodedFrameCount() const
@@ skipping 77 matching lines @@
     if (m_mediaPlayerClient)
         m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
 }
 
 void MediaPlayer::readyStateChanged()
 {
     if (m_mediaPlayerClient)
         m_mediaPlayerClient->mediaPlayerReadyStateChanged(this);
 }
 
-void MediaPlayer::volumeChanged(float newVolume)
+void MediaPlayer::volumeChanged(double newVolume)
 {
     m_volume = newVolume;
     if (m_mediaPlayerClient)
         m_mediaPlayerClient->mediaPlayerVolumeChanged(this);
 }
 
 void MediaPlayer::muteChanged(bool newMuted)
 {
     m_muted = newMuted;
     if (m_mediaPlayerClient)
@@ skipping 174 matching lines @@
     if (!m_private)
         return;
 
     m_private->simulateAudioInterruption();
 }
 #endif
 
 }
 
 #endif