Change original WebMediaPlayer signatures from float to double.

webkit/media/webmediaplayer_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 63 matching lines @@
 // the time bar. For really high speeds, audio becomes a bottleneck and we just
 // use up the data we have, which may not achieve the speed requested, but will
 // not crash the tab.
 //
 // A very slow speed, ie 0.00000001x, causes the machine to lock up. (It seems
 // like a busy loop). It gets unresponsive, although its not completely dead.
 //
 // Also our timers are not very accurate (especially for ogg), which becomes
 // evident at low speeds and on Vista. Since other speeds are risky and outside
 // the norms, we think 1/16x to 16x is a safe and useful range for now.
-const float kMinRate = 0.0625f;
-const float kMaxRate = 16.0f;
+const double kMinRate = 0.0625;
+const double kMaxRate = 16.0;
 
 // Prefix for histograms related to Encrypted Media Extensions.
 const char* kMediaEme = "Media.EME.";
 }  // namespace
 
 namespace webkit_media {
 
 #define COMPILE_ASSERT_MATCHING_ENUM(name) \
   COMPILE_ASSERT(static_cast<int>(WebMediaPlayer::CORSMode ## name) == \
                  static_cast<int>(BufferedResourceLoader::k ## name), \
@@ skipping 272 matching lines @@
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seekFloat(float seconds) {
   seek(seconds);
 }
 
-void WebMediaPlayerImpl::seek(float seconds) {
+void WebMediaPlayerImpl::seek(double seconds) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (starting_ || seeking_) {
     pending_seek_ = true;
     pending_seek_seconds_ = seconds;
     if (chunk_demuxer_)
       chunk_demuxer_->CancelPendingSeek();
     return;
   }
 
@@ skipping 13 matching lines @@
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek));
 }
 
 void WebMediaPlayerImpl::setEndTimeFloat(float seconds) {
   setEndTime(seconds);
 }
 
-void WebMediaPlayerImpl::setEndTime(float seconds) {
+void WebMediaPlayerImpl::setEndTime(double seconds) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): add method call when it has been implemented.
   return;
 }
 
 void WebMediaPlayerImpl::setRateFloat(float rate) {
   setRate(rate);
 }
 
-void WebMediaPlayerImpl::setRate(float rate) {
+void WebMediaPlayerImpl::setRate(double rate) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(kylep): Remove when support for negatives is added. Also, modify the
   // following checks so rewind uses reasonable values also.
-  if (rate < 0.0f)
+  if (rate < 0.0)
     return;
 
   // Limit rates to reasonable values by clamping.
-  if (rate != 0.0f) {
+  if (rate != 0.0) {
     if (rate < kMinRate)
       rate = kMinRate;
     else if (rate > kMaxRate)
       rate = kMaxRate;
   }
 
   playback_rate_ = rate;
   if (!paused_) {
     pipeline_->SetPlaybackRate(rate);
   }
 }
 
 void WebMediaPlayerImpl::setVolumeFloat(float volume) {
   setVolume(volume);
 }
 
-void WebMediaPlayerImpl::setVolume(float volume) {
+void WebMediaPlayerImpl::setVolume(double volume) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   pipeline_->SetVolume(volume);
 }
 
 void WebMediaPlayerImpl::setVisible(bool visible) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): add appropriate method call when pipeline has it implemented.
   return;
@@ skipping 50 matching lines @@
 bool WebMediaPlayerImpl::seeking() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return false;
 
   return seeking_;
 }
 
 float WebMediaPlayerImpl::durationFloat() const {
-  return duration();
-}
-
-float WebMediaPlayerImpl::duration() const {
-  DCHECK(main_loop_->BelongsToCurrentThread());
-
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return std::numeric_limits<float>::quiet_NaN();
 
-  double duration;
-  if (chunk_demuxer_) {
-    duration = chunk_demuxer_->GetDuration();
-  } else {
-    duration = GetPipelineDuration();
-  }
+  double result = duration();
 
   // Make sure super small durations don't get truncated to 0 and
   // large durations don't get converted to infinity by the double -> float
   // conversion.
   //
   // TODO(acolwell): Remove when WebKit is changed to report duration as a
   // double.
-  if (duration > 0.0 && duration < std::numeric_limits<double>::infinity()) {
-    duration = std::max(duration,
-                        static_cast<double>(std::numeric_limits<float>::min()));
-    duration = std::min(duration,
-                        static_cast<double>(std::numeric_limits<float>::max()));
+  if (result > 0.0 && result < std::numeric_limits<double>::infinity()) {
+    result = std::max(result,
+                      static_cast<double>(std::numeric_limits<float>::min()));
+    result = std::min(result,
+                      static_cast<double>(std::numeric_limits<float>::max()));
   }
 
-  return static_cast<float>(duration);
+  return static_cast<float>(result);
+
+}
+
+double WebMediaPlayerImpl::duration() const {
+  DCHECK(main_loop_->BelongsToCurrentThread());
+
+  if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
+    return std::numeric_limits<double>::quiet_NaN();
+
+  if (chunk_demuxer_)
+    return chunk_demuxer_->GetDuration();
+
+  return GetPipelineDuration();
 }
 
 float WebMediaPlayerImpl::currentTimeFloat() const {
-  return currentTime();
+  return static_cast<float>(currentTime());
 }
 
-float WebMediaPlayerImpl::currentTime() const {
+double WebMediaPlayerImpl::currentTime() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   if (paused_)
-    return static_cast<float>(paused_time_.InSecondsF());
-  return static_cast<float>(pipeline_->GetMediaTime().InSecondsF());
+    return paused_time_.InSecondsF();

[DaleCurtis, 2013/04/16 01:19:48]

If you're so inclined: 
return (paused_ ? paused_time_ : pipeline_->GetMediaTime()).InSecondsF()

[acolwell GONE FROM CHROMIUM, 2013/04/16 16:58:15]

Done.

+  return pipeline_->GetMediaTime().InSecondsF();
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return ready_state_;
 }
 
 const WebKit::WebTimeRanges& WebMediaPlayerImpl::buffered() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   WebKit::WebTimeRanges web_ranges(
       ConvertToWebTimeRanges(pipeline_->GetBufferedTimeRanges()));
   buffered_.swap(web_ranges);
   return buffered_;
 }
 
 float WebMediaPlayerImpl::maxTimeSeekableFloat() const {
-  return maxTimeSeekable();

[DaleCurtis, 2013/04/16 01:19:48]

How come?

[acolwell GONE FROM CHROMIUM, 2013/04/16 16:58:15]

durationFloat() needs to be used in this version now that the truncation of the
double range to floats only exists in that function. I just duplicated the
function body for right now and changed the duration() call at the end to
durationFloat().

-}
-
-float WebMediaPlayerImpl::maxTimeSeekable() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // If we haven't even gotten to ReadyStateHaveMetadata yet then just
   // return 0 so that the seekable range is empty.
   if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
     return 0.0f;
 
   // We don't support seeking in streaming media.
   if (data_source_ && data_source_->IsStreaming())
     return 0.0f;
+  return durationFloat();
+}
+
+double WebMediaPlayerImpl::maxTimeSeekable() const {
+  DCHECK(main_loop_->BelongsToCurrentThread());
+
+  // If we haven't even gotten to ReadyStateHaveMetadata yet then just
+  // return 0 so that the seekable range is empty.
+  if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
+    return 0.0;
+
+  // We don't support seeking in streaming media.
+  if (data_source_ && data_source_->IsStreaming())
+    return 0.0;
   return duration();
 }
 
 bool WebMediaPlayerImpl::didLoadingProgress() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return pipeline_->DidLoadingProgress();
 }
 
 unsigned long long WebMediaPlayerImpl::totalBytes() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
@@ skipping 51 matching lines @@
   // Disable seeking while streaming.
   if (data_source_ && data_source_->IsStreaming())
     return WebMediaPlayer::MovieLoadTypeLiveStream;
   return WebMediaPlayer::MovieLoadTypeUnknown;
 }
 
 float WebMediaPlayerImpl::mediaTimeForTimeValueFloat(float timeValue) const {
   return mediaTimeForTimeValue(timeValue);
 }
 
-float WebMediaPlayerImpl::mediaTimeForTimeValue(float timeValue) const {
+double WebMediaPlayerImpl::mediaTimeForTimeValue(double timeValue) const {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerImpl::decodedFrameCount() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_frames_decoded;
 }
 
@@ skipping 585 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media