Add xxxFloat() methods to WebMediaPlayer implementations.

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 349 matching lines @@
 bool WebMediaPlayerImpl::supportsFullscreen() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return true;
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return supports_save_;
 }
 
+void WebMediaPlayerImpl::seekFloat(float seconds) {
+  seek(seconds);
+}
+
 void WebMediaPlayerImpl::seek(float seconds) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   if (starting_ || seeking_) {
     pending_seek_ = true;
     pending_seek_seconds_ = seconds;
     if (chunk_demuxer_)
       chunk_demuxer_->CancelPendingSeek();
     return;
   }
@@ skipping 10 matching lines @@
 
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek();
 
   // 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) {
   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) {
   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)
     return;
 
   // Limit rates to reasonable values by clamping.
   if (rate != 0.0f) {
     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) {
   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.
@@ 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();
   }
 
   // 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()));
   }
 
   return static_cast<float>(duration);
 }
 
+float WebMediaPlayerImpl::currentTimeFloat() const {
+  return currentTime();
+}
+
 float WebMediaPlayerImpl::currentTime() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   if (paused_)
     return static_cast<float>(paused_time_.InSecondsF());
   return static_cast<float>(pipeline_->GetMediaTime().InSecondsF());
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
@@ skipping 12 matching lines @@
 }
 
 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();
+}
+
 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())
@@ skipping 58 matching lines @@
 
 WebMediaPlayer::MovieLoadType WebMediaPlayerImpl::movieLoadType() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // 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 {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerImpl::decodedFrameCount() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_frames_decoded;
 }
@@ skipping 586 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media