Switch to double for time calculations using playback rate.

media/blink/buffered_resource_loader.cc

 // Copyright 2013 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 "media/blink/buffered_resource_loader.h"
 
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 36 matching lines @@
 
 // Maximum number of bytes outside the buffer we will wait for in order to
 // fulfill a read. If a read starts more than 2MB away from the data we
 // currently have in the buffer, we will not wait for buffer to reach the read's
 // location and will instead reset the request.
 static const int kForwardWaitThreshold = 2 * kMegabyte;
 
 // Computes the suggested backward and forward capacity for the buffer
 // if one wants to play at |playback_rate| * the natural playback speed.
 // Use a value of 0 for |bitrate| if it is unknown.
-static void ComputeTargetBufferWindow(float playback_rate, int bitrate,
+static void ComputeTargetBufferWindow(double playback_rate, int bitrate,
                                       int* out_backward_capacity,
                                       int* out_forward_capacity) {
   static const int kDefaultBitrate = 200 * 1024 * 8;  // 200 Kbps.
   static const int kMaxBitrate = 20 * kMegabyte * 8;  // 20 Mbps.
-  static const float kMaxPlaybackRate = 25.0;
+  static const double kMaxPlaybackRate = 25.0;
   static const int kTargetSecondsBufferedAhead = 10;
   static const int kTargetSecondsBufferedBehind = 2;
 
   // Use a default bit rate if unknown and clamp to prevent overflow.
   if (bitrate <= 0)
     bitrate = kDefaultBitrate;
   bitrate = std::min(bitrate, kMaxBitrate);
 
   // Only scale the buffer window for playback rates greater than 1.0 in
   // magnitude and clamp to prevent overflow.
   bool backward_playback = false;
-  if (playback_rate < 0.0f) {
+  if (playback_rate < 0.0) {
     backward_playback = true;
-    playback_rate *= -1.0f;
+    playback_rate *= -1.0;
   }
 
-  playback_rate = std::max(playback_rate, 1.0f);
+  playback_rate = std::max(playback_rate, 1.0);
   playback_rate = std::min(playback_rate, kMaxPlaybackRate);
 
   int bytes_per_second = (bitrate / 8.0) * playback_rate;
 
   // Clamp between kMinBufferCapacity and kMaxBufferCapacity.
   *out_forward_capacity = std::max(
       kTargetSecondsBufferedAhead * bytes_per_second, kMinBufferCapacity);
   *out_backward_capacity = std::max(
       kTargetSecondsBufferedBehind * bytes_per_second, kMinBufferCapacity);
 
   *out_forward_capacity = std::min(*out_forward_capacity, kMaxBufferCapacity);
   *out_backward_capacity = std::min(*out_backward_capacity, kMaxBufferCapacity);
 
   if (backward_playback)
     std::swap(*out_forward_capacity, *out_backward_capacity);
 }
 
 BufferedResourceLoader::BufferedResourceLoader(
     const GURL& url,
     CORSMode cors_mode,
     int64 first_byte_position,
     int64 last_byte_position,
     DeferStrategy strategy,
     int bitrate,
-    float playback_rate,
+    double playback_rate,
     MediaLog* media_log)
     : buffer_(kMinBufferCapacity, kMinBufferCapacity),
       loader_failed_(false),
       defer_strategy_(strategy),
       might_be_reused_from_cache_in_future_(true),
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
       cors_mode_(cors_mode),
       first_byte_position_(first_byte_position),
@@ skipping 449 matching lines @@
   return !loader_failed_ && cors_mode_ != kUnspecified;
 }
 
 void BufferedResourceLoader::UpdateDeferStrategy(DeferStrategy strategy) {
   if (!might_be_reused_from_cache_in_future_ && strategy == kNeverDefer)
     strategy = kCapacityDefer;
   defer_strategy_ = strategy;
   UpdateDeferBehavior();
 }
 
-void BufferedResourceLoader::SetPlaybackRate(float playback_rate) {
+void BufferedResourceLoader::SetPlaybackRate(double playback_rate) {
   playback_rate_ = playback_rate;
 
   // This is a pause so don't bother updating the buffer window as we'll likely
   // get unpaused in the future.
   if (playback_rate_ == 0.0)
     return;
 
   // Abort any cancellations in progress if playback starts.
   if (playback_rate_ > 0 && cancel_upon_deferral_)
     cancel_upon_deferral_ = false;
@@ skipping 210 matching lines @@
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
 }  // namespace media