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

cc/trees/layer_tree_host_impl_unittest.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/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 164 matching lines @@
                                            &proxy_,
                                            &stats_instrumentation_,
                                            shared_bitmap_manager_.get(),
                                            0);
     bool init = host_impl_->InitializeRenderer(output_surface.Pass());
     host_impl_->SetViewportSize(gfx::Size(10, 10));
     return init;
   }
 
   void SetupRootLayerImpl(scoped_ptr<LayerImpl> root) {
-    root->SetAnchorPoint(gfx::PointF());
+    root->SetTransformOrigin(gfx::Point3F());
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
     root->SetContentBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
     host_impl_->active_tree()->SetRootLayer(root.Pass());
   }
 
   static void ExpectClearedScrollDeltasRecursive(LayerImpl* layer) {
     ASSERT_EQ(layer->ScrollDelta(), gfx::Vector2d());
@@ skipping 31 matching lines @@
   LayerImpl* CreateScrollAndContentsLayers(LayerTreeImpl* layer_tree_impl,
                                            const gfx::Size& content_size) {
     const int kInnerViewportScrollLayerId = 2;
     const int kInnerViewportClipLayerId = 4;
     const int kPageScaleLayerId = 5;
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(layer_tree_impl, 1);
     root->SetBounds(content_size);
     root->SetContentBounds(content_size);
     root->SetPosition(gfx::PointF());
-    root->SetAnchorPoint(gfx::PointF());
+    root->SetTransformOrigin(gfx::Point3F());
 
     scoped_ptr<LayerImpl> scroll =
         LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
     LayerImpl* scroll_layer = scroll.get();
     scroll->SetIsContainerForFixedPositionLayers(true);
     scroll->SetScrollOffset(gfx::Vector2d());
 
     scoped_ptr<LayerImpl> clip =
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     clip->SetBounds(
         gfx::Size(content_size.width() / 2, content_size.height() / 2));
 
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     scroll->SetScrollClipLayer(clip->id());
     scroll->SetBounds(content_size);
     scroll->SetContentBounds(content_size);
     scroll->SetPosition(gfx::PointF());
-    scroll->SetAnchorPoint(gfx::PointF());
+    scroll->SetTransformOrigin(gfx::Point3F());
     scroll->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, 3);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetContentBounds(content_size);
     contents->SetPosition(gfx::PointF());
-    contents->SetAnchorPoint(gfx::PointF());
+    contents->SetTransformOrigin(gfx::Point3F());
 
     scroll->AddChild(contents.Pass());
     page_scale->AddChild(scroll.Pass());
     clip->AddChild(page_scale.Pass());
     root->AddChild(clip.Pass());
 
     layer_tree_impl->SetRootLayer(root.Pass());
     layer_tree_impl->SetViewportLayersFromIds(
         kPageScaleLayerId, kInnerViewportScrollLayerId, Layer::INVALID_ID);
 
@@ skipping 561 matching lines @@
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   gfx::Size overflow_size(400, 400);
   ASSERT_EQ(1u, scroll_layer->children().size());
   LayerImpl* overflow = scroll_layer->children()[0];
   overflow->SetBounds(overflow_size);
   overflow->SetContentBounds(overflow_size);
   overflow->SetScrollClipLayer(scroll_layer->parent()->id());
   overflow->SetScrollOffset(gfx::Vector2d());
   overflow->SetPosition(gfx::PointF());
-  overflow->SetAnchorPoint(gfx::PointF());
+  overflow->SetTransformOrigin(gfx::Point3F());
 
   DrawFrame();
   gfx::Point scroll_position(10, 10);
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(scroll_position, InputHandler::Wheel));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->TotalScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), overflow->TotalScrollOffset());
 
   gfx::Vector2dF scroll_delta(10, 10);
@@ skipping 825 matching lines @@
     did_draw_called_ = false;
   }
 
  protected:
   DidDrawCheckLayer(LayerTreeImpl* tree_impl, int id)
       : TiledLayerImpl(tree_impl, id),
         will_draw_returns_false_(false),
         will_draw_called_(false),
         append_quads_called_(false),
         did_draw_called_(false) {
-    SetAnchorPoint(gfx::PointF());
+    SetTransformOrigin(gfx::Point3F());
     SetBounds(gfx::Size(10, 10));
     SetContentBounds(gfx::Size(10, 10));
     SetDrawsContent(true);
     set_skips_draw(false);
     draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
 
     scoped_ptr<LayerTilingData> tiler =
         LayerTilingData::Create(gfx::Size(100, 100),
                                 LayerTilingData::HAS_BORDER_TEXELS);
     tiler->SetTilingRect(gfx::Rect(content_bounds()));
@@ skipping 423 matching lines @@
 
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     root_clip->SetBounds(clip_size_);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(layer_size_);
     root->SetContentBounds(layer_size_);
     root->SetPosition(gfx::PointF());
-    root->SetAnchorPoint(gfx::PointF());
+    root->SetTransformOrigin(gfx::Point3F());
     root->SetDrawsContent(false);
     root->SetIsContainerForFixedPositionLayers(true);
     int inner_viewport_scroll_layer_id = root->id();
     int page_scale_layer_id = root_clip->id();
     root_clip->AddChild(root.Pass());
     host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
     host_impl_->active_tree()->SetViewportLayersFromIds(
         page_scale_layer_id, inner_viewport_scroll_layer_id, Layer::INVALID_ID);
     // Set a viewport size that is large enough to contain both the top controls
     // and some content.
@@ skipping 118 matching lines @@
 TEST_F(LayerTreeHostImplTest, ScrollNonCompositedRoot) {
   // Test the configuration where a non-composited root layer is embedded in a
   // scrollable outer layer.
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
 
   scoped_ptr<LayerImpl> content_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   content_layer->SetDrawsContent(true);
   content_layer->SetPosition(gfx::PointF());
-  content_layer->SetAnchorPoint(gfx::PointF());
+  content_layer->SetTransformOrigin(gfx::Point3F());
   content_layer->SetBounds(contents_size);
   content_layer->SetContentBounds(contents_size);
   content_layer->SetContentsScale(2.f, 2.f);
 
   scoped_ptr<LayerImpl> scroll_clip_layer =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   scroll_clip_layer->SetBounds(surface_size);
 
   scoped_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   scroll_layer->SetScrollClipLayer(3);
   scroll_layer->SetBounds(contents_size);
   scroll_layer->SetContentBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
-  scroll_layer->SetAnchorPoint(gfx::PointF());
+  scroll_layer->SetTransformOrigin(gfx::Point3F());
   scroll_layer->AddChild(content_layer.Pass());
   scroll_clip_layer->AddChild(scroll_layer.Pass());
 
   host_impl_->active_tree()->SetRootLayer(scroll_clip_layer.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
@@ skipping 590 matching lines @@
       child_layer_id, scroll_layer->content_bounds(), clip_layer.get());
   gfx::Transform rotate_transform;
   rotate_transform.Translate(-50.0, -50.0);
   rotate_transform.Rotate(child_layer_angle);
   rotate_transform.Translate(50.0, 50.0);
   clip_layer->SetTransform(rotate_transform);
 
   // Only allow vertical scrolling.
   clip_layer->SetBounds(
       gfx::Size(child->bounds().width(), child->bounds().height() / 2));
-  // The rotation depends on the layer's anchor point, and the child layer is a
-  // different size than the clip, so make sure the clip layer's anchor lines
-  // up over the child.
-  clip_layer->SetAnchorPoint(gfx::PointF(0.5, 1.0));
+  // The rotation depends on the layer's transform origin, and the child layer
+  // is a different size than the clip, so make sure the clip layer's origin
+  // lines up over the child.
+  clip_layer->SetTransformOrigin(gfx::Point3F(
+      clip_layer->bounds().width() * 0.5f, clip_layer->bounds().height(), 0.f));
   LayerImpl* child_ptr = child.get();
   clip_layer->AddChild(child.Pass());
   scroll_layer->AddChild(clip_layer.Pass());
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d gesture_scroll_delta(0, 10);
@@ skipping 571 matching lines @@
         has_render_surface_(false),
         quads_appended_(false),
         quad_rect_(5, 5, 5, 5),
         quad_visible_rect_(5, 5, 5, 5),
         resource_id_(resource_provider->CreateResource(
             gfx::Size(1, 1),
             GL_CLAMP_TO_EDGE,
             ResourceProvider::TextureUsageAny,
             RGBA_8888)) {
     resource_provider->AllocateForTesting(resource_id_);
-    SetAnchorPoint(gfx::PointF());
+    SetTransformOrigin(gfx::Point3F());
     SetBounds(gfx::Size(10, 10));
     SetContentBounds(gfx::Size(10, 10));
     SetDrawsContent(true);
   }
 
   bool blend_;
   bool has_render_surface_;
   bool quads_appended_;
   gfx::Rect quad_rect_;
   gfx::Rect opaque_content_rect_;
   gfx::Rect quad_visible_rect_;
   ResourceProvider::ResourceId resource_id_;
 };
 
 TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   {
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
-    root->SetAnchorPoint(gfx::PointF());
+    root->SetTransformOrigin(gfx::Point3F());
     root->SetBounds(gfx::Size(10, 10));
     root->SetContentBounds(root->bounds());
     root->SetDrawsContent(false);
     host_impl_->active_tree()->SetRootLayer(root.Pass());
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    2,
@@ skipping 506 matching lines @@
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
 TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(provider));
   CreateHostImpl(DefaultSettings(), output_surface.Pass());
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   EXPECT_FALSE(provider->TestContext3d()->reshape_called());
   provider->TestContext3d()->clear_reshape_called();
 
   LayerTreeHostImpl::FrameData frame;
   host_impl_->SetViewportSize(gfx::Size(10, 10));
   host_impl_->SetDeviceScaleFactor(1.f);
@@ skipping 52 matching lines @@
                                 shared_bitmap_manager.get(),
                                 0);
   layer_tree_host_impl->InitializeRenderer(output_surface.Pass());
   layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500));
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 2);
   child->SetPosition(gfx::PointF(12.f, 13.f));
-  child->SetAnchorPoint(gfx::PointF());
+  child->SetTransformOrigin(gfx::Point3F());
   child->SetBounds(gfx::Size(14, 15));
   child->SetContentBounds(gfx::Size(14, 15));
   child->SetDrawsContent(true);
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
   root->SetBounds(gfx::Size(500, 500));
   root->SetContentBounds(gfx::Size(500, 500));
   root->SetDrawsContent(true);
   root->AddChild(child.Pass());
   layer_tree_host_impl->active_tree()->SetRootLayer(root.Pass());
 
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
@@ skipping 35 matching lines @@
 
   EXPECT_EQ(TestContextSupport::SWAP,
             context_provider->support()->last_swap_type());
 }
 
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 2);
-  child->SetAnchorPoint(gfx::PointF());
+  child->SetTransformOrigin(gfx::Point3F());
   child->SetBounds(gfx::Size(10, 10));
   child->SetContentBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetForceRenderSurface(true);
   root->AddChild(child.Pass());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
 
   LayerTreeHostImpl::FrameData frame;
 
@@ skipping 235 matching lines @@
   scoped_ptr<LayerImpl> child =
       LayerImpl::Create(my_host_impl->active_tree(), 2);
   scoped_ptr<LayerImpl> grand_child =
       FakeLayerWithQuads::Create(my_host_impl->active_tree(), 3);
 
   gfx::Rect root_rect(0, 0, 100, 100);
   gfx::Rect child_rect(10, 10, 50, 50);
   gfx::Rect grand_child_rect(5, 5, 150, 150);
 
   root->CreateRenderSurface();
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
   root->SetPosition(root_rect.origin());
   root->SetBounds(root_rect.size());
   root->SetContentBounds(root->bounds());
   root->draw_properties().visible_content_rect = root_rect;
   root->SetDrawsContent(false);
   root->render_surface()->SetContentRect(gfx::Rect(root_rect.size()));
 
-  child->SetAnchorPoint(gfx::PointF());
+  child->SetTransformOrigin(gfx::Point3F());
   child->SetPosition(gfx::PointF(child_rect.x(), child_rect.y()));
   child->SetOpacity(0.5f);
   child->SetBounds(gfx::Size(child_rect.width(), child_rect.height()));
   child->SetContentBounds(child->bounds());
   child->draw_properties().visible_content_rect = child_rect;
   child->SetDrawsContent(false);
   child->SetForceRenderSurface(true);
 
-  grand_child->SetAnchorPoint(gfx::PointF());
+  grand_child->SetTransformOrigin(gfx::Point3F());
   grand_child->SetPosition(grand_child_rect.origin());
   grand_child->SetBounds(grand_child_rect.size());
   grand_child->SetContentBounds(grand_child->bounds());
   grand_child->draw_properties().visible_content_rect = grand_child_rect;
   grand_child->SetDrawsContent(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
 
   my_host_impl->active_tree()->SetRootLayer(root.Pass());
@@ skipping 58 matching lines @@
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(context.Pass()));
   CreateHostImpl(DefaultSettings(), output_surface.Pass());
 
   scoped_ptr<LayerImpl> root_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root_layer->SetBounds(gfx::Size(10, 10));
-  root_layer->SetAnchorPoint(gfx::PointF());
+  root_layer->SetTransformOrigin(gfx::Point3F());
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
   FakeVideoFrameProvider provider;
   provider.set_frame(softwareFrame);
   scoped_ptr<VideoLayerImpl> video_layer =
       VideoLayerImpl::Create(host_impl_->active_tree(), 4, &provider);
   video_layer->SetBounds(gfx::Size(10, 10));
-  video_layer->SetAnchorPoint(gfx::PointF());
+  video_layer->SetTransformOrigin(gfx::Point3F());
   video_layer->SetContentBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
   root_layer->AddChild(video_layer.PassAs<LayerImpl>());
 
   scoped_ptr<IOSurfaceLayerImpl> io_surface_layer =
       IOSurfaceLayerImpl::Create(host_impl_->active_tree(), 5);
   io_surface_layer->SetBounds(gfx::Size(10, 10));
-  io_surface_layer->SetAnchorPoint(gfx::PointF());
+  io_surface_layer->SetTransformOrigin(gfx::Point3F());
   io_surface_layer->SetContentBounds(gfx::Size(10, 10));
   io_surface_layer->SetDrawsContent(true);
   io_surface_layer->SetIOSurfaceProperties(1, gfx::Size(10, 10));
   root_layer->AddChild(io_surface_layer.PassAs<LayerImpl>());
 
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
@@ skipping 136 matching lines @@
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
     EXPECT_EQ(expect_to_draw, host_impl_->SwapBuffers(frame));
   }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
 
   // Child layer is in the bottom right corner.
   scoped_ptr<SolidColorLayerImpl> child =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
-  child->SetAnchorPoint(gfx::PointF(0.f, 0.f));
+  child->SetTransformOrigin(gfx::Point3F(0.f, 0.f, 0.f));
   child->SetPosition(gfx::PointF(9.f, 9.f));
   child->SetBounds(gfx::Size(1, 1));
   child->SetContentBounds(gfx::Size(1, 1));
   child->SetDrawsContent(true);
   root->AddChild(child.PassAs<LayerImpl>());
 
   host_impl_->active_tree()->SetRootLayer(root.PassAs<LayerImpl>());
 
   // Draw a frame. In the first frame, the entire viewport should be damaged.
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
@@ skipping 62 matching lines @@
 
   scoped_ptr<FakeMaskLayerImpl> scoped_mask_layer =
       FakeMaskLayerImpl::Create(host_impl_->active_tree(), 4);
   FakeMaskLayerImpl* mask_layer = scoped_mask_layer.get();
   content_layer->SetMaskLayer(scoped_mask_layer.PassAs<LayerImpl>());
 
   gfx::Size root_size(100, 100);
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetPosition(gfx::PointF());
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
 
   gfx::Size scaling_layer_size(50, 50);
   scaling_layer->SetBounds(scaling_layer_size);
   scaling_layer->SetContentBounds(scaling_layer_size);
   scaling_layer->SetPosition(gfx::PointF());
-  scaling_layer->SetAnchorPoint(gfx::PointF());
+  scaling_layer->SetTransformOrigin(gfx::Point3F());
   gfx::Transform scale;
   scale.Scale(2.f, 2.f);
   scaling_layer->SetTransform(scale);
 
   content_layer->SetBounds(scaling_layer_size);
   content_layer->SetContentBounds(scaling_layer_size);
   content_layer->SetPosition(gfx::PointF());
-  content_layer->SetAnchorPoint(gfx::PointF());
+  content_layer->SetTransformOrigin(gfx::Point3F());
   content_layer->SetDrawsContent(true);
 
   mask_layer->SetBounds(scaling_layer_size);
   mask_layer->SetContentBounds(scaling_layer_size);
   mask_layer->SetPosition(gfx::PointF());
-  mask_layer->SetAnchorPoint(gfx::PointF());
+  mask_layer->SetTransformOrigin(gfx::Point3F());
   mask_layer->SetDrawsContent(true);
 
 
   // Check that the tree scaling is correctly taken into account for the mask,
   // that should fully map onto the quad.
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
@@ skipping 89 matching lines @@
 
   scoped_ptr<FakeMaskLayerImpl> scoped_mask_layer =
       FakeMaskLayerImpl::Create(host_impl_->active_tree(), 4);
   FakeMaskLayerImpl* mask_layer = scoped_mask_layer.get();
   content_layer->SetMaskLayer(scoped_mask_layer.PassAs<LayerImpl>());
 
   gfx::Size root_size(100, 100);
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetPosition(gfx::PointF());
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
 
   gfx::Size layer_size(50, 50);
   content_layer->SetBounds(layer_size);
   content_layer->SetContentBounds(layer_size);
   content_layer->SetPosition(gfx::PointF());
-  content_layer->SetAnchorPoint(gfx::PointF());
+  content_layer->SetTransformOrigin(gfx::Point3F());
   content_layer->SetDrawsContent(true);
 
   gfx::Size mask_size(100, 100);
   mask_layer->SetBounds(mask_size);
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetPosition(gfx::PointF());
-  mask_layer->SetAnchorPoint(gfx::PointF());
+  mask_layer->SetTransformOrigin(gfx::Point3F());
   mask_layer->SetDrawsContent(true);
 
   // Check that the mask fills the surface.
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
@@ skipping 116 matching lines @@
 
   scoped_ptr<FakeMaskLayerImpl> scoped_mask_layer =
       FakeMaskLayerImpl::Create(host_impl_->active_tree(), 4);
   FakeMaskLayerImpl* mask_layer = scoped_mask_layer.get();
   replica_layer->SetMaskLayer(scoped_mask_layer.PassAs<LayerImpl>());
 
   gfx::Size root_size(100, 100);
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetPosition(gfx::PointF());
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
 
   gfx::Size layer_size(50, 50);
   content_layer->SetBounds(layer_size);
   content_layer->SetContentBounds(layer_size);
   content_layer->SetPosition(gfx::PointF());
-  content_layer->SetAnchorPoint(gfx::PointF());
+  content_layer->SetTransformOrigin(gfx::Point3F());
   content_layer->SetDrawsContent(true);
 
   gfx::Size mask_size(100, 100);
   mask_layer->SetBounds(mask_size);
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetPosition(gfx::PointF());
-  mask_layer->SetAnchorPoint(gfx::PointF());
+  mask_layer->SetTransformOrigin(gfx::Point3F());
   mask_layer->SetDrawsContent(true);
 
   // Check that the mask fills the surface.
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
@@ skipping 125 matching lines @@
 
   scoped_ptr<FakeMaskLayerImpl> scoped_mask_layer =
       FakeMaskLayerImpl::Create(host_impl_->active_tree(), 5);
   FakeMaskLayerImpl* mask_layer = scoped_mask_layer.get();
   replica_layer->SetMaskLayer(scoped_mask_layer.PassAs<LayerImpl>());
 
   gfx::Size root_size(100, 100);
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetPosition(gfx::PointF());
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
 
   gfx::Size layer_size(50, 50);
   content_layer->SetBounds(layer_size);
   content_layer->SetContentBounds(layer_size);
   content_layer->SetPosition(gfx::PointF());
-  content_layer->SetAnchorPoint(gfx::PointF());
+  content_layer->SetTransformOrigin(gfx::Point3F());
   content_layer->SetDrawsContent(true);
 
   gfx::Size child_size(50, 50);
   content_child_layer->SetBounds(child_size);
   content_child_layer->SetContentBounds(child_size);
   content_child_layer->SetPosition(gfx::Point(50, 0));
-  content_child_layer->SetAnchorPoint(gfx::PointF());
+  content_child_layer->SetTransformOrigin(gfx::Point3F());
   content_child_layer->SetDrawsContent(true);
 
   gfx::Size mask_size(50, 50);
   mask_layer->SetBounds(mask_size);
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetPosition(gfx::PointF());
-  mask_layer->SetAnchorPoint(gfx::PointF());
+  mask_layer->SetTransformOrigin(gfx::Point3F());
   mask_layer->SetDrawsContent(true);
 
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
@@ skipping 85 matching lines @@
 
   scoped_ptr<FakeMaskLayerImpl> scoped_mask_layer =
       FakeMaskLayerImpl::Create(host_impl_->active_tree(), 6);
   FakeMaskLayerImpl* mask_layer = scoped_mask_layer.get();
   content_layer->SetMaskLayer(scoped_mask_layer.PassAs<LayerImpl>());
 
   gfx::Size root_size(100, 100);
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetPosition(gfx::PointF());
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
 
   gfx::Rect clipping_rect(20, 10, 10, 20);
   clipping_layer->SetBounds(clipping_rect.size());
   clipping_layer->SetContentBounds(clipping_rect.size());
   clipping_layer->SetPosition(clipping_rect.origin());
-  clipping_layer->SetAnchorPoint(gfx::PointF());
+  clipping_layer->SetTransformOrigin(gfx::Point3F());
   clipping_layer->SetMasksToBounds(true);
 
   gfx::Size layer_size(50, 50);
   content_layer->SetBounds(layer_size);
   content_layer->SetContentBounds(layer_size);
   content_layer->SetPosition(gfx::Point() - clipping_rect.OffsetFromOrigin());
-  content_layer->SetAnchorPoint(gfx::PointF());
+  content_layer->SetTransformOrigin(gfx::Point3F());
   content_layer->SetDrawsContent(true);
 
   gfx::Size child_size(50, 50);
   content_child_layer->SetBounds(child_size);
   content_child_layer->SetContentBounds(child_size);
   content_child_layer->SetPosition(gfx::Point(50, 0));
-  content_child_layer->SetAnchorPoint(gfx::PointF());
+  content_child_layer->SetTransformOrigin(gfx::Point3F());
   content_child_layer->SetDrawsContent(true);
 
   gfx::Size mask_size(100, 100);
   mask_layer->SetBounds(mask_size);
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetPosition(gfx::PointF());
-  mask_layer->SetAnchorPoint(gfx::PointF());
+  mask_layer->SetTransformOrigin(gfx::Point3F());
   mask_layer->SetDrawsContent(true);
 
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
@@ skipping 688 matching lines @@
   LayerImpl* page_scale_layer =
       host_impl_->active_tree()->LayerById(page_scale_layer_id);
 
   int occluder_layer_id = 6;
   scoped_ptr<LayerImpl> occluder_layer =
       LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
   occluder_layer->SetContentBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF());
-  occluder_layer->SetAnchorPoint(gfx::PointF());
+  occluder_layer->SetTransformOrigin(gfx::Point3F());
 
   // The parent of the occluder is *above* the scroller.
   page_scale_layer->AddChild(occluder_layer.Pass());
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::ScrollUnknown,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollUnknownScrollAncestorMismatch) {
   // If we ray cast a scroller this is on the first layer's ancestor chain, but
   // is not the first scroller we encounter when walking up from the layer, we
   // should also return ScrollUnknown.
   gfx::Size content_size(100, 100);
   SetupScrollAndContentsLayers(content_size);
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
   scroll_layer->SetDrawsContent(true);
 
   int occluder_layer_id = 6;
   scoped_ptr<LayerImpl> occluder_layer =
       LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
   occluder_layer->SetContentBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF(-10.f, -10.f));
-  occluder_layer->SetAnchorPoint(gfx::PointF());
+  occluder_layer->SetTransformOrigin(gfx::Point3F());
 
   int child_scroll_clip_layer_id = 7;
   scoped_ptr<LayerImpl> child_scroll_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_clip_layer_id);
 
   int child_scroll_layer_id = 8;
   scoped_ptr<LayerImpl> child_scroll = CreateScrollableLayer(
       child_scroll_layer_id, content_size, child_scroll_clip.get());
 
   child_scroll->SetPosition(gfx::PointF(10.f, 10.f));
@@ skipping 53 matching lines @@
       host_impl_->active_tree()->LayerById(scroll_layer_id);
 
   int scroll_child_id = 6;
   scoped_ptr<LayerImpl> scroll_child =
       LayerImpl::Create(host_impl_->active_tree(), scroll_child_id);
   scroll_child->SetDrawsContent(true);
   scroll_child->SetBounds(content_size);
   scroll_child->SetContentBounds(content_size);
   // Move the scroll child so it's not hit by our test point.
   scroll_child->SetPosition(gfx::PointF(10.f, 10.f));
-  scroll_child->SetAnchorPoint(gfx::PointF());
+  scroll_child->SetTransformOrigin(gfx::Point3F());
 
   int invisible_scroll_layer_id = 7;
   scoped_ptr<LayerImpl> invisible_scroll =
       CreateScrollableLayer(invisible_scroll_layer_id, content_size, root);
   invisible_scroll->SetDrawsContent(false);
 
   int container_id = 8;
   scoped_ptr<LayerImpl> container =
       LayerImpl::Create(host_impl_->active_tree(), container_id);
 
@@ skipping 20 matching lines @@
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
 
   EXPECT_EQ(7, host_impl_->CurrentlyScrollingLayer()->id());
 }
 
 // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed
 // to CompositorFrameMetadata after SwapBuffers();
 TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetAnchorPoint(gfx::PointF());
+  root->SetTransformOrigin(gfx::Point3F());
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
 
   host_impl_->active_tree()->SetRootLayer(root.PassAs<LayerImpl>());
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
 
@@ skipping 196 matching lines @@
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(inner_viewport);
 
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(outer_viewport);
     inner_scroll->SetContentBounds(outer_viewport);
     inner_scroll->SetPosition(gfx::PointF());
-    inner_scroll->SetAnchorPoint(gfx::PointF());
+    inner_scroll->SetTransformOrigin(gfx::Point3F());
 
     scoped_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(outer_viewport);
     outer_clip->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> outer_scroll =
         LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->SetScrollOffset(gfx::Vector2d());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetContentBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
-    outer_scroll->SetAnchorPoint(gfx::PointF());
+    outer_scroll->SetTransformOrigin(gfx::Point3F());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, 8);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetContentBounds(content_size);
     contents->SetPosition(gfx::PointF());
-    contents->SetAnchorPoint(gfx::PointF());
+    contents->SetTransformOrigin(gfx::Point3F());
 
     outer_scroll->AddChild(contents.Pass());
     outer_clip->AddChild(outer_scroll.Pass());
     inner_scroll->AddChild(outer_clip.Pass());
     page_scale->AddChild(inner_scroll.Pass());
     inner_clip->AddChild(page_scale.Pass());
 
     layer_tree_impl->SetRootLayer(inner_clip.Pass());
     layer_tree_impl->SetViewportLayersFromIds(kPageScaleLayerId,
         kInnerViewportScrollLayerId, kOuterViewportScrollLayerId);
@@ skipping 120 matching lines @@
   FakePictureLayerImpl* active_mask_content =
       static_cast<FakePictureLayerImpl*>(
           host_impl_->active_tree()->root_layer()->children()[0]->mask_layer());
   gfx::Rect r2 = active_mask_content->visible_rect_for_tile_priority();
 
   ASSERT_TRUE(!r2.IsEmpty());
 }
 
 }  // namespace
 }  // namespace cc