Update all float attributes in HTMLMediaElement and related objects to double

Source/WebCore/html/HTMLMediaElement.h

 /*
  * 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 78 matching lines @@
     , public PlatformTextTrackMenuClient
 #endif
 {
 public:
     MediaPlayer* player() const { return m_player.get(); }
 
     virtual bool isVideo() const = 0;
     virtual bool hasVideo() const { return false; }
     virtual bool hasAudio() const;
 
-    void rewind(float timeDelta);
+    void rewind(double timeDelta);
     void returnToRealtime();
 
     // Eventually overloaded in HTMLVideoElement
     virtual bool supportsFullscreen() const { return false; };
 
     virtual bool supportsSave() const;
     virtual bool supportsScanning() const;
     
     PlatformMedia platformMedia() const;
 #if USE(ACCELERATED_COMPOSITING)
@@ skipping 27 matching lines @@
 
     PassRefPtr<TimeRanges> buffered() const;
     void load();
     String canPlayType(const String& mimeType, const String& keySystem = String(), const KURL& = KURL()) const;
 
 // ready state
     ReadyState readyState() const;
     bool seeking() const;
 
 // playback state
-    float currentTime() const;
-    void setCurrentTime(float, ExceptionCode&);
+    double currentTime() const;
+    void setCurrentTime(double, ExceptionCode&);
     double initialTime() const;
-    float startTime() const;
-    float duration() const;
+    double startTime() const;
+    double duration() const;
     bool paused() const;
-    float defaultPlaybackRate() const;
-    void setDefaultPlaybackRate(float);
-    float playbackRate() const;
-    void setPlaybackRate(float);
+    double defaultPlaybackRate() const;
+    void setDefaultPlaybackRate(double);
+    double playbackRate() const;
+    void setPlaybackRate(double);
     void updatePlaybackRate();
     bool webkitPreservesPitch() const;
     void setWebkitPreservesPitch(bool);
     PassRefPtr<TimeRanges> played();
     PassRefPtr<TimeRanges> seekable() const;
     bool ended() const;
     bool autoplay() const;    
     void setAutoplay(bool b);
     bool loop() const;    
     void setLoop(bool b);
@@ skipping 32 matching lines @@
 #endif
 
 #if ENABLE(ENCRYPTED_MEDIA_V2)
     MediaKeys* mediaKeys() const { return m_mediaKeys.get(); }
     void setMediaKeys(MediaKeys*);
 #endif
 
 // controls
     bool controls() const;
     void setControls(bool);
-    float volume() const;
-    void setVolume(float, ExceptionCode&);
+    double volume() const;
+    void setVolume(double, ExceptionCode&);
     bool muted() const;
     void setMuted(bool);
 
     void togglePlayState();
     void beginScrubbing();
     void endScrubbing();
     
     bool canPlay() const;
 
-    float percentLoaded() const;
+    double percentLoaded() const;
 
 #if ENABLE(VIDEO_TRACK)
     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, const String& language, ExceptionCode&);
     PassRefPtr<TextTrack> addTextTrack(const String& kind, const String& label, ExceptionCode& ec) { return addTextTrack(kind, label, emptyString(), ec); }
     PassRefPtr<TextTrack> addTextTrack(const String& kind, ExceptionCode& ec) { return addTextTrack(kind, emptyString(), emptyString(), ec); }
 
     TextTrackList* textTracks();
     CueList currentlyActiveCues() const { return m_currentlyActiveCues; }
 
     void addTrack(TextTrack*);
@@ skipping 258 matching lines @@
     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const OVERRIDE;
 #endif
 
     void loadTimerFired(Timer<HTMLMediaElement>*);
     void progressEventTimerFired(Timer<HTMLMediaElement>*);
     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
     void startPlaybackProgressTimer();
     void startProgressEventTimer();
     void stopPeriodicTimers();
 
-    void seek(float time, ExceptionCode&);
+    void seek(double time, ExceptionCode&);
     void finishSeek();
     void checkIfSeekNeeded();
-    void addPlayedRange(float start, float end);
+    void addPlayedRange(double start, double end);
     
     void scheduleTimeupdateEvent(bool periodicEvent);
     void scheduleEvent(const AtomicString& eventName);
     
     // loading
     void selectMediaResource();
     void loadResource(const KURL&, ContentType&, const String& keySystem);
     void scheduleNextSourceChild();
     void loadNextSourceChild();
     void userCancelledLoad();
     void clearMediaPlayer(int flags);
     bool havePotentialSourceChild();
     void noneSupported();
     void mediaEngineError(PassRefPtr<MediaError> err);
     void cancelPendingEventsAndCallbacks();
     void waitForSourceChange();
     void prepareToPlay();
 
     KURL selectNextSourceChild(ContentType*, String* keySystem, InvalidURLAction);
 
     void mediaLoadingFailed(MediaPlayer::NetworkState);
 
 #if ENABLE(VIDEO_TRACK)
-    void updateActiveTextTrackCues(float);
+    void updateActiveTextTrackCues(double);
     HTMLTrackElement* showingTrackWithSameKind(HTMLTrackElement*) const;
 
     void markCaptionAndSubtitleTracksAsUnconfigured();
     virtual void captionPreferencesChanged() OVERRIDE;
 #endif
 
     // These "internal" functions do not check user gesture restrictions.
     void loadInternal();
     void playInternal();
     void pauseInternal();
 
     void prepareForLoad();
     void allowVideoRendering();
 
     bool processingMediaPlayerCallback() const { return m_processingMediaPlayerCallback > 0; }
     void beginProcessingMediaPlayerCallback() { ++m_processingMediaPlayerCallback; }
     void endProcessingMediaPlayerCallback() { ASSERT(m_processingMediaPlayerCallback); --m_processingMediaPlayerCallback; }
 
     void updateVolume();
     void updatePlayState();
     bool potentiallyPlaying() const;
     bool endedPlayback() const;
     bool stoppedDueToErrors() const;
     bool pausedForUserInteraction() const;
     bool couldPlayIfEnoughData() const;
 
-    float minTimeSeekable() const;
-    float maxTimeSeekable() const;
+    double minTimeSeekable() const;
+    double maxTimeSeekable() const;
 
     // Pauses playback without changing any states or generating events
     void setPausedInternal(bool);
 
-    void setPlaybackRateInternal(float);
+    void setPlaybackRateInternal(double);
 
     virtual void mediaCanStart();
 
     void setShouldDelayLoadEvent(bool);
     void invalidateCachedTime();
     void refreshCachedTime() const;
 
     bool hasMediaControls() const;
     bool createMediaControls();
     void configureMediaControls();
@@ skipping 23 matching lines @@
     void updateDisableSleep();
     bool shouldDisableSleep() const;
 #endif
 
     Timer<HTMLMediaElement> m_loadTimer;
     Timer<HTMLMediaElement> m_progressEventTimer;
     Timer<HTMLMediaElement> m_playbackProgressTimer;
     RefPtr<TimeRanges> m_playedTimeRanges;
     OwnPtr<GenericEventQueue> m_asyncEventQueue;
 
-    float m_playbackRate;
-    float m_defaultPlaybackRate;
+    double m_playbackRate;
+    double m_defaultPlaybackRate;
     bool m_webkitPreservesPitch;
     NetworkState m_networkState;
     ReadyState m_readyState;
     ReadyState m_readyStateMaximum;
     KURL m_currentSrc;
 
     RefPtr<MediaError> m_error;
 
-    float m_volume;
-    float m_lastSeekTime;
+    double m_volume;
+    double m_lastSeekTime;
     
     unsigned m_previousProgress;
     double m_previousProgressTime;
 
     // The last time a timeupdate event was sent (wall clock).
     double m_lastTimeUpdateEventWallTime;
 
     // The last time a timeupdate event was sent in movie time.
-    float m_lastTimeUpdateEventMovieTime;
+    double m_lastTimeUpdateEventMovieTime;
     
     // Loading state.
     enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
     LoadState m_loadState;
     RefPtr<HTMLSourceElement> m_currentSourceNode;
     RefPtr<Node> m_nextChildNodeToConsider;
 
     OwnPtr<MediaPlayer> m_player;
 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
     RefPtr<Widget> m_proxyWidget;
 #endif
 
     BehaviorRestrictions m_restrictions;
     
     MediaPlayer::Preload m_preload;
 
     DisplayMode m_displayMode;
 
     // Counter incremented while processing a callback from the media player, so we can avoid
     // calling the media engine recursively.
     int m_processingMediaPlayerCallback;
 
 #if ENABLE(MEDIA_SOURCE)
     RefPtr<MediaSource> m_mediaSource;
 #endif
 
-    mutable float m_cachedTime;
+    mutable double m_cachedTime;
     mutable double m_cachedTimeWallClockUpdateTime;
     mutable double m_minimumWallClockTimeToCacheMediaTime;
 
     double m_fragmentStartTime;
     double m_fragmentEndTime;
 
     typedef unsigned PendingActionFlags;
     PendingActionFlags m_pendingActionFlags;
 
     bool m_playing : 1;
@@ skipping 28 matching lines @@
     bool m_dispatchingCanPlayEvent : 1;
     bool m_loadInitiatedByUserGesture : 1;
     bool m_completelyLoaded : 1;
     bool m_havePreparedToPlay : 1;
     bool m_parsingInProgress : 1;
 
 #if ENABLE(VIDEO_TRACK)
     bool m_tracksAreReady : 1;
     bool m_haveVisibleTextTrack : 1;
     bool m_processingPreferenceChange : 1;
-    float m_lastTextTrackUpdateTime;
+    double m_lastTextTrackUpdateTime;
 
     RefPtr<TextTrackList> m_textTracks;
     Vector<RefPtr<TextTrack> > m_textTracksWhenResourceSelectionBegan;
 
     CueIntervalTree m_cueTree;
 
     CueList m_currentlyActiveCues;
     int m_ignoreTrackDisplayUpdate;
 #endif
 
@@ skipping 52 matching lines @@
 inline HTMLMediaElement* toMediaElement(Node* node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!node || isMediaElement(node));
     return static_cast<HTMLMediaElement*>(node);
 }
 
 } //namespace
 
 #endif
 #endif