BASELINE: Update Chromium to 74.0.3729.159

Change-Id: I8d2497da544c275415aedd94dd25328d555de811
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

47 files changed, 419 insertions, 306 deletions

diff --git a/chromium/third_party/blink/renderer/core/animation/README.md b/chromium/third_party/blink/renderer/core/animation/README.md
index 9481e72d44f..52b8e83bfee 100644
--- a/chromium/third_party/blink/renderer/core/animation/README.md
+++ b/chromium/third_party/blink/renderer/core/animation/README.md
@@ -68,7 +68,7 @@ The Blink animation engine interacts with Blink/Chrome in the following ways:
     Whether or not an animation can be accelerated is determined by
     [CheckCanStartAnimationOnCompositor()][] which looks at several aspects
     such as the composite mode, other animations affecting same property, and
-    whether the target element can be promoted and mutated in compositor.  
+    whether the target element can be promoted and mutated in compositor.
     Reasons for not compositing animations are captured in [FailureCodes][].
 
     #### Lifetime of a compositor animation
@@ -89,7 +89,11 @@ The Blink animation engine interacts with Blink/Chrome in the following ways:
     animation updates the visuals the main thread animation updates the computed
     style. There is a special case logic to ensure updates from such accelerated
     animations do not cause spurious commits from main to compositor (See
-    [CompositedLayerMapping::UpdateGraphicsLayerGeometry()][])
+    [CompositedLayerMapping::UpdateGraphicsLayerGeometry()][], or
+    [FragmentPaintPropertyTreeBuilder::UpdateTransform()][],
+    [FragmentPaintPropertyTreeBuilder::UpdateEffect()][], and
+    [FragmentPaintPropertyTreeBuilder::UpdateFilter()][] for
+    [BlinkGenPropertyTrees mode][])
 
     A compositor animation provides updates on its playback state changes (e.g.,
     on start, finish, abort) to its blink counterpart via
@@ -105,6 +109,10 @@ The Blink animation engine interacts with Blink/Chrome in the following ways:
 [Animation::PreCommit()]: https://cs.chromium.org/search/?q=file:animation.h+function:PreCommit
 [CompositorAnimationDelegate]: https://cs.chromium.org/search/?q=file:compositor_animation_delegate.h
 [CompositedLayerMapping::UpdateGraphicsLayerGeometry()]: https://cs.chromium.org/search/?q=file:composited_layer_mapping.h+function:UpdateGraphicsLayerGeometry
+[FragmentPaintPropertyTreeBuilder::UpdateTransform()]: https://cs.chromium.org/search/?q=class:FragmentPaintPropertyTreeBuilder+function:UpdateTransform
+[FragmentPaintPropertyTreeBuilder::UpdateEffect()]: https://cs.chromium.org/search/?q=class:FragmentPaintPropertyTreeBuilder+function:UpdateEffect
+[FragmentPaintPropertyTreeBuilder::UpdateFilter()]: https://cs.chromium.org/search/?q=class:FragmentPaintPropertyTreeBuilder+function:UpdateFilter
+[BlinkGenPropertyTrees mode]: https://chromium.googlesource.com/chromium/src/+/HEAD/third_party/blink/renderer/core/paint/README.md
 
 *   ### Javascript
 
@@ -238,8 +246,8 @@ other specs (for example Javascript callback based effects).
 *   __[KeyframeEffect][]__ represents the effect an animation has (without any
     details of when it started or whether it's playing) and is comprised of
     three things:
-    *   Some __[Timing][]__ information (inherited from [AnimationEffect][]).  
-        [Example](http://jsbin.com/nuyohulojo/edit?js,output):  
+    *   Some __[Timing][]__ information (inherited from [AnimationEffect][]).
+        [Example](http://jsbin.com/nuyohulojo/edit?js,output):
         ```javascript
         {
           duration: 4000,
@@ -256,8 +264,8 @@ other specs (for example Javascript callback based effects).
 
     *   A __[KeyframeEffectModel][]__ that holds a sequence of keyframes to
         specify the properties being animated and what values they pass
-        through.  
-        [Example](http://jsbin.com/wiyefaxiru/1/edit?js,output):  
+        through.
+        [Example](http://jsbin.com/wiyefaxiru/1/edit?js,output):
         ```javascript
         [
           {backgroundColor: 'red', transform: 'rotate(0deg)'},
@@ -275,7 +283,7 @@ other specs (for example Javascript callback based effects).
         *   An __[InterpolationEffect][]__ which holds a set of
             [Interpolation][]s, each one representing the animated values
             between adjacent pairs of [PropertySpecificKeyframe][]s, and where
-            in the percentage progress they are active.  
+            in the percentage progress they are active.
             In the example keyframes above the [Interpolations][] generated
             would include, among the 5 different property specific keyframe
             pairs, one for `backgroundColor: 'red'` to
diff --git a/chromium/third_party/blink/renderer/core/animation/animation.cc b/chromium/third_party/blink/renderer/core/animation/animation.cc
index 7dad569a20d..b9e28da1d5a 100644
--- a/chromium/third_party/blink/renderer/core/animation/animation.cc
+++ b/chromium/third_party/blink/renderer/core/animation/animation.cc
@@ -142,7 +142,7 @@ Animation::Animation(ExecutionContext* execution_context,
     }
     content_->Attach(this);
   }
-  probe::didCreateAnimation(timeline_->GetDocument(), sequence_number_);
+  probe::DidCreateAnimation(timeline_->GetDocument(), sequence_number_);
 }
 
 Animation::~Animation() {
@@ -865,7 +865,7 @@ void Animation::StartAnimationOnCompositor(
   base::Optional<double> start_time = base::nullopt;
   double time_offset = 0;
   if (start_time_) {
-    start_time = TimeTicksInSeconds(TimelineInternal()->ZeroTime()) +
+    start_time = TimelineInternal()->ZeroTime().since_origin().InSecondsF() +
                  start_time_.value();
     if (reversed)
       start_time = start_time.value() - (EffectEnd() / fabs(playback_rate_));
@@ -1222,7 +1222,7 @@ Animation::PlayStateUpdateScope::~PlayStateUpdateScope() {
   animation_->EndUpdatingState();
 
   if (old_play_state != new_play_state) {
-    probe::animationPlayStateChanged(
+    probe::AnimationPlayStateChanged(
         animation_->TimelineInternal()->GetDocument(), animation_,
         old_play_state, new_play_state);
   }
diff --git a/chromium/third_party/blink/renderer/core/animation/animation.h b/chromium/third_party/blink/renderer/core/animation/animation.h
index c4a6db7c401..d42c992d08d 100644
--- a/chromium/third_party/blink/renderer/core/animation/animation.h
+++ b/chromium/third_party/blink/renderer/core/animation/animation.h
@@ -45,9 +45,9 @@
 #include "third_party/blink/renderer/core/animation/document_timeline.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/css/css_property_names.h"
-#include "third_party/blink/renderer/core/dom/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/core/dom/events/event_target.h"
+#include "third_party/blink/renderer/core/execution_context/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/platform/animation/compositor_animation_client.h"
 #include "third_party/blink/renderer/platform/animation/compositor_animation_delegate.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
@@ -145,8 +145,8 @@ class CORE_EXPORT Animation final : public EventTargetWithInlineData,
   bool Limited() const { return Limited(CurrentTimeInternal()); }
   bool FinishedInternal() const { return finished_; }
 
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(finish, kFinish);
-  DEFINE_ATTRIBUTE_EVENT_LISTENER(cancel, kCancel);
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(finish, kFinish)
+  DEFINE_ATTRIBUTE_EVENT_LISTENER(cancel, kCancel)
 
   const AtomicString& InterfaceName() const override;
   ExecutionContext* GetExecutionContext() const override;
diff --git a/chromium/third_party/blink/renderer/core/animation/animation_effect.cc b/chromium/third_party/blink/renderer/core/animation/animation_effect.cc
index ffd0a17316a..44892999bfb 100644
--- a/chromium/third_party/blink/renderer/core/animation/animation_effect.cc
+++ b/chromium/third_party/blink/renderer/core/animation/animation_effect.cc
@@ -267,10 +267,17 @@ void AnimationEffect::UpdateInheritedTime(double inherited_time,
           current_iteration, kLocalIterationDuration, iteration_time, timing_);
     }
 
+    const bool was_canceled = current_phase != calculated_.phase &&
+                              current_phase == AnimationEffect::kPhaseNone;
+    calculated_.phase = current_phase;
+    // If the animation was canceled, we need to fire the event condition before
+    // updating the timing so that the cancelation time can be determined.
+    if (was_canceled && event_delegate_)
+      event_delegate_->OnEventCondition(*this);
+
     calculated_.current_iteration = current_iteration;
     calculated_.progress = progress;
 
-    calculated_.phase = current_phase;
     calculated_.is_in_effect = !IsNull(active_time);
     calculated_.is_in_play = GetPhase() == kPhaseActive;
     calculated_.is_current = GetPhase() == kPhaseBefore || IsInPlay();
diff --git a/chromium/third_party/blink/renderer/core/animation/animation_input_helpers.cc b/chromium/third_party/blink/renderer/core/animation/animation_input_helpers.cc
index 557ed22d95e..dd479937cdf 100644
--- a/chromium/third_party/blink/renderer/core/animation/animation_input_helpers.cc
+++ b/chromium/third_party/blink/renderer/core/animation/animation_input_helpers.cc
@@ -264,8 +264,7 @@ scoped_refptr<TimingFunction> AnimationInputHelpers::ParseTimingFunction(
     exception_state.ThrowTypeError("Easing may not be set to a list of values");
     return nullptr;
   }
-  return CSSToStyleMap::MapAnimationTimingFunction(value_list->Item(0), true,
-                                                   document);
+  return CSSToStyleMap::MapAnimationTimingFunction(value_list->Item(0));
 }
 
 String AnimationInputHelpers::PropertyHandleToKeyframeAttribute(
diff --git a/chromium/third_party/blink/renderer/core/animation/animation_input_helpers_test.cc b/chromium/third_party/blink/renderer/core/animation/animation_input_helpers_test.cc
index 77fd3ef5044..da179987d18 100644
--- a/chromium/third_party/blink/renderer/core/animation/animation_input_helpers_test.cc
+++ b/chromium/third_party/blink/renderer/core/animation/animation_input_helpers_test.cc
@@ -134,16 +134,11 @@ TEST_F(AnimationAnimationInputHelpersTest, ParseAnimationTimingFunction) {
 
   EXPECT_EQ("steps(1, start)",
             ParseTimingFunction("step-start", exception_state)->ToString());
-  EXPECT_EQ("steps(1, middle)",
-            ParseTimingFunction("step-middle", exception_state)->ToString());
   EXPECT_EQ("steps(1)",
             ParseTimingFunction("step-end", exception_state)->ToString());
   EXPECT_EQ(
       "steps(3, start)",
       ParseTimingFunction("steps(3, start)", exception_state)->ToString());
-  EXPECT_EQ(
-      "steps(3, middle)",
-      ParseTimingFunction("steps(3, middle)", exception_state)->ToString());
   EXPECT_EQ("steps(3)",
             ParseTimingFunction("steps(3, end)", exception_state)->ToString());
   EXPECT_EQ("steps(3)",
diff --git a/chromium/third_party/blink/renderer/core/animation/basic_shape_interpolation_functions.cc b/chromium/third_party/blink/renderer/core/animation/basic_shape_interpolation_functions.cc
index 8a077911c48..ee5cb16555c 100644
--- a/chromium/third_party/blink/renderer/core/animation/basic_shape_interpolation_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/basic_shape_interpolation_functions.cc
@@ -83,8 +83,8 @@ std::unique_ptr<InterpolableValue> ConvertCSSCoordinate(
     return Unwrap(
         CSSPositionAxisListInterpolationType::ConvertPositionAxisCSSValue(
             *coordinate));
-  return Unwrap(LengthInterpolationFunctions::MaybeConvertLength(
-      Length(50, kPercent), 1));
+  return Unwrap(
+      LengthInterpolationFunctions::MaybeConvertLength(Length::Percent(50), 1));
 }
 
 std::unique_ptr<InterpolableValue> ConvertCoordinate(
diff --git a/chromium/third_party/blink/renderer/core/animation/compositor_animations.h b/chromium/third_party/blink/renderer/core/animation/compositor_animations.h
index 84413c1043a..a0cf3f06059 100644
--- a/chromium/third_party/blink/renderer/core/animation/compositor_animations.h
+++ b/chromium/third_party/blink/renderer/core/animation/compositor_animations.h
@@ -158,6 +158,8 @@ class CORE_EXPORT CompositorAnimations {
                            CannotStartElementOnCompositorEffectSVG);
   FRIEND_TEST_ALL_PREFIXES(AnimationCompositorAnimationsTest,
                            CancelIncompatibleCompositorAnimations);
+  FRIEND_TEST_ALL_PREFIXES(AnimationCompositorAnimationsTest,
+                           NonAnimatedTransformPropertyChangeGetsUpdated);
 };
 
 }  // namespace blink
diff --git a/chromium/third_party/blink/renderer/core/animation/compositor_animations_test.cc b/chromium/third_party/blink/renderer/core/animation/compositor_animations_test.cc
index d27d062cf5f..88255ce836c 100644
--- a/chromium/third_party/blink/renderer/core/animation/compositor_animations_test.cc
+++ b/chromium/third_party/blink/renderer/core/animation/compositor_animations_test.cc
@@ -36,6 +36,8 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_refptr.h"
+#include "cc/animation/animation_host.h"
+#include "cc/layers/picture_layer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/web/web_settings.h"
 #include "third_party/blink/renderer/core/animation/animatable/animatable_double.h"
@@ -52,13 +54,13 @@
 #include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
 #include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
 #include "third_party/blink/renderer/core/layout/layout_object.h"
+#include "third_party/blink/renderer/core/paint/compositing/composited_layer_mapping.h"
 #include "third_party/blink/renderer/core/paint/object_paint_properties.h"
 #include "third_party/blink/renderer/core/paint/paint_layer.h"
 #include "third_party/blink/renderer/core/style/computed_style.h"
 #include "third_party/blink/renderer/core/style/filter_operations.h"
 #include "third_party/blink/renderer/core/testing/core_unit_test_helper.h"
 #include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
-#include "third_party/blink/renderer/platform/animation/compositor_animation_host.h"
 #include "third_party/blink/renderer/platform/animation/compositor_float_animation_curve.h"
 #include "third_party/blink/renderer/platform/animation/compositor_float_keyframe.h"
 #include "third_party/blink/renderer/platform/animation/compositor_keyframe_model.h"
@@ -465,7 +467,7 @@ class AnimationCompositorAnimationsTest : public RenderingTest {
 
   void BeginFrame() {
     helper_.GetWebView()->MainFrameWidget()->BeginFrame(
-        WTF::CurrentTimeTicks());
+        WTF::CurrentTimeTicks(), false /* record_main_frame_metrics */);
   }
 
   void ForceFullCompositingUpdate() {
@@ -1828,7 +1830,7 @@ TEST_F(AnimationCompositorAnimationsTest,
 TEST_F(AnimationCompositorAnimationsTest, TrackRafAnimation) {
   LoadTestData("raf-countdown.html");
 
-  CompositorAnimationHost* host =
+  cc::AnimationHost* host =
       GetFrame()->GetDocument()->View()->GetCompositorAnimationHost();
 
   // The test file registers two rAF 'animations'; one which ends after 5
@@ -1836,36 +1838,36 @@ TEST_F(AnimationCompositorAnimationsTest, TrackRafAnimation) {
   for (int i = 0; i < 9; i++) {
     BeginFrame();
     ForceFullCompositingUpdate();
-    EXPECT_TRUE(host->CurrentFrameHadRAFForTesting());
-    EXPECT_TRUE(host->NextFrameHasPendingRAFForTesting());
+    EXPECT_TRUE(host->CurrentFrameHadRAF());
+    EXPECT_TRUE(host->NextFrameHasPendingRAF());
   }
 
   // On the 10th iteration, there should be a current rAF, but no more pending
   // rAFs.
   BeginFrame();
   ForceFullCompositingUpdate();
-  EXPECT_TRUE(host->CurrentFrameHadRAFForTesting());
-  EXPECT_FALSE(host->NextFrameHasPendingRAFForTesting());
+  EXPECT_TRUE(host->CurrentFrameHadRAF());
+  EXPECT_FALSE(host->NextFrameHasPendingRAF());
 
   // On the 11th iteration, there should be no more rAFs firing.
   BeginFrame();
   ForceFullCompositingUpdate();
-  EXPECT_FALSE(host->CurrentFrameHadRAFForTesting());
-  EXPECT_FALSE(host->NextFrameHasPendingRAFForTesting());
+  EXPECT_FALSE(host->CurrentFrameHadRAF());
+  EXPECT_FALSE(host->NextFrameHasPendingRAF());
 }
 
 TEST_F(AnimationCompositorAnimationsTest, TrackRafAnimationTimeout) {
   LoadTestData("raf-timeout.html");
 
-  CompositorAnimationHost* host =
+  cc::AnimationHost* host =
       GetFrame()->GetDocument()->View()->GetCompositorAnimationHost();
 
   // The test file executes a rAF, which fires a setTimeout for the next rAF.
   // Even with setTimeout(func, 0), the next rAF is not considered pending.
   BeginFrame();
   ForceFullCompositingUpdate();
-  EXPECT_TRUE(host->CurrentFrameHadRAFForTesting());
-  EXPECT_FALSE(host->NextFrameHasPendingRAFForTesting());
+  EXPECT_TRUE(host->CurrentFrameHadRAF());
+  EXPECT_FALSE(host->NextFrameHasPendingRAF());
 }
 
 TEST_F(AnimationCompositorAnimationsTest, TrackRafAnimationNoneRegistered) {
@@ -1877,16 +1879,16 @@ TEST_F(AnimationCompositorAnimationsTest, TrackRafAnimationNoneRegistered) {
   ForceFullCompositingUpdate();
 
   // The HTML does not have any rAFs.
-  CompositorAnimationHost* host =
+  cc::AnimationHost* host =
       GetFrame()->GetDocument()->View()->GetCompositorAnimationHost();
-  EXPECT_FALSE(host->CurrentFrameHadRAFForTesting());
-  EXPECT_FALSE(host->NextFrameHasPendingRAFForTesting());
+  EXPECT_FALSE(host->CurrentFrameHadRAF());
+  EXPECT_FALSE(host->NextFrameHasPendingRAF());
 
   // And still shouldn't after another frame.
   BeginFrame();
   ForceFullCompositingUpdate();
-  EXPECT_FALSE(host->CurrentFrameHadRAFForTesting());
-  EXPECT_FALSE(host->NextFrameHasPendingRAFForTesting());
+  EXPECT_FALSE(host->CurrentFrameHadRAF());
+  EXPECT_FALSE(host->NextFrameHasPendingRAF());
 }
 
 TEST_F(AnimationCompositorAnimationsTest, CanStartElementOnCompositorEffect) {
@@ -1901,10 +1903,54 @@ TEST_F(AnimationCompositorAnimationsTest, CanStartElementOnCompositorEffect) {
       CompositorAnimations::CheckCanStartElementOnCompositor(*target);
   EXPECT_EQ(code, CompositorAnimations::FailureCode::None());
   EXPECT_EQ(document->Timeline().PendingAnimationsCount(), 1u);
-  CompositorAnimationHost* host =
-      document->View()->GetCompositorAnimationHost();
-  EXPECT_EQ(host->GetMainThreadAnimationsCountForTesting(), 0u);
-  EXPECT_EQ(host->GetCompositedAnimationsCountForTesting(), 1u);
+  cc::AnimationHost* host = document->View()->GetCompositorAnimationHost();
+  EXPECT_EQ(host->MainThreadAnimationsCount(), 0u);
+  EXPECT_EQ(host->CompositedAnimationsCount(), 1u);
+}
+
+TEST_F(AnimationCompositorAnimationsTest,
+       NonAnimatedTransformPropertyChangeGetsUpdated) {
+  LoadTestData("transform-animation-update.html");
+  Document* document = GetFrame()->GetDocument();
+  Element* target = document->getElementById("target");
+  const ObjectPaintProperties* properties =
+      target->GetLayoutObject()->FirstFragment().PaintProperties();
+  ASSERT_NE(nullptr, properties);
+  const auto* transform = properties->Transform();
+  ASSERT_NE(nullptr, transform);
+  // Make sure composited animation is running on #target.
+  if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled())
+    EXPECT_TRUE(transform->HasDirectCompositingReasons());
+  CompositorAnimations::FailureCode code =
+      CompositorAnimations::CheckCanStartElementOnCompositor(*target);
+  EXPECT_EQ(code, CompositorAnimations::FailureCode::None());
+  EXPECT_EQ(document->Timeline().PendingAnimationsCount(), 1u);
+  cc::AnimationHost* host = document->View()->GetCompositorAnimationHost();
+  EXPECT_EQ(host->MainThreadAnimationsCount(), 0u);
+  EXPECT_EQ(host->CompositedAnimationsCount(), 1u);
+  // Make sure the backface-visibility is correctly set, both in blink and on
+  // the cc::Layer.
+  EXPECT_FALSE(transform->Matrix().IsIdentity());  // Rotated
+  EXPECT_EQ(transform->GetBackfaceVisibility(),
+            TransformPaintPropertyNode::BackfaceVisibility::kVisible);
+  const CompositedLayerMapping* composited_layer_mapping =
+      ToLayoutBoxModelObject(target->GetLayoutObject())
+          ->Layer()
+          ->GetCompositedLayerMapping();
+  ASSERT_NE(nullptr, composited_layer_mapping);
+  const cc::PictureLayer* layer =
+      composited_layer_mapping->MainGraphicsLayer()->CcLayer();
+  ASSERT_NE(nullptr, layer);
+  EXPECT_TRUE(layer->double_sided());
+  // Change the backface visibility, while the compositor animation is
+  // happening.
+  target->setAttribute(html_names::kClassAttr, "backface-hidden");
+  ForceFullCompositingUpdate();
+  // Make sure the setting made it to both blink and all the way to CC.
+  EXPECT_EQ(transform->GetBackfaceVisibility(),
+            TransformPaintPropertyNode::BackfaceVisibility::kHidden);
+  EXPECT_FALSE(layer->double_sided())
+      << "Change to hidden did not get propagated to CC";
 }
 
 // Regression test for https://crbug.com/781305. When we have a transform
@@ -1920,10 +1966,9 @@ TEST_F(AnimationCompositorAnimationsTest,
   EXPECT_EQ(code, CompositorAnimations::FailureCode::NonActionable(
                       "Element does not paint into own backing"));
   EXPECT_EQ(document->Timeline().PendingAnimationsCount(), 4u);
-  CompositorAnimationHost* host =
-      document->View()->GetCompositorAnimationHost();
-  EXPECT_EQ(host->GetMainThreadAnimationsCountForTesting(), 4u);
-  EXPECT_EQ(host->GetCompositedAnimationsCountForTesting(), 0u);
+  cc::AnimationHost* host = document->View()->GetCompositorAnimationHost();
+  EXPECT_EQ(host->MainThreadAnimationsCount(), 4u);
+  EXPECT_EQ(host->CompositedAnimationsCount(), 0u);
 }
 
 }  // namespace blink
diff --git a/chromium/third_party/blink/renderer/core/animation/css/css_animation_update.h b/chromium/third_party/blink/renderer/core/animation/css/css_animation_update.h
index 21d53493f3c..d0f764557c6 100644
--- a/chromium/third_party/blink/renderer/core/animation/css/css_animation_update.h
+++ b/chromium/third_party/blink/renderer/core/animation/css/css_animation_update.h
@@ -90,8 +90,8 @@ class UpdatedCSSAnimation {
 
 }  // namespace blink
 
-WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::NewCSSAnimation);
-WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::UpdatedCSSAnimation);
+WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::NewCSSAnimation)
+WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::UpdatedCSSAnimation)
 
 namespace blink {
 
diff --git a/chromium/third_party/blink/renderer/core/animation/css/css_animations.cc b/chromium/third_party/blink/renderer/core/animation/css/css_animations.cc
index a8bdb4b5871..71407ffacab 100644
--- a/chromium/third_party/blink/renderer/core/animation/css/css_animations.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css/css_animations.cc
@@ -210,6 +210,12 @@ std::unique_ptr<TypedInterpolationValue> SampleAnimation(
   return ToTransitionInterpolation(*sample.at(0)).GetInterpolatedValue();
 }
 
+// Returns the start time of an animation given the start delay. A negative
+// start delay results in the animation starting with non-zero progress.
+double StartTimeFromDelay(double start_delay) {
+  return start_delay < 0 ? -start_delay : 0;
+}
+
 }  // namespace
 
 CSSAnimations::CSSAnimations() = default;
@@ -376,14 +382,14 @@ void CSSAnimations::CalculateAnimationUpdate(CSSAnimationUpdate& update,
       wtf_size_t existing_animation_index = 0;
 
       if (css_animations) {
-        for (wtf_size_t i = 0; i < css_animations->running_animations_.size();
-             i++) {
+        for (wtf_size_t j = 0; j < css_animations->running_animations_.size();
+             j++) {
           const RunningAnimation& running_animation =
-              *css_animations->running_animations_[i];
+              *css_animations->running_animations_[j];
           if (running_animation.name == name &&
               running_animation.name_index == name_index) {
             existing_animation = &running_animation;
-            existing_animation_index = i;
+            existing_animation_index = j;
             break;
           }
         }
@@ -786,28 +792,12 @@ void CSSAnimations::CalculateTransitionUpdateForProperty(
   }
 
   TransitionKeyframeVector keyframes;
-  double start_keyframe_offset = 0;
-
-  if (timing.start_delay > 0) {
-    timing.iteration_duration.value() +=
-        AnimationTimeDelta::FromSecondsD(timing.start_delay);
-    start_keyframe_offset =
-        timing.start_delay / timing.iteration_duration->InSecondsF();
-    timing.start_delay = 0;
-  }
-
-  TransitionKeyframe* delay_keyframe = TransitionKeyframe::Create(property);
-  delay_keyframe->SetValue(TypedInterpolationValue::Create(
-      *transition_type, start.interpolable_value->Clone(),
-      start.non_interpolable_value));
-  delay_keyframe->SetOffset(0);
-  keyframes.push_back(delay_keyframe);
 
   TransitionKeyframe* start_keyframe = TransitionKeyframe::Create(property);
   start_keyframe->SetValue(TypedInterpolationValue::Create(
       *transition_type, start.interpolable_value->Clone(),
       start.non_interpolable_value));
-  start_keyframe->SetOffset(start_keyframe_offset);
+  start_keyframe->SetOffset(0);
   start_keyframe->SetEasing(std::move(timing.timing_function));
   timing.timing_function = LinearTimingFunction::Shared();
   keyframes.push_back(start_keyframe);
@@ -824,7 +814,6 @@ void CSSAnimations::CalculateTransitionUpdateForProperty(
         CSSAnimatableValueFactory::Create(property, state.old_style);
     AnimatableValue* to =
         CSSAnimatableValueFactory::Create(property, state.style);
-    delay_keyframe->SetCompositorValue(from);
     start_keyframe->SetCompositorValue(from);
     end_keyframe->SetCompositorValue(to);
   }
@@ -1196,27 +1185,86 @@ EventTarget* CSSAnimations::TransitionEventDelegate::GetEventTarget() const {
 void CSSAnimations::TransitionEventDelegate::OnEventCondition(
     const AnimationEffect& animation_node) {
   const AnimationEffect::Phase current_phase = animation_node.GetPhase();
-  if (current_phase == AnimationEffect::kPhaseAfter &&
-      current_phase != previous_phase_ &&
-      GetDocument().HasListenerType(Document::kTransitionEndListener)) {
-    String property_name =
-        property_.IsCSSCustomProperty()
-            ? property_.CustomPropertyName()
-            : property_.GetCSSProperty().GetPropertyNameString();
-    const Timing& timing = animation_node.SpecifiedTiming();
-    double elapsed_time = timing.iteration_duration->InSecondsF();
-    const AtomicString& event_type = event_type_names::kTransitionend;
-    String pseudo_element =
-        PseudoElement::PseudoElementNameForEvents(GetPseudoId());
-    TransitionEvent* event = TransitionEvent::Create(
-        event_type, property_name, elapsed_time, pseudo_element);
-    event->SetTarget(GetEventTarget());
-    GetDocument().EnqueueAnimationFrameEvent(event);
+  if (current_phase == previous_phase_)
+    return;
+
+  if (GetDocument().HasListenerType(Document::kTransitionRunListener)) {
+    if (previous_phase_ == AnimationEffect::kPhaseNone) {
+      EnqueueEvent(
+          event_type_names::kTransitionrun,
+          StartTimeFromDelay(animation_node.SpecifiedTiming().start_delay));
+    }
+  }
+
+  if (GetDocument().HasListenerType(Document::kTransitionStartListener)) {
+    if ((current_phase == AnimationEffect::kPhaseActive ||
+         current_phase == AnimationEffect::kPhaseAfter) &&
+        (previous_phase_ == AnimationEffect::kPhaseNone ||
+         previous_phase_ == AnimationEffect::kPhaseBefore)) {
+      EnqueueEvent(
+          event_type_names::kTransitionstart,
+          StartTimeFromDelay(animation_node.SpecifiedTiming().start_delay));
+    } else if ((current_phase == AnimationEffect::kPhaseActive ||
+                current_phase == AnimationEffect::kPhaseBefore) &&
+               previous_phase_ == AnimationEffect::kPhaseAfter) {
+      // If the transition is progressing backwards it is considered to have
+      // started at the end position.
+      EnqueueEvent(
+          event_type_names::kTransitionstart,
+          animation_node.SpecifiedTiming().iteration_duration->InSecondsF());
+    }
+  }
+
+  if (GetDocument().HasListenerType(Document::kTransitionEndListener)) {
+    if (current_phase == AnimationEffect::kPhaseAfter &&
+        (previous_phase_ == AnimationEffect::kPhaseActive ||
+         previous_phase_ == AnimationEffect::kPhaseBefore ||
+         previous_phase_ == AnimationEffect::kPhaseNone)) {
+      EnqueueEvent(
+          event_type_names::kTransitionend,
+          animation_node.SpecifiedTiming().iteration_duration->InSecondsF());
+    } else if (current_phase == AnimationEffect::kPhaseBefore &&
+               (previous_phase_ == AnimationEffect::kPhaseActive ||
+                previous_phase_ == AnimationEffect::kPhaseAfter)) {
+      // If the transition is progressing backwards it is considered to have
+      // ended at the start position.
+      EnqueueEvent(
+          event_type_names::kTransitionend,
+          StartTimeFromDelay(animation_node.SpecifiedTiming().start_delay));
+    }
+  }
+
+  if (GetDocument().HasListenerType(Document::kTransitionCancelListener)) {
+    if (current_phase == AnimationEffect::kPhaseNone) {
+      double cancel_iteration_time =
+          animation_node.Progress().has_value()
+              ? animation_node.Progress().value() *
+                    animation_node.SpecifiedTiming()
+                        .iteration_duration->InSecondsF()
+              : StartTimeFromDelay(
+                    animation_node.SpecifiedTiming().start_delay);
+      EnqueueEvent(event_type_names::kTransitioncancel, cancel_iteration_time);
+    }
   }
 
   previous_phase_ = current_phase;
 }
 
+void CSSAnimations::TransitionEventDelegate::EnqueueEvent(
+    const WTF::AtomicString& type,
+    double elapsed_time) {
+  String property_name =
+      property_.IsCSSCustomProperty()
+          ? property_.CustomPropertyName()
+          : property_.GetCSSProperty().GetPropertyNameString();
+  String pseudo_element =
+      PseudoElement::PseudoElementNameForEvents(GetPseudoId());
+  TransitionEvent* event = TransitionEvent::Create(
+      type, property_name, elapsed_time, pseudo_element);
+  event->SetTarget(GetEventTarget());
+  GetDocument().EnqueueAnimationFrameEvent(event);
+}
+
 void CSSAnimations::TransitionEventDelegate::Trace(blink::Visitor* visitor) {
   visitor->Trace(transition_target_);
   AnimationEffect::EventDelegate::Trace(visitor);
@@ -1288,7 +1336,7 @@ bool CSSAnimations::IsAffectedByKeyframesFromScope(
     return false;
   if (tree_scope.RootNode() == tree_scope.GetDocument())
     return false;
-  return ToShadowRoot(tree_scope.RootNode()).host() == element;
+  return To<ShadowRoot>(tree_scope.RootNode()).host() == element;
 }
 
 bool CSSAnimations::IsAnimatingCustomProperties(
diff --git a/chromium/third_party/blink/renderer/core/animation/css/css_animations.h b/chromium/third_party/blink/renderer/core/animation/css/css_animations.h
index 35f26d3bd54..ae17144a071 100644
--- a/chromium/third_party/blink/renderer/core/animation/css/css_animations.h
+++ b/chromium/third_party/blink/renderer/core/animation/css/css_animations.h
@@ -239,6 +239,8 @@ class CSSAnimations final {
     void Trace(blink::Visitor*) override;
 
    private:
+    void EnqueueEvent(const WTF::AtomicString& type, double elapsed_time);
+
     const Element& TransitionTarget() const { return *transition_target_; }
     EventTarget* GetEventTarget() const;
     PseudoId GetPseudoId() const { return transition_target_->GetPseudoId(); }
diff --git a/chromium/third_party/blink/renderer/core/animation/css/css_transition_data.cc b/chromium/third_party/blink/renderer/core/animation/css/css_transition_data.cc
index d0c0f450ad4..a58dd8066d3 100644
--- a/chromium/third_party/blink/renderer/core/animation/css/css_transition_data.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css/css_transition_data.cc
@@ -24,7 +24,7 @@ Timing CSSTransitionData::ConvertToTiming(size_t index) const {
   DCHECK_LT(index, property_list_.size());
   // Note that the backwards fill part is required for delay to work.
   Timing timing = CSSTimingData::ConvertToTiming(index);
-  timing.fill_mode = Timing::FillMode::NONE;
+  timing.fill_mode = Timing::FillMode::BACKWARDS;
   return timing;
 }
 
diff --git a/chromium/third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.cc b/chromium/third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.cc
index 02b0d0062a4..c1288909dda 100644
--- a/chromium/third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.cc
@@ -430,14 +430,14 @@ void CSSBorderImageLengthBoxInterpolationType::ApplyStandardPropertyValue(
         return clampTo<double>(ToInterpolableNumber(list.Get(index))->Value(),
                                0);
       case SideType::kAuto:
-        return Length(kAuto);
+        return Length::Auto();
       case SideType::kLength:
         return LengthInterpolationFunctions::CreateLength(
             *list.Get(index), non_interpolable_values[index].get(),
             state.CssToLengthConversionData(), kValueRangeNonNegative);
       default:
         NOTREACHED();
-        return Length(kAuto);
+        return Length::Auto();
     }
   };
   BorderImageLengthBox box(convert_side(kSideTop), convert_side(kSideRight),
diff --git a/chromium/third_party/blink/renderer/core/animation/css_clip_interpolation_type.cc b/chromium/third_party/blink/renderer/core/animation/css_clip_interpolation_type.cc
index e66554dcf29..8046ee436d6 100644
--- a/chromium/third_party/blink/renderer/core/animation/css_clip_interpolation_type.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css_clip_interpolation_type.cc
@@ -180,10 +180,10 @@ InterpolationValue CSSClipInterpolationType::MaybeConvertNeutral(
   if (underlying_autos.is_auto)
     return nullptr;
   LengthBox neutral_box(
-      underlying_autos.is_top_auto ? Length(kAuto) : Length(0, kFixed),
-      underlying_autos.is_right_auto ? Length(kAuto) : Length(0, kFixed),
-      underlying_autos.is_bottom_auto ? Length(kAuto) : Length(0, kFixed),
-      underlying_autos.is_left_auto ? Length(kAuto) : Length(0, kFixed));
+      underlying_autos.is_top_auto ? Length::Auto() : Length::Fixed(0),
+      underlying_autos.is_right_auto ? Length::Auto() : Length::Fixed(0),
+      underlying_autos.is_bottom_auto ? Length::Auto() : Length::Fixed(0),
+      underlying_autos.is_left_auto ? Length::Auto() : Length::Fixed(0));
   return CreateClipValue(neutral_box, 1);
 }
 
@@ -287,7 +287,7 @@ void CSSClipInterpolationType::ApplyStandardPropertyValue(
   const InterpolableList& list = ToInterpolableList(interpolable_value);
   const auto& convert_index = [&list, &state](bool is_auto, wtf_size_t index) {
     if (is_auto)
-      return Length(kAuto);
+      return Length::Auto();
     return LengthInterpolationFunctions::CreateLength(
         *list.Get(index), nullptr, state.CssToLengthConversionData(),
         kValueRangeAll);
diff --git a/chromium/third_party/blink/renderer/core/animation/css_image_slice_interpolation_type.cc b/chromium/third_party/blink/renderer/core/animation/css_image_slice_interpolation_type.cc
index ac3b5438696..bcddce842df 100644
--- a/chromium/third_party/blink/renderer/core/animation/css_image_slice_interpolation_type.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css_image_slice_interpolation_type.cc
@@ -162,10 +162,14 @@ InterpolationValue CSSImageSliceInterpolationType::MaybeConvertNeutral(
   conversion_checkers.push_back(
       UnderlyingSliceTypesChecker::Create(underlying_types));
   LengthBox zero_box(
-      Length(0, underlying_types.is_number[kSideTop] ? kFixed : kPercent),
-      Length(0, underlying_types.is_number[kSideRight] ? kFixed : kPercent),
-      Length(0, underlying_types.is_number[kSideBottom] ? kFixed : kPercent),
-      Length(0, underlying_types.is_number[kSideLeft] ? kFixed : kPercent));
+      underlying_types.is_number[kSideTop] ? Length::Fixed(0)
+                                           : Length::Percent(0),
+      underlying_types.is_number[kSideRight] ? Length::Fixed(0)
+                                             : Length::Percent(0),
+      underlying_types.is_number[kSideBottom] ? Length::Fixed(0)
+                                              : Length::Percent(0),
+      underlying_types.is_number[kSideLeft] ? Length::Fixed(0)
+                                            : Length::Percent(0));
   return ConvertImageSlice(ImageSlice(zero_box, underlying_types.fill), 1);
 }
 
@@ -272,9 +276,8 @@ void CSSImageSliceInterpolationType::ApplyStandardPropertyValue(
   const auto& convert_side = [&types, &list, &style](wtf_size_t index) {
     float value =
         clampTo<float>(ToInterpolableNumber(list.Get(index))->Value(), 0);
-    return types.is_number[index]
-               ? Length(value * style.EffectiveZoom(), kFixed)
-               : Length(value, kPercent);
+    return types.is_number[index] ? Length::Fixed(value * style.EffectiveZoom())
+                                  : Length::Percent(value);
   };
   LengthBox box(convert_side(kSideTop), convert_side(kSideRight),
                 convert_side(kSideBottom), convert_side(kSideLeft));
diff --git a/chromium/third_party/blink/renderer/core/animation/css_text_indent_interpolation_type.cc b/chromium/third_party/blink/renderer/core/animation/css_text_indent_interpolation_type.cc
index 26990911407..f94809b82ff 100644
--- a/chromium/third_party/blink/renderer/core/animation/css_text_indent_interpolation_type.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css_text_indent_interpolation_type.cc
@@ -137,7 +137,7 @@ InterpolationValue CSSTextIndentInterpolationType::MaybeConvertNeutral(
       ToCSSTextIndentNonInterpolableValue(*underlying.non_interpolable_value)
           .Mode();
   conversion_checkers.push_back(UnderlyingIndentModeChecker::Create(mode));
-  return CreateValue(Length(0, kFixed), mode, 1);
+  return CreateValue(Length::Fixed(0), mode, 1);
 }
 
 InterpolationValue CSSTextIndentInterpolationType::MaybeConvertInitial(
diff --git a/chromium/third_party/blink/renderer/core/animation/css_translate_interpolation_type.cc b/chromium/third_party/blink/renderer/core/animation/css_translate_interpolation_type.cc
index fb731e65db3..69a4e5ef97c 100644
--- a/chromium/third_party/blink/renderer/core/animation/css_translate_interpolation_type.cc
+++ b/chromium/third_party/blink/renderer/core/animation/css_translate_interpolation_type.cc
@@ -90,7 +90,7 @@ InterpolationValue ConvertTranslateOperation(
                                translate->Y(), zoom)
                                .interpolable_value);
   result->Set(kTranslateZ, LengthInterpolationFunctions::MaybeConvertLength(
-                               Length(translate->Z(), kFixed), zoom)
+                               Length::Fixed(translate->Z()), zoom)
                                .interpolable_value);
   return InterpolationValue(std::move(result));
 }
diff --git a/chromium/third_party/blink/renderer/core/animation/document_animations.cc b/chromium/third_party/blink/renderer/core/animation/document_animations.cc
index 12b7aeac3d1..fdc916720ad 100644
--- a/chromium/third_party/blink/renderer/core/animation/document_animations.cc
+++ b/chromium/third_party/blink/renderer/core/animation/document_animations.cc
@@ -30,6 +30,7 @@
 
 #include "third_party/blink/renderer/core/animation/document_animations.h"
 
+#include "cc/animation/animation_host.h"
 #include "third_party/blink/renderer/core/animation/animation_clock.h"
 #include "third_party/blink/renderer/core/animation/document_timeline.h"
 #include "third_party/blink/renderer/core/animation/pending_animations.h"
@@ -39,7 +40,6 @@
 #include "third_party/blink/renderer/core/dom/node.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_frame_view.h"
-#include "third_party/blink/renderer/platform/animation/compositor_animation_host.h"
 
 namespace blink {
 
@@ -78,7 +78,7 @@ void DocumentAnimations::UpdateAnimations(
     document.View()->ScheduleAnimation();
   }
   if (document.View()) {
-    if (CompositorAnimationHost* host =
+    if (cc::AnimationHost* host =
             document.View()->GetCompositorAnimationHost()) {
       wtf_size_t total_animations_count = 0;
       if (document.Timeline().HasAnimations()) {
diff --git a/chromium/third_party/blink/renderer/core/animation/document_timeline.cc b/chromium/third_party/blink/renderer/core/animation/document_timeline.cc
index f83a0fe1c0e..43b8369dd76 100644
--- a/chromium/third_party/blink/renderer/core/animation/document_timeline.cc
+++ b/chromium/third_party/blink/renderer/core/animation/document_timeline.cc
@@ -43,7 +43,6 @@
 #include "third_party/blink/renderer/core/page/page.h"
 #include "third_party/blink/renderer/platform/animation/compositor_animation_timeline.h"
 #include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"
-#include "third_party/blink/renderer/platform/wtf/time.h"
 
 namespace blink {
 
@@ -230,9 +229,9 @@ double DocumentTimeline::CurrentTimeInternal(bool& is_null) {
     return std::numeric_limits<double>::quiet_NaN();
   }
   double result = playback_rate_ == 0
-                      ? TimeTicksInSeconds(ZeroTime())
+                      ? ZeroTime().since_origin().InSecondsF()
                       : (GetDocument()->GetAnimationClock().CurrentTime() -
-                         TimeTicksInSeconds(ZeroTime())) *
+                         ZeroTime().since_origin().InSecondsF()) *
                             playback_rate_;
   is_null = std::isnan(result);
   // This looks like it could never be NaN here.
@@ -268,7 +267,7 @@ bool DocumentTimeline::NeedsAnimationTimingUpdate() {
       std::isnan(last_current_time_internal_))
     return false;
 
-  // We allow m_lastCurrentTimeInternal to advance here when there
+  // We allow |last_current_time_internal_| to advance here when there
   // are no animations to allow animations spawned during style
   // recalc to not invalidate this flag.
   if (animations_needing_update_.IsEmpty())
@@ -295,10 +294,12 @@ void DocumentTimeline::SetPlaybackRate(double playback_rate) {
     return;
   double current_time = CurrentTimeInternal();
   playback_rate_ = playback_rate;
-  zero_time_ = TimeTicksFromSeconds(
+  double zero_time_seconds =
       playback_rate == 0 ? current_time
                          : GetDocument()->GetAnimationClock().CurrentTime() -
-                               current_time / playback_rate);
+                               current_time / playback_rate;
+  zero_time_ =
+      base::TimeTicks() + base::TimeDelta::FromSecondsD(zero_time_seconds);
   zero_time_initialized_ = true;
 
   // Corresponding compositor animation may need to be restarted to pick up
diff --git a/chromium/third_party/blink/renderer/core/animation/document_timeline_test.cc b/chromium/third_party/blink/renderer/core/animation/document_timeline_test.cc
index 2d8daa7ce8a..06f7774ba1b 100644
--- a/chromium/third_party/blink/renderer/core/animation/document_timeline_test.cc
+++ b/chromium/third_party/blink/renderer/core/animation/document_timeline_test.cc
@@ -44,6 +44,12 @@
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
 
+namespace {
+base::TimeTicks TimeTicksFromSecondsD(double seconds) {
+  return base::TimeTicks() + base::TimeDelta::FromSecondsD(seconds);
+}
+}  // namespace
+
 namespace blink {
 
 class MockPlatformTiming : public DocumentTimeline::PlatformTiming {
@@ -78,8 +84,7 @@ class AnimationDocumentTimelineTest : public PageTestBase {
   }
 
   void UpdateClockAndService(double time) {
-    GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                   base::TimeDelta::FromSecondsD(time));
+    GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(time));
     GetPendingAnimations().Update(base::Optional<CompositorElementIdSet>(),
                                   false);
     timeline->ServiceAnimations(kTimingUpdateForAnimationFrame);
@@ -137,14 +142,12 @@ TEST_F(AnimationDocumentTimelineTest, EmptyForwardsKeyframeAnimation) {
 TEST_F(AnimationDocumentTimelineTest, ZeroTime) {
   bool is_null;
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(100, timeline->CurrentTimeInternal());
   EXPECT_EQ(100, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(200));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(200));
   EXPECT_EQ(200, timeline->CurrentTimeInternal());
   EXPECT_EQ(200, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
@@ -153,8 +156,7 @@ TEST_F(AnimationDocumentTimelineTest, ZeroTime) {
 // EffectiveTime is identical to CurrentTimeInternal except that it returns 0
 // when the timeline is inactive.
 TEST_F(AnimationDocumentTimelineTest, EffectiveTime) {
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(200));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(200));
   EXPECT_EQ(200, timeline->EffectiveTime());
   EXPECT_EQ(200, timeline->CurrentTimeInternal());
   bool is_null;
@@ -177,15 +179,13 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateNormal) {
 
   timeline->SetPlaybackRate(1.0);
   EXPECT_EQ(1.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(zero_time, timeline->ZeroTime());
   EXPECT_EQ(100, timeline->CurrentTimeInternal());
   EXPECT_EQ(100, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(200));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(200));
   EXPECT_EQ(zero_time, timeline->ZeroTime());
   EXPECT_EQ(200, timeline->CurrentTimeInternal());
   EXPECT_EQ(200, timeline->CurrentTimeInternal(is_null));
@@ -206,15 +206,13 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateNormalWithOriginTime) {
   EXPECT_EQ(1000, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(TimeTicks() + origin_time, timeline->ZeroTime());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(200));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(200));
   EXPECT_EQ(TimeTicks() + origin_time, timeline->ZeroTime());
   EXPECT_EQ(1200, timeline->CurrentTimeInternal());
   EXPECT_EQ(1200, timeline->CurrentTimeInternal(is_null));
@@ -224,8 +222,7 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateNormalWithOriginTime) {
 TEST_F(AnimationDocumentTimelineTest, PlaybackRatePause) {
   bool is_null;
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(TimeTicks(), timeline->ZeroTime());
   EXPECT_EQ(100, timeline->CurrentTimeInternal());
   EXPECT_EQ(100, timeline->CurrentTimeInternal(is_null));
@@ -233,17 +230,15 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRatePause) {
 
   timeline->SetPlaybackRate(0.0);
   EXPECT_EQ(0.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(200));
-  EXPECT_EQ(TimeTicksFromSeconds(100), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(200));
+  EXPECT_EQ(TimeTicksFromSecondsD(100), timeline->ZeroTime());
   EXPECT_EQ(100, timeline->CurrentTimeInternal());
   EXPECT_EQ(100, timeline->CurrentTimeInternal(is_null));
 
   timeline->SetPlaybackRate(1.0);
   EXPECT_EQ(1.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(400));
-  EXPECT_EQ(TimeTicksFromSeconds(100), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(400));
+  EXPECT_EQ(TimeTicksFromSecondsD(100), timeline->ZeroTime());
   EXPECT_EQ(300, timeline->CurrentTimeInternal());
   EXPECT_EQ(300, timeline->CurrentTimeInternal(is_null));
 
@@ -263,8 +258,7 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRatePauseWithOriginTime) {
   EXPECT_EQ(1000, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(TimeTicks() + origin_time, timeline->ZeroTime());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal(is_null));
@@ -272,21 +266,19 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRatePauseWithOriginTime) {
 
   timeline->SetPlaybackRate(0.0);
   EXPECT_EQ(0.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(200));
-  EXPECT_EQ(TimeTicksFromSeconds(1100), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(200));
+  EXPECT_EQ(TimeTicksFromSecondsD(1100), timeline->ZeroTime());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal(is_null));
 
   timeline->SetPlaybackRate(1.0);
   EXPECT_EQ(1.0, timeline->PlaybackRate());
-  EXPECT_EQ(TimeTicksFromSeconds(-900), timeline->ZeroTime());
+  EXPECT_EQ(TimeTicksFromSecondsD(-900), timeline->ZeroTime());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal(is_null));
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(400));
-  EXPECT_EQ(TimeTicksFromSeconds(-900), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(400));
+  EXPECT_EQ(TimeTicksFromSecondsD(-900), timeline->ZeroTime());
   EXPECT_EQ(1300, timeline->CurrentTimeInternal());
   EXPECT_EQ(1300, timeline->CurrentTimeInternal(is_null));
 
@@ -296,8 +288,7 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRatePauseWithOriginTime) {
 TEST_F(AnimationDocumentTimelineTest, PlaybackRateSlow) {
   bool is_null;
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(TimeTicks(), timeline->ZeroTime());
   EXPECT_EQ(100, timeline->CurrentTimeInternal());
   EXPECT_EQ(100, timeline->CurrentTimeInternal(is_null));
@@ -305,17 +296,15 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateSlow) {
 
   timeline->SetPlaybackRate(0.5);
   EXPECT_EQ(0.5, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(300));
-  EXPECT_EQ(TimeTicksFromSeconds(-100), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(300));
+  EXPECT_EQ(TimeTicksFromSecondsD(-100), timeline->ZeroTime());
   EXPECT_EQ(200, timeline->CurrentTimeInternal());
   EXPECT_EQ(200, timeline->CurrentTimeInternal(is_null));
 
   timeline->SetPlaybackRate(1.0);
   EXPECT_EQ(1.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(400));
-  EXPECT_EQ(TimeTicksFromSeconds(100), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(400));
+  EXPECT_EQ(TimeTicksFromSecondsD(100), timeline->ZeroTime());
   EXPECT_EQ(300, timeline->CurrentTimeInternal());
   EXPECT_EQ(300, timeline->CurrentTimeInternal(is_null));
 
@@ -325,8 +314,7 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateSlow) {
 TEST_F(AnimationDocumentTimelineTest, PlaybackRateFast) {
   bool is_null;
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
   EXPECT_EQ(TimeTicks(), timeline->ZeroTime());
   EXPECT_EQ(100, timeline->CurrentTimeInternal());
   EXPECT_EQ(100, timeline->CurrentTimeInternal(is_null));
@@ -334,17 +322,15 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateFast) {
 
   timeline->SetPlaybackRate(2.0);
   EXPECT_EQ(2.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(300));
-  EXPECT_EQ(TimeTicksFromSeconds(50), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(300));
+  EXPECT_EQ(TimeTicksFromSecondsD(50), timeline->ZeroTime());
   EXPECT_EQ(500, timeline->CurrentTimeInternal());
   EXPECT_EQ(500, timeline->CurrentTimeInternal(is_null));
 
   timeline->SetPlaybackRate(1.0);
   EXPECT_EQ(1.0, timeline->PlaybackRate());
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(400));
-  EXPECT_EQ(TimeTicksFromSeconds(-200), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(400));
+  EXPECT_EQ(TimeTicksFromSecondsD(-200), timeline->ZeroTime());
   EXPECT_EQ(600, timeline->CurrentTimeInternal());
   EXPECT_EQ(600, timeline->CurrentTimeInternal(is_null));
 
@@ -358,34 +344,31 @@ TEST_F(AnimationDocumentTimelineTest, PlaybackRateFastWithOriginTime) {
       document.Get(), TimeDelta::FromSeconds(-1000), platform_timing);
   timeline->ResetForTesting();
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(100));
-  EXPECT_EQ(TimeTicksFromSeconds(-1000), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(100));
+  EXPECT_EQ(TimeTicksFromSecondsD(-1000), timeline->ZeroTime());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal(is_null));
   EXPECT_FALSE(is_null);
 
   timeline->SetPlaybackRate(2.0);
   EXPECT_EQ(2.0, timeline->PlaybackRate());
-  EXPECT_EQ(TimeTicksFromSeconds(-450), timeline->ZeroTime());
+  EXPECT_EQ(TimeTicksFromSecondsD(-450), timeline->ZeroTime());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal());
   EXPECT_EQ(1100, timeline->CurrentTimeInternal(is_null));
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(300));
-  EXPECT_EQ(TimeTicksFromSeconds(-450), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(300));
+  EXPECT_EQ(TimeTicksFromSecondsD(-450), timeline->ZeroTime());
   EXPECT_EQ(1500, timeline->CurrentTimeInternal());
   EXPECT_EQ(1500, timeline->CurrentTimeInternal(is_null));
 
   timeline->SetPlaybackRate(1.0);
   EXPECT_EQ(1.0, timeline->PlaybackRate());
-  EXPECT_EQ(TimeTicksFromSeconds(-1200), timeline->ZeroTime());
+  EXPECT_EQ(TimeTicksFromSecondsD(-1200), timeline->ZeroTime());
   EXPECT_EQ(1500, timeline->CurrentTimeInternal());
   EXPECT_EQ(1500, timeline->CurrentTimeInternal(is_null));
 
-  GetAnimationClock().UpdateTime(base::TimeTicks() +
-                                 base::TimeDelta::FromSecondsD(400));
-  EXPECT_EQ(TimeTicksFromSeconds(-1200), timeline->ZeroTime());
+  GetAnimationClock().UpdateTime(TimeTicksFromSecondsD(400));
+  EXPECT_EQ(TimeTicksFromSecondsD(-1200), timeline->ZeroTime());
   EXPECT_EQ(1600, timeline->CurrentTimeInternal());
   EXPECT_EQ(1600, timeline->CurrentTimeInternal(is_null));
 
diff --git a/chromium/third_party/blink/renderer/core/animation/effect_input.cc b/chromium/third_party/blink/renderer/core/animation/effect_input.cc
index c2e3d0c7247..67af486cf41 100644
--- a/chromium/third_party/blink/renderer/core/animation/effect_input.cc
+++ b/chromium/third_party/blink/renderer/core/animation/effect_input.cc
@@ -102,7 +102,7 @@ void SetKeyframeValue(Element* element,
     if (!set_result.did_parse && execution_context) {
       if (document.GetFrame()) {
         document.GetFrame()->Console().AddMessage(ConsoleMessage::Create(
-            kJSMessageSource, kWarningMessageLevel,
+            kJSMessageSource, mojom::ConsoleMessageLevel::kWarning,
             "Invalid keyframe value for property " + property + ": " + value));
       }
     }
@@ -426,7 +426,7 @@ bool GetPropertyIndexedKeyframeValues(const v8::Local<v8::Object>& keyframe,
 // See https://drafts.csswg.org/web-animations/#processing-a-keyframes-argument
 StringKeyframeVector ConvertObjectForm(Element* element,
                                        Document& document,
-                                       const v8::Local<v8::Object>& keyframe,
+                                       const v8::Local<v8::Object>& v8_keyframe,
                                        ScriptState* script_state,
                                        ExceptionState& exception_state) {
   // We implement much of this procedure out of order from the way the spec is
@@ -437,7 +437,7 @@ StringKeyframeVector ConvertObjectForm(Element* element,
   // to process a keyframe-like object'.
   BasePropertyIndexedKeyframe* property_indexed_keyframe =
       NativeValueTraits<BasePropertyIndexedKeyframe>::NativeValue(
-          script_state->GetIsolate(), keyframe, exception_state);
+          script_state->GetIsolate(), v8_keyframe, exception_state);
   if (exception_state.HadException())
     return {};
 
@@ -466,7 +466,7 @@ StringKeyframeVector ConvertObjectForm(Element* element,
   // object' and step 5.2 of the 'procedure to process a keyframes argument'.
 
   Vector<String> keyframe_properties = GetOwnPropertyNames(
-      script_state->GetIsolate(), keyframe, exception_state);
+      script_state->GetIsolate(), v8_keyframe, exception_state);
   if (exception_state.HadException())
     return {};
 
@@ -496,7 +496,7 @@ StringKeyframeVector ConvertObjectForm(Element* element,
       continue;
 
     Vector<String> values;
-    if (!GetPropertyIndexedKeyframeValues(keyframe, property, script_state,
+    if (!GetPropertyIndexedKeyframeValues(v8_keyframe, property, script_state,
                                           exception_state, values)) {
       return {};
     }
diff --git a/chromium/third_party/blink/renderer/core/animation/invalidatable_interpolation.cc b/chromium/third_party/blink/renderer/core/animation/invalidatable_interpolation.cc
index 8d7bac4f0e9..1f765f2761d 100644
--- a/chromium/third_party/blink/renderer/core/animation/invalidatable_interpolation.cc
+++ b/chromium/third_party/blink/renderer/core/animation/invalidatable_interpolation.cc
@@ -25,7 +25,7 @@ void InvalidatableInterpolation::Interpolate(int, double fraction) {
   if (is_conversion_cached_ && cached_pair_conversion_)
     cached_pair_conversion_->InterpolateValue(fraction, cached_value_);
   // We defer the interpolation to ensureValidConversion() if
-  // m_cachedPairConversion is null.
+  // |cached_pair_conversion_| is null.
 }
 
 std::unique_ptr<PairwisePrimitiveInterpolation>
diff --git a/chromium/third_party/blink/renderer/core/animation/keyframe.h b/chromium/third_party/blink/renderer/core/animation/keyframe.h
index ccf93f6fb8d..5df8b19b8be 100644
--- a/chromium/third_party/blink/renderer/core/animation/keyframe.h
+++ b/chromium/third_party/blink/renderer/core/animation/keyframe.h
@@ -159,7 +159,7 @@ class CORE_EXPORT Keyframe : public GarbageCollectedFinalized<Keyframe> {
         const PropertyHandle&,
         const Keyframe::PropertySpecificKeyframe& end) const;
 
-    virtual void Trace(Visitor*){};
+    virtual void Trace(Visitor*) {}
 
    protected:
     double offset_;
diff --git a/chromium/third_party/blink/renderer/core/animation/length_interpolation_functions.cc b/chromium/third_party/blink/renderer/core/animation/length_interpolation_functions.cc
index cbf455a28a0..bdf01cef458 100644
--- a/chromium/third_party/blink/renderer/core/animation/length_interpolation_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/length_interpolation_functions.cc
@@ -196,10 +196,9 @@ Length LengthInterpolationFunctions::CreateLength(
         range));
   }
   if (has_percentage)
-    return Length(ClampToRange(percentage, range), kPercent);
-  return Length(
-      CSSPrimitiveValue::ClampToCSSLengthRange(ClampToRange(pixels, range)),
-      kFixed);
+    return Length::Percent(ClampToRange(percentage, range));
+  return Length::Fixed(
+      CSSPrimitiveValue::ClampToCSSLengthRange(ClampToRange(pixels, range)));
 }
 
 const CSSValue* LengthInterpolationFunctions::CreateCSSValue(
diff --git a/chromium/third_party/blink/renderer/core/animation/length_list_property_functions.cc b/chromium/third_party/blink/renderer/core/animation/length_list_property_functions.cc
index 10b57c66ce9..c5a2cc780ee 100644
--- a/chromium/third_party/blink/renderer/core/animation/length_list_property_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/length_list_property_functions.cc
@@ -123,7 +123,7 @@ static bool AppendToVector(const TransformOrigin& transform_origin,
                            Vector<Length>& result) {
   result.push_back(transform_origin.X());
   result.push_back(transform_origin.Y());
-  result.push_back(Length(transform_origin.Z(), kFixed));
+  result.push_back(Length::Fixed(transform_origin.Z()));
   return true;
 }
 
diff --git a/chromium/third_party/blink/renderer/core/animation/length_property_functions.cc b/chromium/third_party/blink/renderer/core/animation/length_property_functions.cc
index d0ea0f29d13..c11eb097316 100644
--- a/chromium/third_party/blink/renderer/core/animation/length_property_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/length_property_functions.cc
@@ -106,15 +106,14 @@ bool LengthPropertyFunctions::GetInitialLength(const CSSProperty& property,
     case CSSPropertyBorderLeftWidth:
     case CSSPropertyBorderRightWidth:
     case CSSPropertyBorderTopWidth:
-      result = Length(ComputedStyleInitialValues::InitialBorderWidth(), kFixed);
+      result = Length::Fixed(ComputedStyleInitialValues::InitialBorderWidth());
       return true;
     case CSSPropertyOutlineWidth:
-      result =
-          Length(ComputedStyleInitialValues::InitialOutlineWidth(), kFixed);
+      result = Length::Fixed(ComputedStyleInitialValues::InitialOutlineWidth());
       return true;
     case CSSPropertyColumnRuleWidth:
       result =
-          Length(ComputedStyleInitialValues::InitialColumnRuleWidth(), kFixed);
+          Length::Fixed(ComputedStyleInitialValues::InitialColumnRuleWidth());
       return true;
 
     default:
@@ -230,31 +229,31 @@ bool LengthPropertyFunctions::GetLength(const CSSProperty& property,
       return true;
 
     case CSSPropertyBorderBottomWidth:
-      result = Length(style.BorderBottomWidth(), kFixed);
+      result = Length::Fixed(style.BorderBottomWidth());
       return true;
     case CSSPropertyBorderLeftWidth:
-      result = Length(style.BorderLeftWidth(), kFixed);
+      result = Length::Fixed(style.BorderLeftWidth());
       return true;
     case CSSPropertyBorderRightWidth:
-      result = Length(style.BorderRightWidth(), kFixed);
+      result = Length::Fixed(style.BorderRightWidth());
       return true;
     case CSSPropertyBorderTopWidth:
-      result = Length(style.BorderTopWidth(), kFixed);
+      result = Length::Fixed(style.BorderTopWidth());
       return true;
     case CSSPropertyLetterSpacing:
-      result = Length(style.LetterSpacing(), kFixed);
+      result = Length::Fixed(style.LetterSpacing());
       return true;
     case CSSPropertyOutlineOffset:
-      result = Length(style.OutlineOffset(), kFixed);
+      result = Length::Fixed(style.OutlineOffset());
       return true;
     case CSSPropertyOutlineWidth:
-      result = Length(style.OutlineWidth(), kFixed);
+      result = Length::Fixed(style.OutlineWidth());
       return true;
     case CSSPropertyWebkitBorderHorizontalSpacing:
-      result = Length(style.HorizontalBorderSpacing(), kFixed);
+      result = Length::Fixed(style.HorizontalBorderSpacing());
       return true;
     case CSSPropertyWebkitBorderVerticalSpacing:
-      result = Length(style.VerticalBorderSpacing(), kFixed);
+      result = Length::Fixed(style.VerticalBorderSpacing());
       return true;
     case CSSPropertyRowGap:
       if (style.RowGap().IsNormal())
@@ -267,13 +266,13 @@ bool LengthPropertyFunctions::GetLength(const CSSProperty& property,
       result = style.ColumnGap().GetLength();
       return true;
     case CSSPropertyColumnRuleWidth:
-      result = Length(style.ColumnRuleWidth(), kFixed);
+      result = Length::Fixed(style.ColumnRuleWidth());
       return true;
     case CSSPropertyWebkitTransformOriginZ:
-      result = Length(style.TransformOriginZ(), kFixed);
+      result = Length::Fixed(style.TransformOriginZ());
       return true;
     case CSSPropertyWordSpacing:
-      result = Length(style.WordSpacing(), kFixed);
+      result = Length::Fixed(style.WordSpacing());
       return true;
 
     case CSSPropertyBaselineShift:
@@ -290,7 +289,7 @@ bool LengthPropertyFunctions::GetLength(const CSSProperty& property,
     case CSSPropertyPerspective:
       if (!style.HasPerspective())
         return false;
-      result = Length(style.Perspective(), kFixed);
+      result = Length::Fixed(style.Perspective());
       return true;
     case CSSPropertyStrokeWidth:
       DCHECK(!IsZoomedLength(CSSProperty::Get(CSSPropertyStrokeWidth)));
@@ -304,7 +303,7 @@ bool LengthPropertyFunctions::GetLength(const CSSProperty& property,
     case CSSPropertyColumnWidth:
       if (style.HasAutoColumnWidth())
         return false;
-      result = Length(style.ColumnWidth(), kFixed);
+      result = Length::Fixed(style.ColumnWidth());
       return true;
     default:
       return false;
diff --git a/chromium/third_party/blink/renderer/core/animation/list_interpolation_functions.cc b/chromium/third_party/blink/renderer/core/animation/list_interpolation_functions.cc
index b1625a5c7bb..09bfde3ab4b 100644
--- a/chromium/third_party/blink/renderer/core/animation/list_interpolation_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/list_interpolation_functions.cc
@@ -135,17 +135,17 @@ PairwiseInterpolationValue ListInterpolationFunctions::MaybeMergeSingles(
       ToNonInterpolableList(*end.non_interpolable_value);
 
   for (wtf_size_t i = 0; i < final_length; i++) {
-    PairwiseInterpolationValue result = nullptr;
     if (length_matching_strategy ==
             LengthMatchingStrategy::kLowestCommonMultiple ||
         (i < start_length && i < end_length)) {
-      InterpolationValue start(
+      InterpolationValue start_merge(
           start_interpolable_list.Get(i % start_length)->Clone(),
           start_non_interpolable_list.Get(i % start_length));
-      InterpolationValue end(end_interpolable_list.Get(i % end_length)->Clone(),
-                             end_non_interpolable_list.Get(i % end_length));
-      PairwiseInterpolationValue result =
-          merge_single_item_conversions.Run(std::move(start), std::move(end));
+      InterpolationValue end_merge(
+          end_interpolable_list.Get(i % end_length)->Clone(),
+          end_non_interpolable_list.Get(i % end_length));
+      PairwiseInterpolationValue result = merge_single_item_conversions.Run(
+          std::move(start_merge), std::move(end_merge));
       if (!result)
         return nullptr;
       result_start_interpolable_list->Set(
diff --git a/chromium/third_party/blink/renderer/core/animation/non_interpolable_value.h b/chromium/third_party/blink/renderer/core/animation/non_interpolable_value.h
index 94ac28aa6dc..a570f8aa8e3 100644
--- a/chromium/third_party/blink/renderer/core/animation/non_interpolable_value.h
+++ b/chromium/third_party/blink/renderer/core/animation/non_interpolable_value.h
@@ -22,19 +22,18 @@ class NonInterpolableValue : public RefCounted<NonInterpolableValue> {
 // These macros provide safe downcasts of NonInterpolableValue subclasses with
 // debug assertions.
 // See CSSDefaultInterpolationType.cpp for example usage.
-#define DECLARE_NON_INTERPOLABLE_VALUE_TYPE() \
-  static Type static_type_;                   \
-  Type GetType() const final { return static_type_; }
+#define DECLARE_NON_INTERPOLABLE_VALUE_TYPE()         \
+  Type GetType() const final { return static_type_; } \
+  static Type static_type_
 
 #define DEFINE_NON_INTERPOLABLE_VALUE_TYPE(T) \
-  NonInterpolableValue::Type T::static_type_ = &T::static_type_;
-
-#define DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(T)               \
-  inline bool Is##T(const NonInterpolableValue* value) {          \
-    return !value || value->GetType() == T::static_type_;         \
-  }                                                               \
-  DEFINE_TYPE_CASTS(T, NonInterpolableValue, value, Is##T(value), \
-                    Is##T(&value));
+  NonInterpolableValue::Type T::static_type_ = &T::static_type_
+
+#define DEFINE_NON_INTERPOLABLE_VALUE_TYPE_CASTS(T)       \
+  inline bool Is##T(const NonInterpolableValue* value) {  \
+    return !value || value->GetType() == T::static_type_; \
+  }                                                       \
+  DEFINE_TYPE_CASTS(T, NonInterpolableValue, value, Is##T(value), Is##T(&value))
 
 }  // namespace blink
 
diff --git a/chromium/third_party/blink/renderer/core/animation/number_property_functions.cc b/chromium/third_party/blink/renderer/core/animation/number_property_functions.cc
index 2b79364dad9..467a58fb2a6 100644
--- a/chromium/third_party/blink/renderer/core/animation/number_property_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/number_property_functions.cc
@@ -65,7 +65,7 @@ base::Optional<double> NumberPropertyFunctions::GetNumber(
     case CSSPropertyLineHeight: {
       const Length& length = style.SpecifiedLineHeight();
       // Numbers are represented by percentages.
-      if (length.GetType() != kPercent)
+      if (!length.IsPercent())
         return base::Optional<double>();
       double value = length.Value();
       // -100% represents the keyword "normal".
@@ -104,13 +104,13 @@ double NumberPropertyFunctions::ClampNumber(const CSSProperty& property,
 
     case CSSPropertyOrphans:
     case CSSPropertyWidows:
-      return clampTo<short>(round(value), 1);
+      return clampTo<int16_t>(round(value), 1);
 
     case CSSPropertyColumnCount:
-      return clampTo<unsigned short>(round(value), 1);
+      return clampTo<uint16_t>(round(value), 1);
 
     case CSSPropertyColumnRuleWidth:
-      return clampTo<unsigned short>(round(value));
+      return clampTo<uint16_t>(round(value));
 
     case CSSPropertyOrder:
     case CSSPropertyZIndex:
@@ -140,7 +140,7 @@ bool NumberPropertyFunctions::SetNumber(const CSSProperty& property,
       style.SetFloodOpacity(value);
       return true;
     case CSSPropertyLineHeight:
-      style.SetLineHeight(Length(value * 100, kPercent));
+      style.SetLineHeight(Length::Percent(value * 100));
       return true;
     case CSSPropertyOpacity:
       style.SetOpacity(value);
diff --git a/chromium/third_party/blink/renderer/core/animation/pending_animations.cc b/chromium/third_party/blink/renderer/core/animation/pending_animations.cc
index 315fb5a545d..491ca011b9f 100644
--- a/chromium/third_party/blink/renderer/core/animation/pending_animations.cc
+++ b/chromium/third_party/blink/renderer/core/animation/pending_animations.cc
@@ -152,7 +152,7 @@ void PendingAnimations::NotifyCompositorAnimationStarted(
     }
     animation->NotifyCompositorStartTime(
         monotonic_animation_start_time -
-        TimeTicksInSeconds(animation->TimelineInternal()->ZeroTime()));
+        animation->TimelineInternal()->ZeroTime().since_origin().InSecondsF());
   }
 }
 
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline.cc b/chromium/third_party/blink/renderer/core/animation/scroll_timeline.cc
index 63868fca81a..b0e82a3c050 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline.cc
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline.cc
@@ -110,21 +110,23 @@ ScrollTimeline* ScrollTimeline::Create(Document& document,
 
   return MakeGarbageCollected<ScrollTimeline>(
       scroll_source, orientation, start_scroll_offset, end_scroll_offset,
-      options->timeRange().GetAsDouble());
+      options->timeRange().GetAsDouble(),
+      Timing::StringToFillMode(options->fill()));
 }
 
 ScrollTimeline::ScrollTimeline(Element* scroll_source,
                                ScrollDirection orientation,
                                CSSPrimitiveValue* start_scroll_offset,
                                CSSPrimitiveValue* end_scroll_offset,
-                               double time_range)
+                               double time_range,
+                               Timing::FillMode fill)
     : scroll_source_(scroll_source),
       resolved_scroll_source_(ResolveScrollSource(scroll_source_)),
       orientation_(orientation),
       start_scroll_offset_(start_scroll_offset),
       end_scroll_offset_(end_scroll_offset),
-      time_range_(time_range) {
-}
+      time_range_(time_range),
+      fill_(fill) {}
 
 double ScrollTimeline::currentTime(bool& is_null) {
   is_null = true;
@@ -150,30 +152,35 @@ double ScrollTimeline::currentTime(bool& is_null) {
   ResolveScrollStartAndEnd(layout_box, max_offset, resolved_start_scroll_offset,
                            resolved_end_scroll_offset);
 
-  // 3. If current scroll offset is less than startScrollOffset, return an
-  // unresolved time value if fill is none or forwards, or 0 otherwise.
-  // TODO(smcgruer): Implement |fill|.
+  // 3. If current scroll offset is less than startScrollOffset:
   if (current_offset < resolved_start_scroll_offset) {
-    return std::numeric_limits<double>::quiet_NaN();
+    // Return an unresolved time value if fill is none or forwards.
+    if (fill_ == Timing::FillMode::NONE || fill_ == Timing::FillMode::FORWARDS)
+      return std::numeric_limits<double>::quiet_NaN();
+
+    // Otherwise, return 0.
+    is_null = false;
+    return 0;
   }
 
-  // 4. If current scroll offset is greater than or equal to endScrollOffset,
-  // return an unresolved time value if fill is none or backwards, or the
-  // effective time range otherwise.
-  //
-  // TODO(smcgruer): Implement |fill|.
-  //
-  // Note we deliberately break the spec here by only returning if the current
-  // offset is strictly greater, as that is more in line with the web animation
-  // spec. See https://github.com/WICG/scroll-animations/issues/19
-  if (current_offset > resolved_end_scroll_offset) {
-    return std::numeric_limits<double>::quiet_NaN();
+  // 4. If current scroll offset is greater than or equal to endScrollOffset:
+  if (current_offset >= resolved_end_scroll_offset) {
+    // If endScrollOffset is less than the maximum scroll offset of scrollSource
+    // in orientation and fill is none or backwards, return an unresolved time
+    // value.
+    if (resolved_end_scroll_offset < max_offset &&
+        (fill_ == Timing::FillMode::NONE ||
+         fill_ == Timing::FillMode::BACKWARDS)) {
+      return std::numeric_limits<double>::quiet_NaN();
+    }
+
+    // Otherwise, return the effective time range.
+    is_null = false;
+    return time_range_;
   }
 
-  // This is not by the spec, but avoids both negative current time and a
-  // divsion by zero issue. See
-  // https://github.com/WICG/scroll-animations/issues/20 and
-  // https://github.com/WICG/scroll-animations/issues/21
+  // This is not by the spec, but avoids a negative current time.
+  // See https://github.com/WICG/scroll-animations/issues/20
   if (resolved_start_scroll_offset >= resolved_end_scroll_offset) {
     return std::numeric_limits<double>::quiet_NaN();
   }
@@ -219,6 +226,9 @@ void ScrollTimeline::timeRange(DoubleOrScrollTimelineAutoKeyword& result) {
   result.SetDouble(time_range_);
 }
 
+String ScrollTimeline::fill() {
+  return Timing::FillModeString(fill_);
+}
 
 void ScrollTimeline::GetCurrentAndMaxOffset(const LayoutBox* layout_box,
                                             double& current_offset,
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline.h b/chromium/third_party/blink/renderer/core/animation/scroll_timeline.h
index a78393c25c8..5a468ee5b58 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline.h
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline.h
@@ -7,6 +7,7 @@
 
 #include "third_party/blink/renderer/core/animation/animation_timeline.h"
 #include "third_party/blink/renderer/core/animation/scroll_timeline_options.h"
+#include "third_party/blink/renderer/core/animation/timing.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/css/css_primitive_value.h"
 #include "third_party/blink/renderer/core/dom/element.h"
@@ -43,7 +44,8 @@ class CORE_EXPORT ScrollTimeline final : public AnimationTimeline {
                  ScrollDirection,
                  CSSPrimitiveValue*,
                  CSSPrimitiveValue*,
-                 double);
+                 double,
+                 Timing::FillMode);
 
   // AnimationTimeline implementation.
   double currentTime(bool& is_null) final;
@@ -55,6 +57,7 @@ class CORE_EXPORT ScrollTimeline final : public AnimationTimeline {
   String startScrollOffset();
   String endScrollOffset();
   void timeRange(DoubleOrScrollTimelineAutoKeyword&);
+  String fill();
 
   // Returns the Node that should actually have the ScrollableArea (if one
   // exists). This can differ from |scrollSource| when |scroll_source_| is the
@@ -63,6 +66,7 @@ class CORE_EXPORT ScrollTimeline final : public AnimationTimeline {
   Node* ResolvedScrollSource() const { return resolved_scroll_source_; }
 
   ScrollDirection GetOrientation() const { return orientation_; }
+  Timing::FillMode GetFillMode() const { return fill_; }
 
   void GetCurrentAndMaxOffset(const LayoutBox*,
                               double& current_offset,
@@ -96,6 +100,7 @@ class CORE_EXPORT ScrollTimeline final : public AnimationTimeline {
   Member<CSSPrimitiveValue> start_scroll_offset_;
   Member<CSSPrimitiveValue> end_scroll_offset_;
   double time_range_;
+  Timing::FillMode fill_;
 };
 
 DEFINE_TYPE_CASTS(ScrollTimeline,
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline.idl b/chromium/third_party/blink/renderer/core/animation/scroll_timeline.idl
index fb29483e14b..91fad5c521a 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline.idl
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline.idl
@@ -16,4 +16,5 @@
     readonly attribute DOMString startScrollOffset;
     readonly attribute DOMString endScrollOffset;
     readonly attribute (double or ScrollTimelineAutoKeyword) timeRange;
+    readonly attribute FillMode fill;
 };
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_options.idl b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_options.idl
index 74e907227c7..aef61713958 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_options.idl
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_options.idl
@@ -19,4 +19,5 @@ dictionary ScrollTimelineOptions {
         DOMString startScrollOffset = "auto";
         DOMString endScrollOffset = "auto";
         (double or ScrollTimelineAutoKeyword) timeRange = "auto";
+        FillMode fill = "none";
 };
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_test.cc b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_test.cc
index 0ea4dcba6c0..92bbbb92061 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_test.cc
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_test.cc
@@ -229,7 +229,7 @@ TEST_F(ScrollTimelineTest, AttachOrDetachAnimationWithNullScrollSource) {
   CSSPrimitiveValue* end_scroll_offset = nullptr;
   ScrollTimeline* scroll_timeline = MakeGarbageCollected<ScrollTimeline>(
       scroll_source, ScrollTimeline::Block, start_scroll_offset,
-      end_scroll_offset, 100);
+      end_scroll_offset, 100, Timing::FillMode::NONE);
 
   // Sanity checks.
   ASSERT_EQ(scroll_timeline->scrollSource(), nullptr);
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util.cc b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util.cc
index c9667a02f43..5778cfff289 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util.cc
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util.cc
@@ -52,7 +52,7 @@ std::unique_ptr<CompositorScrollTimeline> ToCompositorScrollTimeline(
 
   return std::make_unique<CompositorScrollTimeline>(
       element_id, orientation, start_scroll_offset, end_scroll_offset,
-      time_range.GetAsDouble());
+      time_range.GetAsDouble(), scroll_timeline->GetFillMode());
 }
 
 base::Optional<CompositorElementId> GetCompositorScrollElementId(
diff --git a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util_test.cc b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util_test.cc
index cd0ec23e17c..8f7c41e71c5 100644
--- a/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util_test.cc
+++ b/chromium/third_party/blink/renderer/core/animation/scroll_timeline_util_test.cc
@@ -81,7 +81,7 @@ TEST_F(ScrollTimelineUtilTest, ToCompositorScrollTimelineNullScrollSource) {
   CSSPrimitiveValue* end_scroll_offset = nullptr;
   ScrollTimeline* timeline = MakeGarbageCollected<ScrollTimeline>(
       scroll_source, ScrollTimeline::Block, start_scroll_offset,
-      end_scroll_offset, 100);
+      end_scroll_offset, 100, Timing::FillMode::NONE);
 
   std::unique_ptr<CompositorScrollTimeline> compositor_timeline =
       ToCompositorScrollTimeline(timeline);
diff --git a/chromium/third_party/blink/renderer/core/animation/size_interpolation_functions.cc b/chromium/third_party/blink/renderer/core/animation/size_interpolation_functions.cc
index a7032b228af..6488247fa13 100644
--- a/chromium/third_party/blink/renderer/core/animation/size_interpolation_functions.cc
+++ b/chromium/third_party/blink/renderer/core/animation/size_interpolation_functions.cc
@@ -180,7 +180,7 @@ static Length CreateLength(
     const CSSToLengthConversionData& conversion_data) {
   if (non_interpolable_value.IsKeyword()) {
     DCHECK_EQ(non_interpolable_value.Keyword(), CSSValueAuto);
-    return Length(kAuto);
+    return Length::Auto();
   }
   return LengthInterpolationFunctions::CreateLength(
       interpolable_value, non_interpolable_value.LengthNonInterpolableValue(),
diff --git a/chromium/third_party/blink/renderer/core/animation/svg_transform_list_interpolation_type.cc b/chromium/third_party/blink/renderer/core/animation/svg_transform_list_interpolation_type.cc
index 2eb432cd652..24f6766723d 100644
--- a/chromium/third_party/blink/renderer/core/animation/svg_transform_list_interpolation_type.cc
+++ b/chromium/third_party/blink/renderer/core/animation/svg_transform_list_interpolation_type.cc
@@ -58,7 +58,7 @@ std::unique_ptr<InterpolableValue> TranslateToInterpolableValue(
 SVGTransform* TranslateFromInterpolableValue(const InterpolableValue& value) {
   const InterpolableList& list = ToInterpolableList(value);
 
-  SVGTransform* transform = SVGTransform::Create(kSvgTransformTranslate);
+  SVGTransform* transform = SVGTransform::Create(SVGTransformType::kTranslate);
   transform->SetTranslate(ToInterpolableNumber(list.Get(0))->Value(),
                           ToInterpolableNumber(list.Get(1))->Value());
   return transform;
@@ -76,7 +76,7 @@ std::unique_ptr<InterpolableValue> ScaleToInterpolableValue(
 SVGTransform* ScaleFromInterpolableValue(const InterpolableValue& value) {
   const InterpolableList& list = ToInterpolableList(value);
 
-  SVGTransform* transform = SVGTransform::Create(kSvgTransformScale);
+  SVGTransform* transform = SVGTransform::Create(SVGTransformType::kScale);
   transform->SetScale(ToInterpolableNumber(list.Get(0))->Value(),
                       ToInterpolableNumber(list.Get(1))->Value());
   return transform;
@@ -95,7 +95,7 @@ std::unique_ptr<InterpolableValue> RotateToInterpolableValue(
 SVGTransform* RotateFromInterpolableValue(const InterpolableValue& value) {
   const InterpolableList& list = ToInterpolableList(value);
 
-  SVGTransform* transform = SVGTransform::Create(kSvgTransformRotate);
+  SVGTransform* transform = SVGTransform::Create(SVGTransformType::kRotate);
   transform->SetRotate(ToInterpolableNumber(list.Get(0))->Value(),
                        ToInterpolableNumber(list.Get(1))->Value(),
                        ToInterpolableNumber(list.Get(2))->Value());
@@ -108,7 +108,7 @@ std::unique_ptr<InterpolableValue> SkewXToInterpolableValue(
 }
 
 SVGTransform* SkewXFromInterpolableValue(const InterpolableValue& value) {
-  SVGTransform* transform = SVGTransform::Create(kSvgTransformSkewx);
+  SVGTransform* transform = SVGTransform::Create(SVGTransformType::kSkewx);
   transform->SetSkewX(ToInterpolableNumber(value).Value());
   return transform;
 }
@@ -119,7 +119,7 @@ std::unique_ptr<InterpolableValue> SkewYToInterpolableValue(
 }
 
 SVGTransform* SkewYFromInterpolableValue(const InterpolableValue& value) {
-  SVGTransform* transform = SVGTransform::Create(kSvgTransformSkewy);
+  SVGTransform* transform = SVGTransform::Create(SVGTransformType::kSkewy);
   transform->SetSkewY(ToInterpolableNumber(value).Value());
   return transform;
 }
@@ -128,18 +128,18 @@ std::unique_ptr<InterpolableValue> ToInterpolableValue(
     SVGTransform* transform,
     SVGTransformType transform_type) {
   switch (transform_type) {
-    case kSvgTransformTranslate:
+    case SVGTransformType::kTranslate:
       return TranslateToInterpolableValue(transform);
-    case kSvgTransformScale:
+    case SVGTransformType::kScale:
       return ScaleToInterpolableValue(transform);
-    case kSvgTransformRotate:
+    case SVGTransformType::kRotate:
       return RotateToInterpolableValue(transform);
-    case kSvgTransformSkewx:
+    case SVGTransformType::kSkewx:
       return SkewXToInterpolableValue(transform);
-    case kSvgTransformSkewy:
+    case SVGTransformType::kSkewy:
       return SkewYToInterpolableValue(transform);
-    case kSvgTransformMatrix:
-    case kSvgTransformUnknown:
+    case SVGTransformType::kMatrix:
+    case SVGTransformType::kUnknown:
       NOTREACHED();
   }
   NOTREACHED();
@@ -149,18 +149,18 @@ std::unique_ptr<InterpolableValue> ToInterpolableValue(
 SVGTransform* FromInterpolableValue(const InterpolableValue& value,
                                     SVGTransformType transform_type) {
   switch (transform_type) {
-    case kSvgTransformTranslate:
+    case SVGTransformType::kTranslate:
       return TranslateFromInterpolableValue(value);
-    case kSvgTransformScale:
+    case SVGTransformType::kScale:
       return ScaleFromInterpolableValue(value);
-    case kSvgTransformRotate:
+    case SVGTransformType::kRotate:
       return RotateFromInterpolableValue(value);
-    case kSvgTransformSkewx:
+    case SVGTransformType::kSkewx:
       return SkewXFromInterpolableValue(value);
-    case kSvgTransformSkewy:
+    case SVGTransformType::kSkewy:
       return SkewYFromInterpolableValue(value);
-    case kSvgTransformMatrix:
-    case kSvgTransformUnknown:
+    case SVGTransformType::kMatrix:
+    case SVGTransformType::kUnknown:
       NOTREACHED();
   }
   NOTREACHED();
@@ -224,7 +224,7 @@ InterpolationValue SVGTransformListInterpolationType::MaybeConvertSVGValue(
   for (wtf_size_t i = 0; i < svg_list.length(); i++) {
     const SVGTransform* transform = svg_list.at(i);
     SVGTransformType transform_type(transform->TransformType());
-    if (transform_type == kSvgTransformMatrix) {
+    if (transform_type == SVGTransformType::kMatrix) {
       // TODO(ericwilligers): Support matrix interpolation.
       return nullptr;
     }
diff --git a/chromium/third_party/blink/renderer/core/animation/test_data/transform-animation-update.html b/chromium/third_party/blink/renderer/core/animation/test_data/transform-animation-update.html
new file mode 100644
index 00000000000..4f011a80917
--- /dev/null
+++ b/chromium/third_party/blink/renderer/core/animation/test_data/transform-animation-update.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<style>
+@keyframes rotate {
+  from {transform: rotateY(180deg);}
+  to {transform: rotateY(0deg);}
+}
+#target {
+  width: 100px;
+  height: 100px;
+  animation: rotate 9999s linear 0s infinite;
+}
+.backface-visible {
+  backface-visibility: visible;
+}
+.backface-hidden {
+  backface-visibility: hidden;
+}
+</style>
+<div id="target" class="backface-visible"></div>
diff --git a/chromium/third_party/blink/renderer/core/animation/timing.cc b/chromium/third_party/blink/renderer/core/animation/timing.cc
index 9f3cdc5a65f..d37f7fff9ee 100644
--- a/chromium/third_party/blink/renderer/core/animation/timing.cc
+++ b/chromium/third_party/blink/renderer/core/animation/timing.cc
@@ -23,6 +23,19 @@ String Timing::FillModeString(FillMode fill_mode) {
   return "none";
 }
 
+Timing::FillMode Timing::StringToFillMode(const String& fill_mode) {
+  if (fill_mode == "none")
+    return Timing::FillMode::NONE;
+  if (fill_mode == "backwards")
+    return Timing::FillMode::BACKWARDS;
+  if (fill_mode == "both")
+    return Timing::FillMode::BOTH;
+  if (fill_mode == "forwards")
+    return Timing::FillMode::FORWARDS;
+  DCHECK_EQ(fill_mode, "auto");
+  return Timing::FillMode::AUTO;
+}
+
 String Timing::PlaybackDirectionString(PlaybackDirection playback_direction) {
   switch (playback_direction) {
     case PlaybackDirection::NORMAL:
diff --git a/chromium/third_party/blink/renderer/core/animation/timing.h b/chromium/third_party/blink/renderer/core/animation/timing.h
index 0903c1315f3..c1be6ade6b4 100644
--- a/chromium/third_party/blink/renderer/core/animation/timing.h
+++ b/chromium/third_party/blink/renderer/core/animation/timing.h
@@ -50,6 +50,7 @@ struct Timing {
   using PlaybackDirection = CompositorKeyframeModel::Direction;
 
   static String FillModeString(FillMode);
+  static FillMode StringToFillMode(const String&);
   static String PlaybackDirectionString(PlaybackDirection);
 
   static const Timing& Defaults() {
diff --git a/chromium/third_party/blink/renderer/core/animation/timing_input.cc b/chromium/third_party/blink/renderer/core/animation/timing_input.cc
index da804826fef..92a29c8f80d 100644
--- a/chromium/third_party/blink/renderer/core/animation/timing_input.cc
+++ b/chromium/third_party/blink/renderer/core/animation/timing_input.cc
@@ -15,19 +15,6 @@
 
 namespace blink {
 namespace {
-Timing::FillMode ConvertFillMode(const String& fill_mode) {
-  if (fill_mode == "none")
-    return Timing::FillMode::NONE;
-  if (fill_mode == "backwards")
-    return Timing::FillMode::BACKWARDS;
-  if (fill_mode == "both")
-    return Timing::FillMode::BOTH;
-  if (fill_mode == "forwards")
-    return Timing::FillMode::FORWARDS;
-  DCHECK_EQ(fill_mode, "auto");
-  return Timing::FillMode::AUTO;
-}
-
 Timing::PlaybackDirection ConvertPlaybackDirection(const String& direction) {
   if (direction == "reverse")
     return Timing::PlaybackDirection::REVERSE;
@@ -184,8 +171,8 @@ bool TimingInput::Update(Timing& timing,
     changed |= UpdateValueIfChanged(timing.end_delay, input->endDelay() / 1000);
   }
   if (input->hasFill()) {
-    changed |=
-        UpdateValueIfChanged(timing.fill_mode, ConvertFillMode(input->fill()));
+    changed |= UpdateValueIfChanged(timing.fill_mode,
+                                    Timing::StringToFillMode(input->fill()));
   }
   if (input->hasIterationStart()) {
     changed |=
diff --git a/chromium/third_party/blink/renderer/core/animation/timing_input_test.cc b/chromium/third_party/blink/renderer/core/animation/timing_input_test.cc
index de45cbe72be..7953de5cfae 100644
--- a/chromium/third_party/blink/renderer/core/animation/timing_input_test.cc
+++ b/chromium/third_party/blink/renderer/core/animation/timing_input_test.cc
@@ -380,12 +380,6 @@ TEST_F(AnimationTimingInputTest, TimingInputTimingFunction) {
            .timing_function);
   EXPECT_TRUE(success);
   EXPECT_EQ(
-      *StepsTimingFunction::Preset(StepsTimingFunction::StepPosition::MIDDLE),
-      *ApplyTimingInputString(scope.GetIsolate(), "easing", "step-middle",
-                              success)
-           .timing_function);
-  EXPECT_TRUE(success);
-  EXPECT_EQ(
       *StepsTimingFunction::Preset(StepsTimingFunction::StepPosition::END),
       *ApplyTimingInputString(scope.GetIsolate(), "easing", "step-end", success)
            .timing_function);
@@ -401,12 +395,6 @@ TEST_F(AnimationTimingInputTest, TimingInputTimingFunction) {
                               success)
            .timing_function);
   EXPECT_TRUE(success);
-  EXPECT_EQ(*StepsTimingFunction::Create(
-                5, StepsTimingFunction::StepPosition::MIDDLE),
-            *ApplyTimingInputString(scope.GetIsolate(), "easing",
-                                    "steps(5, middle)", success)
-                 .timing_function);
-  EXPECT_TRUE(success);
   EXPECT_EQ(
       *StepsTimingFunction::Create(5, StepsTimingFunction::StepPosition::END),
       *ApplyTimingInputString(scope.GetIsolate(), "easing", "steps(5, end)",
diff --git a/chromium/third_party/blink/renderer/core/animation/underlying_value_owner.cc b/chromium/third_party/blink/renderer/core/animation/underlying_value_owner.cc
index 9e3b744a123..ccbca95abd0 100644
--- a/chromium/third_party/blink/renderer/core/animation/underlying_value_owner.cc
+++ b/chromium/third_party/blink/renderer/core/animation/underlying_value_owner.cc
@@ -28,8 +28,8 @@ void UnderlyingValueOwner::Set(const InterpolationType& type,
                                const InterpolationValue& value) {
   DCHECK(value);
   type_ = &type;
-  // By clearing m_valueOwner we will perform a copy before attempting to mutate
-  // m_value, thus upholding the const contract for this instance of
+  // By clearing |value_owner_| we will perform a copy before attempting to
+  // mutate |value_|, thus upholding the const contract for this instance of
   // interpolationValue.
   value_owner_.Clear();
   value_ = &value;
diff --git a/chromium/third_party/blink/renderer/core/animation/worklet_animation_controller.h b/chromium/third_party/blink/renderer/core/animation/worklet_animation_controller.h
index 3b9bdb7774b..0acfb2fb95b 100644
--- a/chromium/third_party/blink/renderer/core/animation/worklet_animation_controller.h
+++ b/chromium/third_party/blink/renderer/core/animation/worklet_animation_controller.h
@@ -58,8 +58,6 @@ class CORE_EXPORT WorkletAnimationController
 
   void SetMutationUpdate(
       std::unique_ptr<AnimationWorkletOutput> output) override;
-  void NotifyAnimationsPending() override {}
-  void NotifyAnimationsReady() override {}
 
   void SynchronizeAnimatorName(const String& animator_name) override;
   // Returns true if the animator with given name is registered in