Support bottom-right anchored fixed-position elements during a pinch gesture

cc/layers/layer.cc

Index: cc/layers/layer.cc
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index b07b30855615920ac9295c4587306604f527af76..71c6706dbe979cff8edd1efc781978b2e4bce6a0 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -40,7 +40,6 @@ Layer::Layer()
       opacity_(1.f),
       anchor_point_z_(0.f),
       is_container_for_fixed_position_layers_(false),
-      fixed_to_container_layer_(false),
       is_drawable_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
@@ -415,6 +414,14 @@ void Layer::SetPosition(gfx::PointF position) {
   SetNeedsCommit();
 }
 
+bool Layer::is_container_for_fixed_position_layers() const {

[Sami, 2013/03/25 11:41:37]

Any reason why this is on Layer instead LayerImpl? It seems like this bit should
be updated any time the transforms change and that can happen on the impl side
too.

[trchen, 2013/03/26 01:45:28]

Extra transform may be applied in LayerImpl but transform_ itself never changes
I believe. I do need to push the adjusted flag to LayerImpl though. (which I
forgot. thanks Sami!)

I do agree that promoting a layer with transform animation to fixed container
sounds like the right thing to do. Unfortunately I don't know a good way to
detect that.

+  if (!transform_.IsIdentityOrTranslation())
+    return true;
+  if (parent_ && !parent_->sublayer_transform_.IsIdentityOrTranslation())

[Sami, 2013/03/25 11:41:37]

Should we also check sublayer_transform_ for this layer?

[trchen, 2013/03/26 01:45:28]

It is arguable but I would vote not. The point of the implicit promotion is that
scroll delta compensation can be easily applied after all intermediate
transforms. (i.e. scroll delta compensation is commutative with translation-only
transform)

             scroll delta sub-layer transform transform
PARENT LAYER <----------- <------------------ <-------- CURRENT LAYER

I ideally we want to apply scroll compensation (anti scroll delta) at the place
scroll delta is applied, it is actually what we do now (well not that simple, we
have to inverse all intermediate transforms and apply again). If we guarantee
all transform will be commutative, then we can simply apply a combined scroll
compensation at last.

Let's see the case current layer with sub-layer transform:

              scroll delta sub-layer transform transform
CURRENT LAYER <----------- <------------------ <-------- SUB LAYER(PROMOTED)

No scroll delta will be ever applied BEFORE the sub-layer transform, as the
sub-layer gets promoted to a fixed-container already, absorbing all scroll delta
after it. That means an anti scroll delta transform never needs commutate past
the sub-layer transform.

[shawnsingh, 2013/03/27 19:46:39]

In reply to Sami asking "Should we also check sublayer_transform_ for this
layer" --> I don't think we should be checking both layer and parent for a
non-identity sublayer transform.  Otherwise we'll either potentially get two
consecutive containers where clearly only one of them should have been the
container.  So I think the way trchen has it now is very reasonable =)

However, trchen@ I didn't totally understand your reply.  Also I think the
diagrams you've made are actually wrong.

First, we should rarely ever bring up the concept of matrix commutativity. 
Because matrices are generally not commutative, making decisions based on
assumptions about commutativity will very likely result in bad sequences of
transforms that are very hard to debug.

Second, sublayer transform doesn't fit in the diagram where you've drawn it. 
the scroll delta of a layer is applied to the right hand side (in matrix*vector
math ordering) of the parent's hierarchy matrix passed down the recursion.   the
parent's sublayer transform is inside that hierarchy matrix.   The current
layer's sublayer transform is appended to the right hand side after the layer's
current transform.

Just wanted to set some concepts straight =)  But it doesn't change anything
about the code as it's written here.

+    return true;
+  return is_container_for_fixed_position_layers_;
+}
+
 void Layer::SetSublayerTransform(const gfx::Transform& sublayer_transform) {
   if (sublayer_transform_ == sublayer_transform)
     return;
@@ -532,7 +539,7 @@ void Layer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) {
 
 bool Layer::DescendantIsFixedToContainerLayer() const {
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i]->fixed_to_container_layer() ||
+    if (children_[i]->position_constraint_.is_fixed_position() ||
         children_[i]->DescendantIsFixedToContainerLayer())
       return true;
   }
@@ -552,11 +559,11 @@ void Layer::SetIsContainerForFixedPositionLayers(bool container) {
     SetNeedsCommit();
 }
 
-void Layer::SetFixedToContainerLayer(bool fixed_to_container_layer) {
-  if (fixed_to_container_layer_ == fixed_to_container_layer)
-    return;
-  fixed_to_container_layer_ = fixed_to_container_layer;
-  SetNeedsCommit();
+void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
+    if (position_constraint_ == constraint)
+        return;
+    position_constraint_ = constraint;
+    SetNeedsCommit();
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
@@ -587,7 +594,8 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->SetPosition(position_);
   layer->SetIsContainerForFixedPositionLayers(
       is_container_for_fixed_position_layers_);
-  layer->SetFixedToContainerLayer(fixed_to_container_layer_);
+  layer->SetFixedContainerSizeDelta(gfx::Vector2dF());
+  layer->SetPositionConstraint(position_constraint_);
   layer->SetPreserves3d(preserves_3d());
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);