Remove owning_id from EffectNode and replace it by an opaque stable_id

cc/input/scrollbar_animation_controller_unittest.cc

 // Copyright 2013 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/input/scrollbar_animation_controller.h"
 
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
+#include "cc/test/layer_test_common.h"
 #include "cc/test/test_task_graph_runner.h"
+#include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::AtLeast;
 using testing::Mock;
 using testing::NiceMock;
 using testing::_;
 
 namespace cc {
@@ skipping 36 matching lines @@
   LayerTreeHostImpl* host_impl_;
 };
 
 class ScrollbarAnimationControllerAuraOverlayTest : public testing::Test {
  public:
   ScrollbarAnimationControllerAuraOverlayTest()
       : host_impl_(&task_runner_provider_, &task_graph_runner_),
         client_(&host_impl_) {}
 
   void ExpectScrollbarsOpacity(float opacity) {
-    EXPECT_FLOAT_EQ(opacity, v_scrollbar_layer_->Opacity());
-    EXPECT_FLOAT_EQ(opacity, h_scrollbar_layer_->Opacity());
+    EXPECT_FLOAT_EQ(opacity, OpacityForLayer(v_scrollbar_layer_));
+    EXPECT_FLOAT_EQ(opacity, OpacityForLayer(h_scrollbar_layer_));
   }
 
  protected:
   const base::TimeDelta kFadeDelay = base::TimeDelta::FromSeconds(4);
   const base::TimeDelta kFadeDuration = base::TimeDelta::FromSeconds(3);
   const base::TimeDelta kThinningDuration = base::TimeDelta::FromSeconds(2);
 
   void SetUp() override {
     std::unique_ptr<LayerImpl> scroll_layer =
         LayerImpl::Create(host_impl_.active_tree(), 1);
@@ skipping 120 matching lines @@
   ASSERT_TRUE(scroll_layer);
   EXPECT_EQ(gfx::Size(200, 200), scroll_layer->bounds());
 
   // Shrink along X axis, horizontal scrollbar should appear.
   clip_layer_->SetBounds(gfx::Size(100, 200));
   EXPECT_EQ(gfx::Size(100, 200), clip_layer_->bounds());
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->Opacity());
+
+  EXPECT_FLOAT_EQ(1, OpacityForLayer(h_scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 
   // Shrink along Y axis and expand along X, horizontal scrollbar
   // should disappear.
   clip_layer_->SetBounds(gfx::Size(200, 100));
   EXPECT_EQ(gfx::Size(200, 100), clip_layer_->bounds());
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(0.0f, h_scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(h_scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 // Scroll content. Confirm the scrollbar appears and fades out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicAppearAndFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Scrollbar should be invisible.
@@ skipping 1049 matching lines @@
 
 class VerticalScrollbarAnimationControllerAndroidTest
     : public ScrollbarAnimationControllerAndroidTest {
  protected:
   ScrollbarOrientation orientation() const override { return VERTICAL; }
 };
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, HiddenInBegin) {
   scrollbar_layer_->SetOverlayScrollbarLayerOpacityAnimated(0.f);
   scrollbar_controller_->Animate(base::TimeTicks());
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest,
        HiddenAfterNonScrollingGesture) {
   scrollbar_layer_->SetOverlayScrollbarLayerOpacityAnimated(0.f);
   scrollbar_controller_->DidScrollBegin();
 
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(100);
   scrollbar_controller_->Animate(time);
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+
+  float opacity = scrollbar_layer_->layer_tree_impl()
+                      ->property_trees()
+                      ->effect_tree.Node(scrollbar_layer_->effect_tree_index())
+                      ->opacity;
+  EXPECT_FLOAT_EQ(0.0f, opacity);
   scrollbar_controller_->DidScrollEnd();
 
   EXPECT_TRUE(start_fade_.Equals(base::Closure()));
 
   time += base::TimeDelta::FromSeconds(100);
   scrollbar_controller_->Animate(time);
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 }
 
 // Confirm the scrollbar does not appear on WillUpdateScroll on Android.
 TEST_F(ScrollbarAnimationControllerAndroidTest,
        WillUpdateScrollNotAppearScrollbar) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Scrollbar should be invisible.
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
 
   // Scrollbar should appear when scroll will update.
   scrollbar_controller_->WillUpdateScroll();
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
 
   // No fade out animation should have been enqueued.
   EXPECT_TRUE(start_fade_.Equals(base::Closure()));
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnResize) {
   LayerImpl* scroll_layer = host_impl_.active_tree()->LayerById(1);
   ASSERT_TRUE(scroll_layer);
   EXPECT_EQ(gfx::Size(200, 200), scroll_layer->bounds());
 
   EXPECT_EQ(HORIZONTAL, scrollbar_layer_->orientation());
 
   // Shrink along X axis, horizontal scrollbar should appear.
   clip_layer_->SetBounds(gfx::Size(100, 200));
   EXPECT_EQ(gfx::Size(100, 200), clip_layer_->bounds());
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 
   // Shrink along Y axis and expand along X, horizontal scrollbar
   // should disappear.
   clip_layer_->SetBounds(gfx::Size(200, 100));
   EXPECT_EQ(gfx::Size(200, 100), clip_layer_->bounds());
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(VerticalScrollbarAnimationControllerAndroidTest, HideOnResize) {
   LayerImpl* scroll_layer = host_impl_.active_tree()->LayerById(1);
   ASSERT_TRUE(scroll_layer);
   EXPECT_EQ(gfx::Size(200, 200), scroll_layer->bounds());
 
   EXPECT_EQ(VERTICAL, scrollbar_layer_->orientation());
 
   // Shrink along X axis, vertical scrollbar should remain invisible.
   clip_layer_->SetBounds(gfx::Size(100, 200));
   EXPECT_EQ(gfx::Size(100, 200), clip_layer_->bounds());
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 
   // Shrink along Y axis and expand along X, vertical scrollbar should appear.
   clip_layer_->SetBounds(gfx::Size(200, 100));
   EXPECT_EQ(gfx::Size(200, 100), clip_layer_->bounds());
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnUserNonScrollableHorz) {
   EXPECT_EQ(HORIZONTAL, scrollbar_layer_->orientation());
 
   LayerImpl* scroll_layer = host_impl_.active_tree()->LayerById(1);
   ASSERT_TRUE(scroll_layer);
   scroll_layer->set_user_scrollable_horizontal(false);
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, ShowOnUserNonScrollableVert) {
   EXPECT_EQ(HORIZONTAL, scrollbar_layer_->orientation());
 
   LayerImpl* scroll_layer = host_impl_.active_tree()->LayerById(1);
   ASSERT_TRUE(scroll_layer);
   scroll_layer->set_user_scrollable_vertical(false);
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(VerticalScrollbarAnimationControllerAndroidTest,
        HideOnUserNonScrollableVert) {
   EXPECT_EQ(VERTICAL, scrollbar_layer_->orientation());
 
   LayerImpl* scroll_layer = host_impl_.active_tree()->LayerById(1);
   ASSERT_TRUE(scroll_layer);
   scroll_layer->set_user_scrollable_vertical(false);
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(VerticalScrollbarAnimationControllerAndroidTest,
        ShowOnUserNonScrollableHorz) {
   EXPECT_EQ(VERTICAL, scrollbar_layer_->orientation());
 
   LayerImpl* scroll_layer = host_impl_.active_tree()->LayerById(1);
   ASSERT_TRUE(scroll_layer);
   scroll_layer->set_user_scrollable_horizontal(false);
 
   scrollbar_controller_->DidScrollBegin();
 
   scrollbar_controller_->DidScrollUpdate();
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, AwakenByScrollingGesture) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollBegin();
   EXPECT_FALSE(did_request_animate_);
 
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   EXPECT_TRUE(start_fade_.Equals(base::Closure()));
 
   time += base::TimeDelta::FromSeconds(100);
 
   scrollbar_controller_->Animate(time);
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
   scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
   start_fade_.Run();
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
 
   time += base::TimeDelta::FromSeconds(2);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   start_fade_.Run();
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
 
   time += base::TimeDelta::FromSeconds(2);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest, AwakenByProgrammaticScroll) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(did_request_animate_);
 
   start_fade_.Run();
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(did_request_animate_);
 
   start_fade_.Run();
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
   time += base::TimeDelta::FromSeconds(2);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollUpdate();
   start_fade_.Run();
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest,
        AnimationPreservedByNonScrollingGesture) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollUpdate();
   start_fade_.Run();
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollBegin();
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(0.0f, OpacityForLayer(scrollbar_layer_));
 }
 
 TEST_F(ScrollbarAnimationControllerAndroidTest,
        AnimationOverriddenByScrollingGesture) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(did_request_animate_);
   start_fade_.Run();
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   scrollbar_controller_->DidScrollBegin();
-  EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(2.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(did_request_animate_);
   did_request_animate_ = false;
-  EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1.0f / 3.0f, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollUpdate();
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1, OpacityForLayer(scrollbar_layer_));
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
-  EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity());
+  EXPECT_FLOAT_EQ(1, OpacityForLayer(scrollbar_layer_));
 }
 
 }  // namespace
 }  // namespace cc