Get rid of graphics layer anchor points, and replace with transform origin.

cc/layers/layer_utils.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/layers/layer_utils.h"
 
 #include "cc/layers/layer_impl.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "ui/gfx/box_f.h"
 
@@ skipping 57 matching lines @@
 
   // We want to inflate/transform the box as few times as possible. Each time
   // we do this, we have to make the box axis aligned again, so if we make many
   // small adjustments to the box by transforming it repeatedly rather than
   // once by the product of all these matrices, we will accumulate a bunch of
   // unnecessary inflation because of the the many axis-alignment fixes. This
   // matrix stores said product.
   gfx::Transform coalesced_transform;
 
   for (const LayerImpl* layer = &layer_in; layer; layer = layer->parent()) {
-    int anchor_x = layer->anchor_point().x() * layer->bounds().width();
-    int anchor_y = layer->anchor_point().y() * layer->bounds().height();
+    int transform_origin_x = layer->transform_origin().x();
+    int transform_origin_y = layer->transform_origin().y();
+    int transform_origin_z = layer->transform_origin().z();
+
     gfx::PointF position = layer->position();
     if (layer->parent() && !HasAnimationThatInflatesBounds(*layer)) {
       // |composite_layer_transform| contains 1 - 4 mentioned above. We compute
       // it separately and apply afterwards because it's a bit more efficient
       // because post-multiplication appears a bit more expensive, so we want
       // to do it only once.
       gfx::Transform composite_layer_transform;
 
-      composite_layer_transform.Translate3d(anchor_x + position.x(),
-                                            anchor_y + position.y(),
-                                            layer->anchor_point_z());
+      composite_layer_transform.Translate3d(transform_origin_x + position.x(),
+                                            transform_origin_y + position.y(),
+                                            transform_origin_z);
       composite_layer_transform.PreconcatTransform(layer->transform());
       composite_layer_transform.Translate3d(
-          -anchor_x, -anchor_y, -layer->anchor_point_z());
+          -transform_origin_x, -transform_origin_y, -transform_origin_z);
 
       // Add this layer's contributions to the |coalesced_transform|.
       coalesced_transform.ConcatTransform(composite_layer_transform);
       continue;
     }
 
     // First, apply coalesced transform we've been building and reset it.
     coalesced_transform.TransformBox(&box);
     coalesced_transform.MakeIdentity();
 
     // We need to apply the inflation about the layer's anchor point. Rather
     // than doing this via transforms, we'll just shift the box directly.
-    box.set_origin(box.origin() + gfx::Vector3dF(-anchor_x,
-                                                 -anchor_y,
-                                                 -layer->anchor_point_z()));
+    box.set_origin(box.origin() + gfx::Vector3dF(-transform_origin_x,
+                                                 -transform_origin_y,
+                                                 -transform_origin_z));
 
     // Perform the inflation
     if (HasFilterAnimationThatInflatesBounds(*layer)) {
       gfx::BoxF inflated;
       if (!layer->layer_animation_controller()->FilterAnimationBoundsForBox(
               box, &inflated))
         return false;
       box = inflated;
     }
 
     if (HasTransformAnimationThatInflatesBounds(*layer)) {
       gfx::BoxF inflated;
       if (!layer->layer_animation_controller()->TransformAnimationBoundsForBox(
               box, &inflated))
         return false;
       box = inflated;
     }
 
     // Apply step 3) mentioned above.
-    box.set_origin(box.origin() + gfx::Vector3dF(anchor_x + position.x(),
-                                                 anchor_y + position.y(),
-                                                 layer->anchor_point_z()));
+    box.set_origin(box.origin() +
+                   gfx::Vector3dF(transform_origin_x + position.x(),
+                                  transform_origin_y + position.y(),
+                                  transform_origin_z));
   }
 
   // If we've got an unapplied coalesced transform at this point, it must still
   // be applied.
   if (!coalesced_transform.IsIdentity())
     coalesced_transform.TransformBox(&box);
 
   *out = box;
 
   return true;
 }
 
 }  // namespace cc