Experimental alignment layout manager using state retained in the layout manager

ui/views/layout/align_layout_state_unittest.cc

 // Copyright (c) 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 <stddef.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "ui/views/align_attribute.h"
-#include "ui/views/layout/align_layout.h"
+#include "ui/views/layout/align_layout_state.h"
 #include "ui/views/test/test_views.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 namespace {
 
-class AlignLayoutTest : public testing::Test {
+class AlignLayoutStateTest : public testing::Test {
  public:
   void SetUp() override { host_.reset(new View); }
 
   std::unique_ptr<View> host_;
 };
 
 }  // namespace
 
-TEST_F(AlignLayoutTest, Empty) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, Empty) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   EXPECT_EQ(gfx::Size(0, 0), layout->GetPreferredSize(host_.get()));
 }
 
-TEST_F(AlignLayoutTest, AlignTop) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignTop) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  v1->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v1, Align::Top);
+  layout->SetViewBounds(v1, 0, 0, 0, 10);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 20, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 20, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), host_->bounds());
   host_->SetBounds(0, 0, 30, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 30, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 20), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignBottom) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignBottom) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  v1->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v1, Align::Bottom);
+  layout->SetViewBounds(v1, 0, 0, 0, 10);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 20, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 20, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), host_->bounds());
   host_->SetBounds(0, 0, 30, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 30, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 20), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignLeft) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignLeft) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Left);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 20, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), host_->bounds());
   host_->SetBounds(0, 0, 20, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignRight) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignRight) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Right);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 20, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(10, 0, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), host_->bounds());
   host_->SetBounds(0, 0, 20, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(10, 0, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignContent) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignContent) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Content)));
-  v1->SetBounds(0, 0, 0, 0);
+  layout->AlignView(v1, Align::Content);
+  layout->SetViewBounds(v1, 0, 0, 0, 0);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 20, 20);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignLeftTop) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignLeftTop) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Left);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Top);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignLeftTopRight) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignLeftTopRight) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Left);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Top);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   View* v3 = new View();
-  v3->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v3->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v3, Align::Right);
+  layout->SetViewBounds(v3, 0, 0, 10, 0);
   host_->AddChildView(v3);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(30, 10, 10, 30), v3->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(20, 10, 10, 20), v3->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignTopRight) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignTopRight) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Right);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Top);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(30, 10, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(20, 10, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignLeftBottomRight) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignLeftBottomRight) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Left);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Bottom);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   View* v3 = new View();
-  v3->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v3->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v3, Align::Right);
+  layout->SetViewBounds(v3, 0, 0, 10, 0);
   host_->AddChildView(v3);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 30, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(30, 0, 10, 30), v3->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 20, 30, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(20, 0, 10, 20), v3->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignBottomRight) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignBottomRight) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Right);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Bottom);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(30, 0, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 30, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(20, 0, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 20, 30, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignLeftBottom) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignLeftBottom) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
+  layout->AlignView(v1, Align::Left);
   v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Bottom);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 30), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 30, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   host_->SetBounds(0, 0, 30, 30);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 20), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 20, 30, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignLeftTopRightBottomContent) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignLeftTopRightBottomContent) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* vc = new View();
-  vc->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Content)));
+  layout->AlignView(vc, Align::Content);
   vc->SetBounds(0, 0, 0, 0);
   host_->AddChildView(vc);
   host_->SetBounds(0, 0, 60, 60);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 60, 60), vc->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 60), host_->bounds());
   View* vl = new View();
-  vl->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  vl->SetBounds(0, 0, 10, 0);
+  layout->AlignView(vl, Align::Left);
+  layout->SetViewBounds(vl, 0, 0, 10, 0);
   host_->AddChildView(vl);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 60), vl->bounds());
   EXPECT_EQ(gfx::Rect(10, 0, 50, 60), vc->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 60), host_->bounds());
   View* vr = new View();
+  layout->AlignView(vr, Align::Right);
   vr->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  vr->SetBounds(0, 0, 10, 0);
+  layout->SetViewBounds(vr, 0, 0, 10, 0);
   host_->AddChildView(vr);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 60), vl->bounds());
   EXPECT_EQ(gfx::Rect(50, 0, 10, 60), vr->bounds());
   EXPECT_EQ(gfx::Rect(10, 0, 40, 60), vc->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 60), host_->bounds());
   View* vt = new View();
-  vt->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  vt->SetBounds(0, 0, 0, 10);
+  layout->AlignView(vt, Align::Top);
+  layout->SetViewBounds(vt, 0, 0, 0, 10);
   host_->AddChildView(vt);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 10, 50), vl->bounds());
   EXPECT_EQ(gfx::Rect(50, 10, 10, 50), vr->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 10), vt->bounds());
   EXPECT_EQ(gfx::Rect(10, 10, 40, 50), vc->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 60), host_->bounds());
   View* vb = new View();
-  vb->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  vb->SetBounds(0, 0, 0, 10);
+  layout->AlignView(vb, Align::Bottom);
+  layout->SetViewBounds(vb, 0, 0, 0, 10);
   host_->AddChildView(vb);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 10, 10, 40), vl->bounds());
   EXPECT_EQ(gfx::Rect(50, 10, 10, 40), vr->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 10), vt->bounds());
   EXPECT_EQ(gfx::Rect(0, 50, 60, 10), vb->bounds());
   EXPECT_EQ(gfx::Rect(10, 10, 40, 40), vc->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 60, 60), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignStackedTop) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignStackedTop) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  v1->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v1, Align::Top);
+  layout->SetViewBounds(v1, 0, 0, 0, 10);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 40, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Top)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Top);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 40, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 10, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignStackedBottom) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignStackedBottom) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  v1->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v1, Align::Bottom);
+  layout->SetViewBounds(v1, 0, 0, 0, 10);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 30, 40, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Bottom)));
-  v2->SetBounds(0, 0, 0, 10);
+  layout->AlignView(v2, Align::Bottom);
+  layout->SetViewBounds(v2, 0, 0, 0, 10);
   host_->AddChildView(v2);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 30, 40, 10), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 20, 40, 10), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignStackedLeft) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignStackedLeft) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Left);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 40), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Left)));
-  v2->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v2, Align::Left);
+  layout->SetViewBounds(v2, 0, 0, 10, 0);
   host_->AddChildView(v2);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(0, 0, 10, 40), v1->bounds());
   EXPECT_EQ(gfx::Rect(10, 0, 10, 40), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
 }
 
-TEST_F(AlignLayoutTest, AlignStackedRight) {
-  AlignLayout* layout = new AlignLayout();
+TEST_F(AlignLayoutStateTest, AlignStackedRight) {
+  AlignLayoutState* layout = new AlignLayoutState();
   host_->SetLayoutManager(layout);
   View* v1 = new View();
-  v1->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v1->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v1, Align::Right);
+  layout->SetViewBounds(v1, 0, 0, 10, 0);
   host_->AddChildView(v1);
   host_->SetBounds(0, 0, 40, 40);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(30, 0, 10, 40), v1->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
   View* v2 = new View();
-  v2->attributes().Add(base::WrapUnique(new AlignAttribute(Align::Right)));
-  v2->SetBounds(0, 0, 10, 0);
+  layout->AlignView(v2, Align::Right);
+  layout->SetViewBounds(v2, 0, 0, 10, 0);
   host_->AddChildView(v2);
   host_->Layout();
   EXPECT_EQ(gfx::Rect(30, 0, 10, 40), v1->bounds());
   EXPECT_EQ(gfx::Rect(20, 0, 10, 40), v2->bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), host_->bounds());
 }
 
 }  // namespace views