Merge 181957

cc/layer_tree_host_common.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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/layer.h"
@@ skipping 151 matching lines @@
     return calculateVisibleRectWithCachedLayerRect(visibleRectInTargetSurfaceSpace, gfx::Rect(gfx::Point(), layer->contentBounds()), layerRectInTargetSpace, layer->drawTransform());
 }
 
 static inline bool transformToParentIsKnown(LayerImpl*)
 {
     return true;
 }
 
 static inline bool transformToParentIsKnown(Layer* layer)
 {
+
     return !layer->transformIsAnimating();
 }
 
 static inline bool transformToScreenIsKnown(LayerImpl*)
 {
     return true;
 }
 
 static inline bool transformToScreenIsKnown(Layer* layer)
 {
@@ skipping 381 matching lines @@
     //    the transform to the anchor point is specified in "layer space", where the bounds
     //    of the layer map to [bounds.width(), bounds.height()].
     //
     // 3. Definition of various transforms used:
     //        M[parent] is the parent matrix, with respect to the nearest render surface, passed down recursively.
     //        M[root] is the full hierarchy, with respect to the root, passed down recursively.
     //        Tr[origin] is the translation matrix from the parent's origin to this layer's origin.
     //        Tr[origin2anchor] is the translation from the layer's origin to its anchor point
     //        Tr[origin2center] is the translation from the layer's origin to its center
     //        M[layer] is the layer's matrix (applied at the anchor point)
-    //        M[sublayer] is the layer's sublayer transform (applied at the layer's center)
+    //        M[sublayer] is the layer's sublayer transform (also applied at the layer's anchor point)
     //        S[layer2content] is the ratio of a layer's contentBounds() to its bounds().
     //
     //    Some composite transforms can help in understanding the sequence of transforms:
     //        compositeLayerTransform = Tr[origin2anchor] * M[layer] * Tr[origin2anchor].inverse()
-    //        compositeSublayerTransform = Tr[origin2center] * M[sublayer] * Tr[origin2center].inverse()
-    //
-    //    In words, the layer transform is applied about the anchor point, and the sublayer transform is
-    //    applied about the center of the layer.
+    //        compositeSublayerTransform = Tr[origin2anchor] * M[sublayer] * Tr[origin2anchor].inverse()
     //
     // 4. When a layer (or render surface) is drawn, it is drawn into a "target render surface". Therefore the draw
     //    transform does not necessarily transform from screen space to local layer space. Instead, the draw transform
     //    is the transform between the "target render surface space" and local layer space. Note that render surfaces,
     //    except for the root, also draw themselves into a different target render surface, and so their draw
     //    transform and origin transforms are also described with respect to the target.
     //
     // Using these definitions, then:
     //
     // The draw transform for the layer is:
@@ skipping 155 matching lines @@
         // scale factor that accounts for the surface's pixel dimensions.
         combinedTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
         renderSurface->setDrawTransform(combinedTransform);
 
         // The owning layer's transform was re-parented by the surface, so the layer's new drawTransform
         // only needs to scale the layer to surface space.
         layerDrawProperties.target_space_transform.MakeIdentity();
         layerDrawProperties.target_space_transform.Scale(renderSurfaceSublayerScale.x() / layer->contentsScaleX(), renderSurfaceSublayerScale.y() / layer->contentsScaleY());
 
         // Inside the surface's subtree, we scale everything to the owning layer's scale.
-        // The sublayer matrix transforms centered layer rects into target
+        // The sublayer matrix transforms layer rects into target
         // surface content space.
         DCHECK(sublayerMatrix.IsIdentity());
         sublayerMatrix.Scale(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
 
         // The opacity value is moved from the layer to its surface, so that the entire subtree properly inherits opacity.
         renderSurface->setDrawOpacity(accumulatedDrawOpacity);
         renderSurface->setDrawOpacityIsAnimating(animatingOpacityToTarget);
         animatingOpacityToTarget = false;
         layerDrawProperties.opacity = 1;
         layerDrawProperties.opacity_is_animating = animatingOpacityToTarget;
@@ skipping 92 matching lines @@
             clipRectForSubtree = clipRectFromAncestor;
             clipRectForSubtree.Intersect(rectInTargetSpace);
         } else
             clipRectForSubtree = rectInTargetSpace;
     }
 
     // Flatten to 2D if the layer doesn't preserve 3D.
     if (!layer->preserves3D())
         sublayerMatrix.FlattenTo2d();
 
-    // Apply the sublayer transform at the center of the layer.
+    // Apply the sublayer transform at the anchor point of the layer.
     if (!layer->sublayerTransform().IsIdentity()) {
-        sublayerMatrix.Translate(0.5 * bounds.width(), 0.5 * bounds.height());
+        sublayerMatrix.Translate(layer->anchorPoint().x() * bounds.width(), layer->anchorPoint().y() * bounds.height());
         sublayerMatrix.PreconcatTransform(layer->sublayerTransform());
-        sublayerMatrix.Translate(-0.5 * bounds.width(), -0.5 * bounds.height());
+        sublayerMatrix.Translate(-layer->anchorPoint().x() * bounds.width(), -layer->anchorPoint().y() * bounds.height());
     }
 
     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
 
     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
     unsigned sortingStartIndex = descendants.size();
 
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
@@ skipping 313 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc