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

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 2012 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 "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 290 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
 
 class LayerTreeHostContextTestLostContextSucceedsWithContent
     : public LayerTreeHostContextTestLostContextSucceeds {
  public:
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(10, 10));
-    root_->SetAnchorPoint(gfx::PointF());
     root_->SetIsDrawable(true);
 
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(10, 10));
-    content_->SetAnchorPoint(gfx::PointF());
     content_->SetIsDrawable(true);
 
     root_->AddChild(content_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
   }
 
   virtual void InvalidateAndSetNeedsCommit() OVERRIDE {
     // Invalidate the render surface so we don't try to use a cached copy of the
@@ skipping 395 matching lines @@
             RGBA_8888);
     ResourceProvider::ScopedWriteLockGL lock(child_resource_provider_.get(),
                                              resource);
 
     gpu::Mailbox mailbox;
     gl->GenMailboxCHROMIUM(mailbox.name);
     GLuint sync_point = gl->InsertSyncPointCHROMIUM();
 
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
-    root->SetAnchorPoint(gfx::PointF());
     root->SetIsDrawable(true);
 
     scoped_refptr<FakeDelegatedRendererLayer> delegated =
         FakeDelegatedRendererLayer::Create(delegated_frame_provider_.get());
     delegated->SetBounds(gfx::Size(10, 10));
-    delegated->SetAnchorPoint(gfx::PointF());
     delegated->SetIsDrawable(true);
     root->AddChild(delegated);
 
     scoped_refptr<ContentLayer> content = ContentLayer::Create(&client_);
     content->SetBounds(gfx::Size(10, 10));
-    content->SetAnchorPoint(gfx::PointF());
     content->SetIsDrawable(true);
     root->AddChild(content);
 
     scoped_refptr<TextureLayer> texture = TextureLayer::CreateForMailbox(NULL);
     texture->SetBounds(gfx::Size(10, 10));
-    texture->SetAnchorPoint(gfx::PointF());
     texture->SetIsDrawable(true);
     texture->SetTextureMailbox(
         TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
         SingleReleaseCallback::Create(
             base::Bind(&LayerTreeHostContextTestDontUseLostResources::
                             EmptyReleaseCallback)));
     root->AddChild(texture);
 
     scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client_);
     mask->SetBounds(gfx::Size(10, 10));
-    mask->SetAnchorPoint(gfx::PointF());
 
     scoped_refptr<ContentLayer> content_with_mask =
         ContentLayer::Create(&client_);
     content_with_mask->SetBounds(gfx::Size(10, 10));
-    content_with_mask->SetAnchorPoint(gfx::PointF());
     content_with_mask->SetIsDrawable(true);
     content_with_mask->SetMaskLayer(mask.get());
     root->AddChild(content_with_mask);
 
     scoped_refptr<VideoLayer> video_color =
         VideoLayer::Create(&color_frame_provider_);
     video_color->SetBounds(gfx::Size(10, 10));
-    video_color->SetAnchorPoint(gfx::PointF());
     video_color->SetIsDrawable(true);
     root->AddChild(video_color);
 
     scoped_refptr<VideoLayer> video_hw =
         VideoLayer::Create(&hw_frame_provider_);
     video_hw->SetBounds(gfx::Size(10, 10));
-    video_hw->SetAnchorPoint(gfx::PointF());
     video_hw->SetIsDrawable(true);
     root->AddChild(video_hw);
 
     scoped_refptr<VideoLayer> video_scaled_hw =
         VideoLayer::Create(&scaled_hw_frame_provider_);
     video_scaled_hw->SetBounds(gfx::Size(10, 10));
-    video_scaled_hw->SetAnchorPoint(gfx::PointF());
     video_scaled_hw->SetIsDrawable(true);
     root->AddChild(video_scaled_hw);
 
     color_video_frame_ = VideoFrame::CreateColorFrame(
         gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
     hw_video_frame_ =
         VideoFrame::WrapNativeTexture(make_scoped_ptr(new gpu::MailboxHolder(
                                           mailbox, GL_TEXTURE_2D, sync_point)),
                                       media::VideoFrame::ReleaseMailboxCB(),
                                       gfx::Size(4, 4),
@@ skipping 12 matching lines @@
                                       VideoFrame::ReadPixelsCB());
 
     color_frame_provider_.set_frame(color_video_frame_);
     hw_frame_provider_.set_frame(hw_video_frame_);
     scaled_hw_frame_provider_.set_frame(scaled_hw_video_frame_);
 
     if (!delegating_renderer()) {
       // TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
       scoped_refptr<IOSurfaceLayer> io_surface = IOSurfaceLayer::Create();
       io_surface->SetBounds(gfx::Size(10, 10));
-      io_surface->SetAnchorPoint(gfx::PointF());
       io_surface->SetIsDrawable(true);
       io_surface->SetIOSurfaceProperties(1, gfx::Size(10, 10));
       root->AddChild(io_surface);
     }
 
     // Enable the hud.
     LayerTreeDebugState debug_state;
     debug_state.show_property_changed_rects = true;
     layer_tree_host()->SetDebugState(debug_state);
 
     scoped_refptr<PaintedScrollbarLayer> scrollbar =
         PaintedScrollbarLayer::Create(
             scoped_ptr<Scrollbar>(new FakeScrollbar).Pass(), content->id());
     scrollbar->SetBounds(gfx::Size(10, 10));
-    scrollbar->SetAnchorPoint(gfx::PointF());
     scrollbar->SetIsDrawable(true);
     root->AddChild(scrollbar);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ skipping 75 matching lines @@
     settings->impl_side_painting = true;
   }
 };
 
 class LayerTreeHostContextTestImplSidePainting
     : public ImplSidePaintingLayerTreeHostContextTest {
  public:
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
-    root->SetAnchorPoint(gfx::PointF());
     root->SetIsDrawable(true);
 
     scoped_refptr<PictureLayer> picture = PictureLayer::Create(&client_);
     picture->SetBounds(gfx::Size(10, 10));
-    picture->SetAnchorPoint(gfx::PointF());
     picture->SetIsDrawable(true);
     root->AddChild(picture);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     times_to_lose_during_commit_ = 1;
     PostSetNeedsCommitToMainThread();
@@ skipping 535 matching lines @@
 
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestSurfaceCreateCallback);
 
 }  // namespace
 }  // namespace cc