Reuse property trees

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 <algorithm>
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 1165 matching lines @@
                                true,
                                false);
 
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), translate, &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
     EXPECT_EQ(translate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
   }
 
   gfx::Transform scale;
   scale.Scale(2, 2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), scale, &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(scale, root->draw_properties().target_space_transform);
     EXPECT_EQ(scale, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(2.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(2.f, child->draw_properties().device_scale_factor);
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), rotate, &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
     EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
   }
 
   gfx::Transform composite;
   composite.ConcatTransform(translate);
   composite.ConcatTransform(scale);
   composite.ConcatTransform(rotate);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), composite, &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(composite, root->draw_properties().target_space_transform);
     EXPECT_EQ(composite, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   // Verify it composes correctly with device scale.
   float device_scale_factor = 1.5f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), translate, &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_EQ(device_scaled_translate,
               root->draw_properties().target_space_transform);
     EXPECT_EQ(device_scaled_translate,
               child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(device_scale_factor, root->draw_properties().device_scale_factor);
     EXPECT_EQ(device_scale_factor,
               child->draw_properties().device_scale_factor);
   }
 
   // Verify it composes correctly with page scale.
   float page_scale_factor = 2.f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), translate, &render_surface_layer_list);
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
     EXPECT_EQ(page_scaled_translate,
               child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
   }
@@ skipping 3415 matching lines @@
   page_scale_factor = 1.25f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(
         device_scale_factor * page_scale_factor * initial_parent_scale, parent);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                                  initial_parent_scale * initial_child_scale,
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale * initial_child_scale,
                              child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
   }
 
   // If the transform changes, we expect the raster scale to be reset to 1.0.
   SkMScalar second_child_scale = 1.75;
   child_scale_matrix.Scale(second_child_scale / initial_child_scale,
                            second_child_scale / initial_child_scale);
   child_scale->SetTransform(child_scale_matrix);
   child_empty->SetTransform(child_scale_matrix);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
                              parent);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                              child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
   }
 
   // If the device_scale_factor or page_scale_factor changes, then it should be
   // updated, but still using 1.0 as the raster scale.
   device_scale_factor = 2.75f;
   page_scale_factor = 1.75f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
+    inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
                              parent);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                              child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
@@ skipping 4385 matching lines @@
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   gfx::Rect expected(0, 0, 50, 50);
   EXPECT_EQ(expected, fixed->visible_rect_from_property_trees());
 }
 
+TEST_F(LayerTreeHostCommonTest, ChangingAxisAlignmentTriggersRebuild) {
+  gfx::Transform identity;
+  gfx::Transform translate;
+  gfx::Transform rotate;
+
+  translate.Translate(10, 10);
+  rotate.Rotate(45);
+
+  scoped_refptr<Layer> root = Layer::Create();
+  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(800, 800), true, false);
+  root->SetIsContainerForFixedPositionLayers(true);
+
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
+  host->SetRootLayer(root);
+
+  ExecuteCalculateDrawProperties(root.get());
+
+  root->SetTransform(translate);
+  EXPECT_FALSE(host->property_trees()->needs_rebuild);
+
+  root->SetTransform(rotate);
+  EXPECT_TRUE(host->property_trees()->needs_rebuild);
+}
+
 }  // namespace
 }  // namespace cc