cc: Chromify animation_test_common

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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_common.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/thread.h"
 #include "cc/layers/content_layer.h"
@@ skipping 1609 matching lines @@
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Without an animation, we should cull child and grandChild from the renderSurfaceLayerList.
     ASSERT_EQ(1U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
 
     // Now put an animating transform on child.
-    addAnimatedTransformToController(*child->layer_animation_controller(), 10, 30, 0);
+    AddAnimatedTransformToController(child->layer_animation_controller(), 10, 30, 0);
 
     parent->ClearRenderSurface();
     child->ClearRenderSurface();
     grandChild->ClearRenderSurface();
     renderSurfaceLayerList.clear();
 
     LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // With an animating transform, we should keep child and grandChild in the renderSurfaceLayerList.
     ASSERT_EQ(3U, renderSurfaceLayerList.size());
@@ skipping 261 matching lines @@
     setLayerPropertiesForTesting(renderSurface1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface2.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(childOfRoot.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(childOfRS1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(childOfRS2.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRoot.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRS1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRS2.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(2.5, 0), gfx::Size(10, 10), false);
 
     // Put an animated opacity on the render surface.
-    addOpacityTransitionToController(*renderSurface1->layer_animation_controller(), 10, 1, 0, false);
+    AddOpacityTransitionToController(renderSurface1->layer_animation_controller(), 10, 1, 0, false);
 
     // Also put an animated opacity on a layer without descendants.
-    addOpacityTransitionToController(*grandChildOfRoot->layer_animation_controller(), 10, 1, 0, false);
+    AddOpacityTransitionToController(grandChildOfRoot->layer_animation_controller(), 10, 1, 0, false);
 
     // Put a transform animation on the render surface.
-    addAnimatedTransformToController(*renderSurface2->layer_animation_controller(), 10, 30, 0);
+    AddAnimatedTransformToController(renderSurface2->layer_animation_controller(), 10, 30, 0);
 
     // Also put transform animations on grandChildOfRoot, and grandChildOfRS2
-    addAnimatedTransformToController(*grandChildOfRoot->layer_animation_controller(), 10, 30, 0);
-    addAnimatedTransformToController(*grandChildOfRS2->layer_animation_controller(), 10, 30, 0);
+    AddAnimatedTransformToController(grandChildOfRoot->layer_animation_controller(), 10, 30, 0);
+    AddAnimatedTransformToController(grandChildOfRS2->layer_animation_controller(), 10, 30, 0);
 
     executeCalculateDrawProperties(parent.get());
 
     // Only layers that are associated with render surfaces should have an actual RenderSurface() value.
     //
     ASSERT_TRUE(parent->render_surface());
     ASSERT_FALSE(childOfRoot->render_surface());
     ASSERT_FALSE(grandChildOfRoot->render_surface());
 
     ASSERT_TRUE(renderSurface1->render_surface());
@@ skipping 918 matching lines @@
 
     gfx::Transform backfaceMatrix;
     backfaceMatrix.Translate(50, 50);
     backfaceMatrix.RotateAboutYAxis(180);
     backfaceMatrix.Translate(-50, -50);
 
     // Make our render surface.
     animatingSurface->SetForceRenderSurface(true);
 
     // Animate the transform on the render surface.
-    addAnimatedTransformToController(*animatingSurface->layer_animation_controller(), 10, 30, 0);
+    AddAnimatedTransformToController(animatingSurface->layer_animation_controller(), 10, 30, 0);
     // This is just an animating layer, not a surface.
-    addAnimatedTransformToController(*animatingChild->layer_animation_controller(), 10, 30, 0);
+    AddAnimatedTransformToController(animatingChild->layer_animation_controller(), 10, 30, 0);
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(animatingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(childOfAnimatingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(animatingChild.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
@@ skipping 1942 matching lines @@
 
     scoped_refptr<ContentLayer> parent = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true);
 
     scoped_refptr<ContentLayer> childScale = createDrawableContentLayer(&delegate);
     setLayerPropertiesForTesting(childScale.get(), childScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     parent->AddChild(childScale);
 
     // Now put an animating transform on child.
-    int animationId = addAnimatedTransformToController(*childScale->layer_animation_controller(), 10, 30, 0);
+    int animationId = AddAnimatedTransformToController(childScale->layer_animation_controller(), 10, 30, 0);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(initialParentScale, parent);
     // The layers with animating transforms should not compute a contentsScale other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(1, childScale);
 
@@ skipping 288 matching lines @@
 TEST_P(LCDTextTest, verifycan_use_lcd_textWithAnimation)
 {
     // Sanity check: Make sure m_canUseLCDText is set on each node.
     executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
     EXPECT_EQ(m_canUseLCDText, m_root->can_use_lcd_text());
     EXPECT_EQ(m_canUseLCDText, m_child->can_use_lcd_text());
     EXPECT_EQ(m_canUseLCDText, m_grandChild->can_use_lcd_text());
 
     // Add opacity animation.
     m_child->SetOpacity(0.9f);
-    addOpacityTransitionToController(*(m_child->layer_animation_controller()), 10, 0.9f, 0.1f, false);
+    AddOpacityTransitionToController(m_child->layer_animation_controller(), 10, 0.9f, 0.1f, false);
 
     executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
     // Text AA should not be adjusted while animation is active.
     // Make sure LCD text AA setting remains unchanged.
     EXPECT_EQ(m_canUseLCDText, m_root->can_use_lcd_text());
     EXPECT_EQ(m_canUseLCDText, m_child->can_use_lcd_text());
     EXPECT_EQ(m_canUseLCDText, m_grandChild->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(),
                                          testing::Bool()));
 
 }  // namespace
 }  // namespace cc