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

cc/trees/layer_tree_host_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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 983 matching lines @@
   virtual bool Update(ResourceUpdateQueue* queue,
                       const OcclusionTracker<Layer>* occlusion) OVERRIDE {
     bool updated = ContentLayer::Update(queue, occlusion);
     paint_contents_count_++;
     return updated;
   }
 
  private:
   explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
       : ContentLayer(client), paint_contents_count_(0) {
-    SetAnchorPoint(gfx::PointF(0.f, 0.f));
     SetBounds(gfx::Size(10, 10));
     SetIsDrawable(true);
   }
   virtual ~ContentLayerWithUpdateTracking() {}
 
   int paint_contents_count_;
 };
 
 // Layer opacity change during paint should not prevent compositor resources
 // from being updated during commit.
@@ skipping 69 matching lines @@
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
     layer_tree_host()->SetDeviceScaleFactor(1.5);
     EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
 
     root_layer_->AddChild(child_layer_);
 
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(30, 30));
-    root_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetPosition(gfx::Point(2, 2));
     child_layer_->SetBounds(gfx::Size(10, 10));
-    child_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 
     layer_tree_host()->SetRootLayer(root_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // Should only do one commit.
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     // Device scale factor should come over to impl.
@@ skipping 223 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_DELEGATING_RENDERER_NOIMPL_TEST_F(
     LayerTreeHostTestDelegatingRendererAtomicCommit);
 
 static void SetLayerPropertiesForTesting(Layer* layer,
                                          Layer* parent,
                                          const gfx::Transform& transform,
-                                         const gfx::PointF& anchor,
+                                         const gfx::Point3F& transform_origin,
                                          const gfx::PointF& position,
                                          const gfx::Size& bounds,
                                          bool opaque) {
   layer->RemoveAllChildren();
   if (parent)
     parent->AddChild(layer);
   layer->SetTransform(transform);
-  layer->SetAnchorPoint(anchor);
+  layer->SetTransformOrigin(transform_origin);
   layer->SetPosition(position);
   layer->SetBounds(bounds);
   layer->SetContentsOpaque(opaque);
 }
 
 class LayerTreeHostTestAtomicCommitWithPartialUpdate
     : public LayerTreeHostTest {
  public:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->texture_id_allocation_chunk_size = 1;
@@ skipping 357 matching lines @@
         num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetRootLayer(layer_);
     layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
 
     gfx::Transform identity_matrix;
     SetLayerPropertiesForTesting(layer_.get(),
                                  0,
                                  identity_matrix,
-                                 gfx::PointF(0.f, 0.f),
+                                 gfx::Point3F(0.f, 0.f, 0.f),
                                  gfx::PointF(0.f, 0.f),
                                  gfx::Size(10, 20),
                                  true);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void PostEvictTextures() {
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
@@ skipping 146 matching lines @@
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     content_layer_ = ContentLayer::Create(&client_);
     content_layer_->SetBounds(gfx::Size(10, 10));
     content_layer_->SetPosition(gfx::PointF(0.f, 0.f));
-    content_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
     content_layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(content_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     if (num_draw_layers_ == 2)
       return;
     content_layer_->SetNeedsDisplay();
@@ skipping 631 matching lines @@
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostTest::SetupTree();
 
     layer_tree_host()->root_layer()->SetIsDrawable(false);
 
     io_surface_id_ = 9;
     io_surface_size_ = gfx::Size(6, 7);
 
     scoped_refptr<IOSurfaceLayer> io_surface_layer = IOSurfaceLayer::Create();
     io_surface_layer->SetBounds(gfx::Size(10, 10));
-    io_surface_layer->SetAnchorPoint(gfx::PointF());
     io_surface_layer->SetIsDrawable(true);
     io_surface_layer->SetContentsOpaque(true);
     io_surface_layer->SetIOSurfaceProperties(io_surface_id_, io_surface_size_);
     layer_tree_host()->root_layer()->AddChild(io_surface_layer);
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     EXPECT_EQ(0u, host_impl->resource_provider()->num_resources());
@@ skipping 387 matching lines @@
 
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
  private:
   size_t push_properties_count_;
 
   PushPropertiesCountingLayerImpl(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id),
         push_properties_count_(0) {
-    SetAnchorPoint(gfx::PointF());
     SetBounds(gfx::Size(1, 1));
   }
 };
 
 class PushPropertiesCountingLayer : public Layer {
  public:
   static scoped_refptr<PushPropertiesCountingLayer> Create() {
     return new PushPropertiesCountingLayer();
   }
 
@@ skipping 13 matching lines @@
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
   void set_persist_needs_push_properties(bool persist) {
     persist_needs_push_properties_ = persist;
   }
 
  private:
   PushPropertiesCountingLayer()
       : push_properties_count_(0), persist_needs_push_properties_(false) {
-    SetAnchorPoint(gfx::PointF());
     SetBounds(gfx::Size(1, 1));
     SetIsDrawable(true);
   }
   virtual ~PushPropertiesCountingLayer() {}
 
   size_t push_properties_count_;
   bool persist_needs_push_properties_;
 };
 
 class LayerTreeHostTestLayersPushProperties : public LayerTreeHostTest {
@@ skipping 1005 matching lines @@
 };
 
 // TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestIOSurfaceLayerInvalidate);
 
 class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
  protected:
   virtual void SetupTree() OVERRIDE {
     root_layer_ = Layer::Create();
-    root_layer_->SetAnchorPoint(gfx::PointF());
     root_layer_->SetPosition(gfx::Point());
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     parent_layer_ = SolidColorLayer::Create();
-    parent_layer_->SetAnchorPoint(gfx::PointF());
     parent_layer_->SetPosition(gfx::Point());
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root_layer_->AddChild(parent_layer_);
 
     child_layer_ = SolidColorLayer::Create();
-    child_layer_->SetAnchorPoint(gfx::PointF());
     child_layer_->SetPosition(gfx::Point());
     child_layer_->SetBounds(gfx::Size(10, 10));
     child_layer_->SetIsDrawable(true);
     parent_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
@@ skipping 40 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->impl_side_painting = true;
   }
 
   virtual void SetupTree() OVERRIDE {
     root_layer_ = FakePictureLayer::Create(&client_);
-    root_layer_->SetAnchorPoint(gfx::PointF());
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     // The viewport is empty, but we still need to update layers on the main
     // thread.
     layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
@@ skipping 799 matching lines @@
   const gfx::Size bounds_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayerWithUpdateTracking> content_layer_;
   scoped_refptr<FakePictureLayer> picture_layer_;
   Layer* child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousPainting);
 
 }  // namespace cc