cc: Abstract the LayerTreeHost.

cc/trees/layer_tree_host_unittest_animation.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <stdint.h>
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_host.h"
@@ skipping 454 matching lines @@
     LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity);
 
 // Layers added to tree with existing active animations should have the
 // animation correctly recognized.
 class LayerTreeHostAnimationTestLayerAddedWithAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       AttachPlayersToTimeline();
 
       scoped_refptr<Layer> layer = Layer::Create();
       layer->SetElementId(ElementId(42, 0));
       player_->AttachElement(layer->element_id());
       player_->set_animation_delegate(this);
 
       // Any valid AnimationCurve will do here.
       std::unique_ptr<AnimationCurve> curve(new FakeFloatAnimationCurve());
       std::unique_ptr<Animation> animation(
@@ skipping 20 matching lines @@
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCancelAnimateCommit()
       : num_begin_frames_(0), num_commit_calls_(0), num_draw_calls_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     num_begin_frames_++;
     // No-op animate will cancel the commit.
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       EndTest();
       return;
     }
     layer_tree_host()->SetNeedsAnimate();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     num_commit_calls_++;
     if (impl->active_tree()->source_frame_number() > 1)
       FAIL() << "Commit should have been canceled.";
@@ skipping 128 matching lines @@
     if (TestEnded())
       return draw_result;
     // Act like there is checkerboard when the second animation wants to draw.
     ++prevented_draw_;
     if (prevented_draw_ > 2)
       EndTest();
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   void DidCommitAndDrawFrame() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // The animation is longer than 1 BeginFrame interval.
         AddOpacityTransitionToPlayer(player_child_.get(), 0.1, 0.2f, 0.8f,
                                      false);
         break;
       case 2:
         // This second animation will not be drawn so it should not start.
         AddAnimatedTransformToPlayer(player_child_.get(), 0.1, 5, 5);
         break;
     }
@@ skipping 40 matching lines @@
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
     player_child_->AttachElement(scroll_layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1: {
         std::unique_ptr<ScrollOffsetAnimationCurve> curve(
             ScrollOffsetAnimationCurve::Create(
                 gfx::ScrollOffset(500.f, 550.f),
                 CubicBezierTimingFunction::CreatePreset(
                     CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
         std::unique_ptr<Animation> animation(Animation::Create(
             std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
         animation->set_needs_synchronized_start_time(true);
         bool impl_scrolling_supported =
@@ skipping 39 matching lines @@
 
     AttachPlayersToTimeline();
     player_child_->AttachElement(scroll_layer_->element_id());
     // Allows NotifyAnimationTakeover to get called.
     player_child_->set_animation_delegate(this);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       // Add an update after the first commit to trigger the animation takeover
       // path.
       layer_tree()
           ->animation_host()
           ->scroll_offset_animations()
           .AddTakeoverUpdate(scroll_layer_->element_id());
       EXPECT_TRUE(layer_tree()
                       ->animation_host()
                       ->scroll_offset_animations()
                       .HasUpdatesForTesting());
@@ skipping 40 matching lines @@
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
     player_child_->AttachElement(scroll_layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       // Add an update after the first commit to trigger the animation update
       // path.
       layer_tree()
           ->animation_host()
           ->scroll_offset_animations()
           .AddAdjustmentUpdate(scroll_layer_->element_id(),
                                gfx::Vector2dF(100.f, 100.f));
       EXPECT_TRUE(layer_tree()
                       ->animation_host()
                       ->scroll_offset_animations()
                       .HasUpdatesForTesting());
-    } else if (layer_tree_host()->source_frame_number() == 2) {
+    } else if (layer_tree_host()->SourceFrameNumber() == 2) {
       // Verify that the update queue is cleared after the update is applied.
       EXPECT_FALSE(layer_tree()
                        ->animation_host()
                        ->scroll_offset_animations()
                        .HasUpdatesForTesting());
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     // Note that the frame number gets incremented after BeginCommitOnThread but
@@ skipping 83 matching lines @@
     animation->set_needs_synchronized_start_time(true);
 
     AttachPlayersToTimeline();
     player_child_->AttachElement(scroll_layer_->element_id());
     player_child_->AddAnimation(std::move(animation));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         break;
       case 1: {
         Animation* animation =
             player_child_->element_animations()
                 ->GetAnimation(TargetProperty::SCROLL_OFFSET);
         player_child_->RemoveAnimation(animation->id());
         scroll_layer_->SetScrollOffset(final_postion_);
         break;
       }
@@ skipping 79 matching lines @@
  public:
   LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers()
       : frame_count_with_pending_tree_(0) {}
 
   void BeginTest() override {
     AttachPlayersToTimeline();
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       player_->AttachElement(layer_tree()->root_layer()->element_id());
       AddAnimatedTransformToPlayer(player_.get(), 4, 1, 1);
-    } else if (layer_tree_host()->source_frame_number() == 2) {
+    } else if (layer_tree_host()->SourceFrameNumber() == 2) {
       AddOpacityTransitionToPlayer(player_.get(), 1, 0.f, 0.5f, true);
 
       scoped_refptr<Layer> layer = Layer::Create();
       layer_tree()->root_layer()->AddChild(layer);
 
       layer_tree()->SetElementIdsForTesting();
       layer->SetBounds(gfx::Size(4, 4));
 
       player_child_->AttachElement(layer->element_id());
       player_child_->set_animation_delegate(this);
@@ skipping 161 matching lines @@
     timeline_->AttachPlayer(player_.get());
     player_->AttachElement(layer_->element_id());
     DCHECK(player_->element_animations());
 
     AddOpacityTransitionToPlayer(player_.get(), 10000.0, 0.1f, 0.9f, true);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         EXPECT_TRUE(
             player_->element_animations()->has_element_in_active_list());
         EXPECT_FALSE(
             player_->element_animations()->has_element_in_pending_list());
         EXPECT_TRUE(layer_tree()->animation_host()->NeedsAnimateLayers());
         break;
       case 1:
         layer_->RemoveFromParent();
         EXPECT_FALSE(
@@ skipping 59 matching lines @@
 
     AttachPlayersToTimeline();
 
     player_->AttachElement(layer_tree()->root_layer()->element_id());
     player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // First frame: add an animation to the root layer.
         AddAnimatedTransformToPlayer(player_.get(), 0.1, 5, 5);
         break;
       case 2:
         // Second frame: add an animation to the content layer. The root layer
         // animation has caused us to animate already during this frame.
         AddOpacityTransitionToPlayer(player_child_.get(), 0.1, 5, 5, false);
         break;
     }
@@ skipping 54 matching lines @@
 
     AttachPlayersToTimeline();
 
     player_->AttachElement(layer_tree()->root_layer()->element_id());
     player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 5, 5);
         break;
       case 2:
         Animation* animation =
             player_child_->element_animations()->GetAnimation(
                 TargetProperty::TRANSFORM);
         player_child_->RemoveAnimation(animation->id());
         gfx::Transform transform;
         transform.Translate(10.f, 10.f);
@@ skipping 58 matching lines @@
     client_.set_bounds(layer_->bounds());
     layer_tree()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
     player_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         AddAnimatedTransformToPlayer(player_.get(), 1.0, 5, 5);
         break;
       case 2:
         Animation* animation = player_->element_animations()->GetAnimation(
             TargetProperty::TRANSFORM);
         player_->RemoveAnimation(animation->id());
         break;
     }
   }
@@ skipping 62 matching lines @@
 
     AttachPlayersToTimeline();
 
     player_->AttachElement(layer_tree()->root_layer()->element_id());
     player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1)
+    if (layer_tree_host()->SourceFrameNumber() == 1)
       AddAnimatedTransformToPlayer(player_child_.get(), 0.04, 5, 5);
   }
 
   void WillCommit() override {
-    if (layer_tree_host()->source_frame_number() == 2) {
+    if (layer_tree_host()->SourceFrameNumber() == 2) {
       // Block until the animation finishes on the compositor thread. Since
       // animations have already been ticked on the main thread, when the commit
       // happens the state on the main thread will be consistent with having a
       // running animation but the state on the compositor thread will be
       // consistent with having only a finished animation.
       completion_.Wait();
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 122 matching lines @@
         EndTest();
         break;
       default:
         break;
     }
   }
 
   void DidCommit() override { PostSetNeedsCommitToMainThread(); }
 
   void WillBeginMainFrame() override {
-    if (layer_tree_host()->source_frame_number() == 2) {
+    if (layer_tree_host()->SourceFrameNumber() == 2) {
       // Destroy player.
       timeline_->DetachPlayer(player_.get());
       player_ = nullptr;
       timeline_->AttachPlayer(player_child_.get());
       player_child_->AttachElement(layer_tree()->root_layer()->element_id());
       AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 10, 10);
       Animation* animation = player_child_->element_animations()->GetAnimation(
           TargetProperty::TRANSFORM);
       animation->set_start_time(base::TimeTicks::Now() +
                                 base::TimeDelta::FromSecondsD(1000));
@@ skipping 31 matching lines @@
     } else {
       EXPECT_FALSE(host_impl->pending_tree()
                        ->root_layer_for_testing()
                        ->screen_space_transform_is_animating());
     }
   }
 
   void DidCommit() override { PostSetNeedsCommitToMainThread(); }
 
   void UpdateLayerTreeHost() override {
-    if (layer_tree_host()->source_frame_number() == 2) {
+    if (layer_tree_host()->SourceFrameNumber() == 2) {
       // Destroy player.
       timeline_->DetachPlayer(player_.get());
       player_ = nullptr;
     }
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     const bool screen_space_transform_is_animating =
@@ skipping 49 matching lines @@
 
     AttachPlayersToTimeline();
 
     player_->AttachElement(layer_tree()->root_layer()->element_id());
     player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1 ||
-        layer_tree_host()->source_frame_number() == 2)
+    if (layer_tree_host()->SourceFrameNumber() == 1 ||
+        layer_tree_host()->SourceFrameNumber() == 2)
       PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       EXPECT_FALSE(layer_tree()->property_trees()->needs_rebuild);
       AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 5, 5);
     }
 
     EXPECT_TRUE(layer_tree()->property_trees()->needs_rebuild);
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() >= 2)
       EndTest();
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit);
 
 }  // namespace
 }  // namespace cc