Change original WebMediaPlayer signatures from float to double.

webkit/media/webmediaplayer_ms.cc

 // Copyright (c) 2012 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 "webkit/media/webmediaplayer_ms.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 170 matching lines @@
 
 bool WebMediaPlayerMS::supportsSave() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 void WebMediaPlayerMS::seekFloat(float seconds) {
   seek(seconds);
 }
 
-void WebMediaPlayerMS::seek(float seconds) {
+void WebMediaPlayerMS::seek(double seconds) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setEndTimeFloat(float seconds) {
   setEndTime(seconds);
 }
 
-void WebMediaPlayerMS::setEndTime(float seconds) {
+void WebMediaPlayerMS::setEndTime(double seconds) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setRateFloat(float rate) {
   setRate(rate);
 }
 
-void WebMediaPlayerMS::setRate(float rate) {
+void WebMediaPlayerMS::setRate(double rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebMediaPlayerMS::setVolumeFloat(float volume) {
   setVolume(volume);
 }
 
-void WebMediaPlayerMS::setVolume(float volume) {
+void WebMediaPlayerMS::setVolume(double volume) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!audio_renderer_)
     return;
   DVLOG(1) << "WebMediaPlayerMS::setVolume(volume=" << volume << ")";
   audio_renderer_->SetVolume(volume);
 }
 
 void WebMediaPlayerMS::setVisible(bool visible) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
@@ skipping 34 matching lines @@
 
 bool WebMediaPlayerMS::seeking() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
 }
 
 float WebMediaPlayerMS::durationFloat() const {
   return duration();
 }
 
-float WebMediaPlayerMS::duration() const {
+double WebMediaPlayerMS::duration() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return std::numeric_limits<float>::infinity();
+  return std::numeric_limits<double>::infinity();
 }
 
 float WebMediaPlayerMS::currentTimeFloat() const {
   return currentTime();
 }
 
-float WebMediaPlayerMS::currentTime() const {
+double WebMediaPlayerMS::currentTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (current_frame_.get()) {
     return current_frame_->GetTimestamp().InSecondsF();
   } else if (audio_renderer_) {
     return audio_renderer_->GetCurrentRenderTime().InSecondsF();
   }
-  return 0.0f;
+  return 0.0;
 }
 
 int WebMediaPlayerMS::dataRate() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return 0;
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerMS::networkState() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebMediaPlayerMS::networkState, state:" << network_state_;
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerMS::readyState() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebMediaPlayerMS::readyState, state:" << ready_state_;
   return ready_state_;
 }
 
 const WebKit::WebTimeRanges& WebMediaPlayerMS::buffered() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return buffered_;
 }
 
 float WebMediaPlayerMS::maxTimeSeekableFloat() const {
   return maxTimeSeekable();
 }
 
-float WebMediaPlayerMS::maxTimeSeekable() const {
+double WebMediaPlayerMS::maxTimeSeekable() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return 0.0f;
+  return 0.0;
 }
 
 bool WebMediaPlayerMS::didLoadingProgress() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
 }
 
 unsigned long long WebMediaPlayerMS::totalBytes() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return 0;
@@ skipping 32 matching lines @@
 
 WebMediaPlayer::MovieLoadType WebMediaPlayerMS::movieLoadType() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return WebMediaPlayer::MovieLoadTypeUnknown;
 }
 
 float WebMediaPlayerMS::mediaTimeForTimeValueFloat(float timeValue) const {
   return mediaTimeForTimeValue(timeValue);
 }
 
-float WebMediaPlayerMS::mediaTimeForTimeValue(float timeValue) const {
+double WebMediaPlayerMS::mediaTimeForTimeValue(double timeValue) const {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerMS::decodedFrameCount() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebMediaPlayerMS::decodedFrameCount, " << total_frame_count_;
   return total_frame_count_;
 }
 
 unsigned WebMediaPlayerMS::droppedFrameCount() const {
@@ skipping 118 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_media