cc: Make impl-thread property trees handle fixed-position layers

cc/trees/property_tree_builder.cc

 // Copyright 2014 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/property_tree_builder.h"
 
 #include <map>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 194 matching lines @@
         source_offset = data_from_ancestor.transform_tree_parent
                             ->offset_to_transform_parent();
         source_index =
             data_from_ancestor.transform_tree_parent->transform_tree_index();
       }
       source_offset += data_from_ancestor.scroll_compensation_adjustment;
     }
   }
 
   if (layer->IsContainerForFixedPositionLayers() || is_root) {
-    DCHECK(!is_scrollable || layer->transform().IsIdentity());
-    data_for_children->transform_fixed_parent = layer;
+    if (is_scrollable) {
+      DCHECK(!is_root);
+      DCHECK(layer->transform().IsIdentity());
+      data_for_children->transform_fixed_parent = layer->parent();
+    } else {
+      data_for_children->transform_fixed_parent = layer;
+    }
   }
   data_for_children->transform_tree_parent = layer;
 
   if (layer->IsContainerForFixedPositionLayers() || is_fixed)
     data_for_children->scroll_compensation_adjustment = gfx::Vector2dF();
 
   if (!requires_node) {
     data_for_children->should_flatten |= layer->should_flatten_transform();
     gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
                                   layer->transform().To2dTranslation();
@@ skipping 152 matching lines @@
 }  // namespace
 
 template <typename LayerType>
 void BuildPropertyTreesTopLevelInternal(LayerType* root_layer,
                                         const LayerType* page_scale_layer,
                                         float page_scale_factor,
                                         float device_scale_factor,
                                         const gfx::Rect& viewport,
                                         const gfx::Transform& device_transform,
                                         PropertyTrees* property_trees) {
+  if (!property_trees->needs_rebuild)
+    return;

[ajuma, 2015/05/29 17:47:08]

This change causes about 16 unit tests to fail, since they rely on property
trees being rebuilt every frame. I'm not sure what the best approach is here.
One option would be to change those tests so that they explicitly set
needs_rebuild. Alternatively, we could add a way for tests that don't want to
rebuild (like LayerPositionConstraintTests) to opt out. Making the default be
"don't rebuild" seems better in the sense that non-test impl property trees
aren't rebuilt, so tests that want to rebuild anyway should be making a
conscious choice.

[enne (OOO), 2015/05/29 20:07:53]

Agreed that the default should be don't rebuild unless the flag is set.  Tests
that are doing weird things should mark rebuild explicitly if they really need
it.

+
   property_trees->sequence_number++;
 
   DataForRecursion<LayerType> data_for_recursion;
   data_for_recursion.transform_tree = &property_trees->transform_tree;
   data_for_recursion.clip_tree = &property_trees->clip_tree;
   data_for_recursion.opacity_tree = &property_trees->opacity_tree;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.render_target = root_layer;
   data_for_recursion.clip_tree_parent = 0;
@@ skipping 27 matching lines @@
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
     Layer* root_layer,
     const Layer* page_scale_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
-  // TODO(enne): hoist this out of here
-  if (!property_trees->needs_rebuild)
-    return;
-
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
 }
 
 }  // namespace cc