Composited Worklet Animations: Fixed updating local time on main thread.

This CL changes how local time of composited worklet animations is updated on main thread:
instead of polling local time on main thread, the local time is posted via animation events
by the composited thread to the main thread.

Design document: https://docs.google.com/document/d/1vUxaKBLDHQv9ACJUQJH4RXjuQTlWIsSiAFYkMrjccyc/edit?usp=sharing

Changes made:
- Expanded AnimationEvent to support worklet animation time update event type.
- Reused existing mechanism of posting animation events to the main thread to support new
  event type.
- Removed "peek" logic.
- Enabled tests that previously failed.

Bug: 943787
Change-Id: I2d285506739ea623e292927d21e54910fb7e24bd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1826872
Reviewed-by: Majid Valipour <[email protected]>
Reviewed-by: Robert Flack <[email protected]>
Commit-Queue: Olga Gerchikov <[email protected]>
Cr-Commit-Position: refs/heads/master@{#706078}

Author: ogerchikov

animation-worklet/inactive-timeline.https.html

@@ -49,6 +49,16 @@
     promise_test(async t => {
       const animation = createScrollLinkedWorkletAnimation(t);
       const scroller = animation.timeline.scrollSource;
+      const target = animation.effect.target;
+
+      // There is no direct way to control when local times of composited
+      // animations are synced to the main thread. This test uses another
+      // composited worklet animation with an always active timeline as an
+      // indicator of when the sync is ready. The sync is done when animation
+      // effect's output has changed as a result of advancing the timeline.
+      const animationRef = createScrollLinkedWorkletAnimation(t);
+      const scrollerRef = animationRef.timeline.scrollSource;
+      const targetRef = animationRef.effect.target;
 
       const maxScroll = scroller.scrollHeight - scroller.clientHeight;
       const timeRange = animation.timeline.timeRange;
@@ -60,6 +70,7 @@
       scroller.scrollTop;
 
       animation.play();
+      animationRef.play();
       assert_equals(animation.currentTime, null,
         'Initial current time must be unresolved in idle state.');
       assert_equals(animation.startTime, null,
@@ -72,6 +83,17 @@
       assert_equals(animation.startTime, null,
         'Initial start time must be unresolved in playing state.');
 
+      scrollerRef.scrollTop = 0.2 * maxScroll;
+
+      // Wait until local times are synced back to the main thread.
+      await waitForAnimationFrameWithCondition(_ => {
+        return animationRef.effect.getComputedTiming().localTime == 200;
+      });
+
+      assert_equals(animation.effect.getComputedTiming().localTime, null,
+        'The underlying effect local time must be undefined while the ' +
+        'timeline is inactive.');
+
       // Make the timeline active.
       scroller.style.display = ""
       scroller.scrollTop;
@@ -81,6 +103,15 @@
       assert_times_equal(animation.startTime, 0,
         'Start time must be initialized.');
 
+      scrollerRef.scrollTop = 0.4 * maxScroll;
+      // Wait until local times are synced back to the main thread.
+      await waitForAnimationFrameWithCondition(_ => {
+        return animationRef.effect.getComputedTiming().localTime == 400;
+      });
+      assert_times_equal(animation.effect.getComputedTiming().localTime, 200,
+        'When the timeline becomes newly active, the underlying effect\'s ' +
+        'timing should be properly updated.');
+
       // Make the timeline inactive again.
       scroller.style.display = "none"
       scroller.scrollTop;
@@ -90,6 +121,16 @@
       assert_equals(animation.startTime, null,
         'Initial start time must be unresolved.');
 
+      scrollerRef.scrollTop = 0.6 * maxScroll;
+      scrollerRef.scrollTop;
+      // Wait until local times are synced back to the main thread.
+      await waitForAnimationFrameWithCondition(_ => {
+        return animationRef.effect.getComputedTiming().localTime == 600;
+      });
+
+      assert_times_equal(animation.effect.getComputedTiming().localTime, 200,
+        'When the timeline becomes newly inactive, the underlying effect\'s ' +
+        'timing should stay unchanged.');
     }, 'When timeline time becomes inactive previous current time must be ' +
        'the current time and start time unresolved');
     done();