cc: Move CalculateContentsScale from LayerImpl to LayerTreeHostCommon

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 <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 7848 matching lines @@
  public:
   static scoped_ptr<AnimationScaleFactorTrackingLayerImpl> Create(
       LayerTreeImpl* tree_impl,
       int id) {
     return make_scoped_ptr(
         new AnimationScaleFactorTrackingLayerImpl(tree_impl, id));
   }
 
   virtual ~AnimationScaleFactorTrackingLayerImpl() {}
 
   virtual void CalculateContentsScale(float ideal_contents_scale,

[danakj, 2014/06/13 15:00:27]

Can just remove this method? It's not overriding anything anymore, clang should
complain about it.

[sohanjg, 2014/06/13 15:36:06]

Done.

                                       float device_scale_factor,
                                       float page_scale_factor,
                                       float maximum_animation_contents_scale,
                                       bool animating_transform_to_screen,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
                                       gfx::Size* content_bounds) OVERRIDE {
-    last_maximum_animation_contents_scale_ = maximum_animation_contents_scale;
-    LayerImpl::CalculateContentsScale(ideal_contents_scale,
-                                      device_scale_factor,
-                                      page_scale_factor,
-                                      maximum_animation_contents_scale,
-                                      animating_transform_to_screen,
-                                      contents_scale_x,
-                                      contents_scale_y,
-                                      content_bounds);
-  }
-
-  float last_maximum_animation_contents_scale() {
-    return last_maximum_animation_contents_scale_;
+    this->draw_properties().ideal_contents_scale = ideal_contents_scale;
+    this->draw_properties().device_scale_factor = device_scale_factor;
+    this->draw_properties().page_scale_factor = page_scale_factor;
+    this->draw_properties().maximum_animation_contents_scale =
+        maximum_animation_contents_scale;
+    this->draw_properties().screen_space_transform_is_animating =
+        animating_transform_to_screen;
   }
 
  private:
   explicit AnimationScaleFactorTrackingLayerImpl(LayerTreeImpl* tree_impl,
                                                  int id)
-      : LayerImpl(tree_impl, id), last_maximum_animation_contents_scale_(0.f) {
+      : LayerImpl(tree_impl, id) {
     SetDrawsContent(true);
   }
-
-  float last_maximum_animation_contents_scale_;
 };
 
 TEST_F(LayerTreeHostCommonTest, MaximumAnimationScaleFactor) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   gfx::Transform identity_matrix;
   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> grand_parent =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 1);
   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> parent =
@@ skipping 36 matching lines @@
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
                                false);
 
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // No layers have animations.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   TransformOperations translation;
   translation.AppendTranslate(1.f, 2.f, 3.f);
 
   AddAnimatedTransformToLayer(
       parent_raw, 1.0, TransformOperations(), translation);
 
   // No layers have scale-affecting animations.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 4.f, 3.f);
 
   AddAnimatedTransformToLayer(child_raw, 1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // Only |child| has a scale-affecting animation.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(5.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(5.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(5.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      5.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   AddAnimatedTransformToLayer(
       grand_parent.get(), 1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |grand_parent| and |child| have scale-affecting animations.
-  EXPECT_EQ(5.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(5.f, parent_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(5.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(5.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
   // We don't support combining animated scales from two nodes; 0.f means
   // that the maximum scale could not be computed.
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   AddAnimatedTransformToLayer(parent_raw, 1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |grand_parent|, |parent|, and |child| have scale-affecting animations.
-  EXPECT_EQ(5.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(5.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   grand_parent->layer_animation_controller()->AbortAnimations(
       Animation::Transform);
   parent_raw->layer_animation_controller()->AbortAnimations(
       Animation::Transform);
   child_raw->layer_animation_controller()->AbortAnimations(
       Animation::Transform);
 
   TransformOperations perspective;
   perspective.AppendPerspective(10.f);
 
   AddAnimatedTransformToLayer(
       child_raw, 1.0, TransformOperations(), perspective);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |child| has a scale-affecting animation but computing the maximum of this
   // animation is not supported.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   child_raw->layer_animation_controller()->AbortAnimations(
       Animation::Transform);
 
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
   grand_parent->SetTransform(scale_matrix);
   parent_raw->SetTransform(scale_matrix);
   AddAnimatedTransformToLayer(parent_raw, 1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
   // animation with maximum scale 5.f.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(10.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(10.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(10.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(10.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(10.f,
+            child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      10.f,
+      grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(2.f);
   child_raw->SetTransform(perspective_matrix);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |child| has a transform that's neither a translation nor a scale.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(10.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(10.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   parent_raw->SetTransform(perspective_matrix);
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |parent| and |child| have transforms that are neither translations nor
   // scales.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   parent_raw->SetTransform(identity_matrix);
   child_raw->SetTransform(identity_matrix);
   grand_parent->SetTransform(perspective_matrix);
 
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
-  EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
-  EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
+  EXPECT_EQ(0.f,
+            grand_parent->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f,
+            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(
+      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 }
 
 static int membership_id(LayerImpl* layer) {
   return layer->draw_properties().last_drawn_render_surface_layer_list_id;
 }
 
 static void GatherDrawnLayers(LayerImplList* rsll,
                               std::set<LayerImpl*>* drawn_layers) {
   for (LayerIterator<LayerImpl> it = LayerIterator<LayerImpl>::Begin(rsll),
                                 end = LayerIterator<LayerImpl>::End(rsll);
@@ skipping 500 matching lines @@
   EXPECT_FLOAT_EQ(4.f,
                   child1_layer->replica_layer()
                       ->mask_layer()
                       ->draw_properties()
                       .device_scale_factor);
   EXPECT_FLOAT_EQ(4.f, child2_layer->draw_properties().device_scale_factor);
 }
 
 }  // namespace
 }  // namespace cc