Misc. cleanup, cc/ edition.

* Inline temps
* Combine conditions
* Use min/max more
* VideoPlaybackRoughnessReporter::kDesiredWindowDuration isn't needed

Bug: none
Change-Id: Ifbe23075f035df50e6bec4299802b6832c15d96b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2359000
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Commit-Queue: vmpstr <vmpstr@chromium.org>
Reviewed-by: vmpstr <vmpstr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798626}

cc/animation/scroll_offset_animation_curve.cc

@@ -294,19 +294,15 @@ void ScrollOffsetAnimationCurve::ApplyAdjustment(
 
 gfx::ScrollOffset ScrollOffsetAnimationCurve::GetValue(
     base::TimeDelta t) const {
-  base::TimeDelta duration = total_animation_duration_ - last_retarget_;
+  const base::TimeDelta duration = total_animation_duration_ - last_retarget_;
   t -= last_retarget_;
 
-  if (duration.is_zero())
+  if (duration.is_zero() || (t >= duration))
     return target_value_;
-
   if (t <= base::TimeDelta())
     return initial_value_;
 
-  if (t >= duration)
-    return target_value_;
-
-  double progress = timing_function_->GetValue(t / duration);
+  const double progress = timing_function_->GetValue(t / duration);
   return gfx::ScrollOffset(
       gfx::Tween::FloatValueBetween(progress, initial_value_.x(),
                                     target_value_.x()),

cc/input/scrollbar_animation_controller.cc

@@ -159,9 +159,8 @@ bool ScrollbarAnimationController::Animate(base::TimeTicks now) {
 
 float ScrollbarAnimationController::AnimationProgressAtTime(
     base::TimeTicks now) {
-  base::TimeDelta delta = now - last_awaken_time_;
-  float progress = delta / fade_duration_;
-  return base::ClampToRange(progress, 0.0f, 1.0f);
+  const base::TimeDelta delta = now - last_awaken_time_;
+  return base::ClampToRange(float{delta / fade_duration_}, 0.0f, 1.0f);
 }
 
 void ScrollbarAnimationController::RunAnimationFrame(float progress) {

cc/input/single_scrollbar_animation_controller_thinning.cc

@@ -98,9 +98,8 @@ float SingleScrollbarAnimationControllerThinning::AnimationProgressAtTime(
   if (thinning_duration_.is_zero())
     return 1.0f;
 
-  base::TimeDelta delta = now - last_awaken_time_;
-  float progress = delta / thinning_duration_;
-  return base::ClampToRange(progress, 0.0f, 1.0f);
+  const base::TimeDelta delta = now - last_awaken_time_;
+  return base::ClampToRange(float{delta / thinning_duration_}, 0.0f, 1.0f);
 }
 
 void SingleScrollbarAnimationControllerThinning::RunAnimationFrame(

cc/input/snap_fling_curve.cc

@@ -81,7 +81,7 @@ double SnapFlingCurve::GetCurrentCurveDistance(base::TimeDelta current_time) {
   const double current_frame = current_time / kFrameTime + 1;
   const double sum =
       first_delta_ * (1 - std::pow(kRatio, current_frame)) / (1 - kRatio);
-  return sum <= total_distance_ ? sum : total_distance_;
+  return std::min(sum, total_distance_);
 }
 
 gfx::Vector2dF SnapFlingCurve::GetScrollDelta(base::TimeTicks time_stamp) {

cc/metrics/video_playback_roughness_reporter.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/numerics/ranges.h"
 #include "base/numerics/safe_conversions.h"
 #include "components/viz/common/quads/compositor_frame_metadata.h"
 
@@ -31,7 +32,6 @@ constexpr int VideoPlaybackRoughnessReporter::kMaxWindowSize;
 constexpr int VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit;
 constexpr int VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit;
 constexpr int VideoPlaybackRoughnessReporter::kPercentileToSubmit;
-constexpr double VideoPlaybackRoughnessReporter::kDesiredWindowDuration;
 
 VideoPlaybackRoughnessReporter::VideoPlaybackRoughnessReporter(
     PlaybackRoughnessReportingCallback reporting_cb)
@@ -73,10 +73,10 @@ void VideoPlaybackRoughnessReporter::FrameSubmitted(
     }
 
     // Adjust frame window size to fit about 1 second of playback
-    int win_size = base::ClampRound(kDesiredWindowDuration *
-                                    info.intended_duration.value().ToHz());
-    frames_window_size_ = std::max(kMinWindowSize, win_size);
-    frames_window_size_ = std::min(frames_window_size_, kMaxWindowSize);
+    const int win_size =
+        base::ClampRound(info.intended_duration.value().ToHz());
+    frames_window_size_ =
+        base::ClampToRange(win_size, kMinWindowSize, kMaxWindowSize);
   }
 
   frames_.push_back(info);

cc/metrics/video_playback_roughness_reporter.h

@@ -81,13 +81,6 @@ class CC_EXPORT VideoPlaybackRoughnessReporter {
   static_assert(kPercentileToSubmit > 0 && kPercentileToSubmit < 100,
                 "invalid percentile value");
 
-  // Desired duration of ConsecutiveFramesWindow in seconds.
-  // This value and the video FPS are being used when calculating actual
-  // number of frames in the ConsecutiveFramesWindow.
-  // kMinWindowSize and kMaxWindowSize put bounds to the window length
-  // and superseed this value.
-  static constexpr double kDesiredWindowDuration = 1.0;
-
  private:
   friend class VideoPlaybackRoughnessReporterTest;
   struct FrameInfo {

cc/test/animation_test_common.cc

@@ -4,6 +4,7 @@
 
 #include "cc/test/animation_test_common.h"
 
+#include <algorithm>
 #include <memory>
 #include <utility>
 
@@ -231,9 +232,7 @@ base::TimeDelta FakeFloatTransition::Duration() const {
 }
 
 float FakeFloatTransition::GetValue(base::TimeDelta time) const {
-  double progress = time / duration_;
-  if (progress >= 1.0)
-    progress = 1.0;
+  const double progress = std::min(time / duration_, 1.0);
   return (1.0 - progress) * from_ + progress * to_;
 }