1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104


content / browser / navigation_transitions / progress_bar.cc [blame]

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/navigation_transitions/progress_bar.h"

#include "ui/android/progress_bar_config.h"

namespace content {

ProgressBar::ProgressBar(int width_physical,
                         const ui::ProgressBarConfig& config)
    : width_physical_(width_physical),
      height_physical_(config.height_physical),
      background_layer_(cc::slim::SolidColorLayer::Create()),
      first_pulse_layer_(cc::slim::SolidColorLayer::Create()),
      second_pulse_layer_(cc::slim::SolidColorLayer::Create()),
      hairline_layer_(cc::slim::SolidColorLayer::Create()) {
  background_layer_->SetBackgroundColor(config.background_color);
  background_layer_->SetIsDrawable(true);
  background_layer_->SetBounds(
      gfx::Size(width_physical_, config.height_physical));

  first_pulse_layer_->SetBackgroundColor(config.color);
  first_pulse_layer_->SetIsDrawable(true);
  background_layer_->AddChild(first_pulse_layer_);

  second_pulse_layer_->SetBackgroundColor(config.color);
  second_pulse_layer_->SetIsDrawable(true);
  background_layer_->AddChild(second_pulse_layer_);

  hairline_layer_->SetBackgroundColor(config.hairline_color);
  hairline_layer_->SetIsDrawable(true);
  hairline_layer_->SetBounds(
      gfx::Size(width_physical_, config.hairline_height_physical));
  hairline_layer_->SetPosition(gfx::PointF(0, config.height_physical));

  SetupAnimation();
}

ProgressBar::~ProgressBar() = default;

scoped_refptr<cc::slim::Layer> ProgressBar::GetLayer() const {
  return background_layer_;
}

void ProgressBar::Animate(base::TimeTicks frame_begin_time) {
  CHECK(!effect_.keyframe_models().empty());
  effect_.Tick(frame_begin_time);

  // The first pulse fires off at the beginning of the animation.
  float left =
      width_physical_ * static_cast<float>(pow(current_value_, 1.5f) - 0.5f);
  float right = width_physical_ * current_value_;
  // TODO(bokan/khushalsagar): This needs to account for RTL.
  first_pulse_layer_->SetBounds(gfx::Size(right - left, height_physical_));
  first_pulse_layer_->SetPosition(gfx::PointF(left, 0));

  // The second pulse fires off at some point after the first pulse has been
  // fired.
  constexpr float kSecondPulseStart = 1.1f;
  constexpr float kSecondPulseLength = 1.0f;
  if (current_value_ >= kSecondPulseStart) {
    float percentage =
        (current_value_ - kSecondPulseStart) / kSecondPulseLength;
    left = width_physical_ * static_cast<float>(pow(percentage, 2.5f) - 0.1f);
    right = width_physical_ * percentage;
    second_pulse_layer_->SetBounds(gfx::Size(right - left, height_physical_));
    second_pulse_layer_->SetPosition(gfx::PointF(left, 0));
  } else {
    second_pulse_layer_->SetBounds(gfx::Size(0, 0));
  }
}

void ProgressBar::SetupAnimation() {
  constexpr float kStartValue = 0.f;
  constexpr float kEndValue = 3.f;
  constexpr base::TimeDelta kDuration = base::Milliseconds(3000);

  auto curve = gfx::KeyframedFloatAnimationCurve::Create();
  curve->AddKeyframe(gfx::FloatKeyframe::Create(/*time=*/base::TimeDelta(),
                                                /*value=*/kStartValue,
                                                /*timing_function=*/nullptr));
  curve->AddKeyframe(gfx::FloatKeyframe::Create(/*time=*/kDuration,
                                                /*value=*/kEndValue,
                                                /*timing_function=*/nullptr));
  curve->set_target(this);

  auto model = gfx::KeyframeModel::Create(
      /*curve=*/std::move(curve),
      /*keyframe_model_id=*/effect_.GetNextKeyframeModelId(),
      /*target_property_id=*/1);
  model->set_iterations(std::numeric_limits<double>::infinity());

  effect_.AddKeyframeModel(std::move(model));
}

void ProgressBar::OnFloatAnimated(const float& value,
                                  int target_property_id,
                                  gfx::KeyframeModel* keyframe_model) {
  current_value_ = value;
}

}  // namespace content