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

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include "base/metrics/histogram.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 22 matching lines @@
       parent_(NULL),
       layer_tree_host_(NULL),
       scrollable_(false),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
       anchor_point_(0.5f, 0.5f),
       background_color_(0),
       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),
       double_sided_(true),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       force_render_surface_(false),
       replica_layer_(NULL),
       raster_scale_(1.f),
@@ skipping 354 matching lines @@
   SetNeedsCommit();
 }
 
 void Layer::SetPosition(gfx::PointF position) {
   if (position_ == position)
     return;
   position_ = 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;
   sublayer_transform_ = sublayer_transform;
   SetNeedsCommit();
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
@@ skipping 97 matching lines @@
 
   // Simply mark the contents as dirty. For non-root layers, the call to
   // SetNeedsCommit will schedule a fresh compositing pass.
   // For the root layer, SetNeedsCommit has no effect.
   if (DrawsContent() && !update_rect_.IsEmpty())
     SetNeedsCommit();
 }
 
 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;
   }
   return false;
 }
 
 void Layer::SetIsContainerForFixedPositionLayers(bool container) {
   if (is_container_for_fixed_position_layers_ == container)
     return;
   is_container_for_fixed_position_layers_ = container;
 
   if (layer_tree_host_ && layer_tree_host_->CommitRequested())
     return;
 
   // Only request a commit if we have a fixed positioned descendant.
   if (DescendantIsFixedToContainerLayer())
     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) {
   layer->SetAnchorPoint(anchor_point_);
   layer->SetAnchorPointZ(anchor_point_z_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(bounds_);
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDebugName(debug_name_);
@@ skipping 10 matching lines @@
   layer->SetHaveWheelEventHandlers(have_wheel_event_handlers_);
   layer->SetNonFastScrollableRegion(non_fast_scrollable_region_);
   layer->SetTouchEventHandlerRegion(touch_event_handler_region_);
   layer->SetContentsOpaque(contents_opaque_);
   if (!layer->OpacityIsAnimatingOnImplOnly())
     layer->SetOpacity(opacity_);
   DCHECK(!(OpacityIsAnimating() && layer->OpacityIsAnimatingOnImplOnly()));
   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_);
   if (!layer->TransformIsAnimatingOnImplOnly())
     layer->SetTransform(transform_);
   DCHECK(!(TransformIsAnimating() && layer->TransformIsAnimatingOnImplOnly()));
 
   layer->SetScrollable(scrollable_);
   layer->SetScrollOffset(scroll_offset_);
   layer->SetMaxScrollOffset(max_scroll_offset_);
@@ skipping 210 matching lines @@
   if (contents_opaque())
     return visible_content_rect();
   return Region();
 }
 
 ScrollbarLayer* Layer::ToScrollbarLayer() {
   return NULL;
 }
 
 }  // namespace cc