Added common layout framework for system menu rows.

ash/common/system/tray/three_view_layout_unittest.cc

Index: ash/common/system/tray/three_view_layout_unittest.cc
diff --git a/ash/common/system/tray/three_view_layout_unittest.cc b/ash/common/system/tray/three_view_layout_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2fe8c1784673fb9039614d1ad9df3c35af13d718
--- /dev/null
+++ b/ash/common/system/tray/three_view_layout_unittest.cc
@@ -0,0 +1,288 @@
+// Copyright 2016 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 "ash/common/system/tray/three_view_layout.h"
+#include "base/memory/ptr_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/views/test/test_layout_manager.h"
+#include "ui/views/view.h"
+
+namespace ash {
+
+namespace {
+
+// A View that allows clients to specify its preferred size.
+class TestView : public views::View {

[tdanderson, 2016/10/19 18:31:00]

should you specify a destructor for TestView and ThreeViewLayoutTest ?

[bruthig, 2016/10/20 04:40:12]

I don't think they are necessary, are they?

[tdanderson, 2016/10/20 18:16:49]

My mistake, they're not.

+ public:
+  TestView() : TestView(gfx::Size()) {}
+
+  explicit TestView(const gfx::Size& preferred_size)
+      : preferred_size_(preferred_size) {}
+
+  void set_preferred_size(const gfx::Size& size) { preferred_size_ = size; }
+
+  // View:
+  gfx::Size GetPreferredSize() const override { return preferred_size_; }
+
+ private:
+  gfx::Size preferred_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestView);
+};
+
+}  // namespace
+
+class ThreeViewLayoutTest : public testing::Test {
+ public:
+  ThreeViewLayoutTest();
+
+ protected:
+  // Returns the bounds of |child| in the coordinate space of |host_|.
+  gfx::Rect GetBoundsInHost(const views::View* child) const;
+
+  // Wrapper functions to access the internals of |layout_|.
+  views::View* GetContainer(ThreeViewLayout::Container container) const;
+
+  // The test target.
+  ThreeViewLayout* layout_;
+
+  // The View that the test target is installed on.
+  std::unique_ptr<views::View> host_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ThreeViewLayoutTest);
+};
+
+ThreeViewLayoutTest::ThreeViewLayoutTest()
+    : layout_(new ThreeViewLayout()), host_(new views::View) {
+  host_->SetLayoutManager(layout_);
+}
+
+gfx::Rect ThreeViewLayoutTest::GetBoundsInHost(const views::View* child) const {
+  gfx::RectF rect_f(child->bounds());
+  views::View::ConvertRectToTarget(child, host_.get(), &rect_f);
+  return ToNearestRect(rect_f);
+}
+
+views::View* ThreeViewLayoutTest::GetContainer(
+    ThreeViewLayout::Container container) const {
+  return layout_->GetContainer(container);
+}
+
+TEST_F(ThreeViewLayoutTest, PaddingBetweenContainers) {
+  const int kPaddingBetweenContainers = 3;
+  layout_ = new ThreeViewLayout(kPaddingBetweenContainers);
+  host_->SetLayoutManager(layout_);
+
+  host_->SetBounds(0, 0, 100, 10);
+  views::View* start_child = new TestView(gfx::Size(10, 10));
+  views::View* center_child = new TestView(gfx::Size(10, 10));
+  views::View* end_child = new TestView(gfx::Size(10, 10));
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  host_->Layout();
+
+  EXPECT_EQ(0, GetBoundsInHost(start_child).x());
+  EXPECT_EQ(13, GetBoundsInHost(center_child).x());
+  EXPECT_EQ(26, GetBoundsInHost(end_child).x());

[tdanderson, 2016/10/19 18:31:00]

Consider specifying these as constants derived from the other constants you use
in the test rather than as magic numbers.

[bruthig, 2016/10/20 04:40:12]

Updated along with some of the other tests.  Let me know if I haven't made them
more clear.

[tdanderson, 2016/10/20 18:16:49]

lg, thanks

+}
+
+TEST_F(ThreeViewLayoutTest, VerticalOrientation) {
+  layout_ = new ThreeViewLayout(ThreeViewLayout::VERTICAL);
+  host_->SetLayoutManager(layout_);
+
+  host_->SetBounds(0, 0, 10, 100);
+  views::View* start_child = new TestView(gfx::Size(10, 10));
+  views::View* center_child = new TestView(gfx::Size(10, 10));
+  views::View* end_child = new TestView(gfx::Size(10, 10));
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  host_->Layout();
+
+  EXPECT_EQ(0, GetBoundsInHost(start_child).y());
+  EXPECT_EQ(10, GetBoundsInHost(center_child).y());
+  EXPECT_EQ(20, GetBoundsInHost(end_child).y());
+}
+
+TEST_F(ThreeViewLayoutTest, ContainerViewsRemovedFromHost) {
+  EXPECT_NE(0, host_->child_count());
+  host_->SetLayoutManager(nullptr);
+  EXPECT_EQ(0, host_->child_count());
+}
+
+TEST_F(ThreeViewLayoutTest, MinCrossAxisSize) {
+  const int kMinCrossAxisSize = 15;
+  EXPECT_EQ(0, layout_->GetPreferredSize(host_.get()).height());
+  layout_->SetMinCrossAxisSize(kMinCrossAxisSize);
+  EXPECT_EQ(kMinCrossAxisSize, layout_->GetPreferredSize(host_.get()).height());
+  EXPECT_EQ(kMinCrossAxisSize,
+            layout_->GetPreferredHeightForWidth(host_.get(), 0));
+}
+
+TEST_F(ThreeViewLayoutTest, MainAxisMinSize) {
+  host_->SetBounds(0, 0, 100, 10);
+  const gfx::Size kMinSize(15, 10);
+  layout_->SetMinSize(ThreeViewLayout::START, kMinSize);
+  views::View* child = new TestView(gfx::Size(10, 10));
+  layout_->AddView(ThreeViewLayout::CENTER, child);
+  host_->Layout();
+
+  EXPECT_EQ(kMinSize.width(), GetBoundsInHost(child).x());
+}
+
+TEST_F(ThreeViewLayoutTest, MainAxisMaxSize) {
+  host_->SetBounds(0, 0, 100, 10);
+  const gfx::Size kMaxSize(10, 10);
+
+  layout_->SetMaxSize(ThreeViewLayout::START, kMaxSize);
+  views::View* start_child = new TestView(gfx::Size(20, 20));
+  layout_->AddView(ThreeViewLayout::START, start_child);
+
+  views::View* center_child = new TestView(gfx::Size(10, 10));
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+
+  host_->Layout();
+
+  EXPECT_EQ(kMaxSize.width(), GetBoundsInHost(center_child).x());
+}
+
+TEST_F(ThreeViewLayoutTest, ViewsAddedToCorrectContainers) {
+  views::View* start_child = new TestView();
+  views::View* center_child = new TestView();
+  views::View* end_child = new TestView();
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::START)->Contains(start_child));
+  EXPECT_EQ(1, GetContainer(ThreeViewLayout::START)->child_count());
+
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::CENTER)->Contains(center_child));
+  EXPECT_EQ(1, GetContainer(ThreeViewLayout::CENTER)->child_count());
+
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::END)->Contains(end_child));
+  EXPECT_EQ(1, GetContainer(ThreeViewLayout::END)->child_count());
+}
+
+TEST_F(ThreeViewLayoutTest, MultipleViewsAddedToTheSameContainer) {
+  views::View* child1 = new TestView();
+  views::View* child2 = new TestView();
+
+  layout_->AddView(ThreeViewLayout::START, child1);
+  layout_->AddView(ThreeViewLayout::START, child2);
+
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::START)->Contains(child1));
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::START)->Contains(child2));
+}
+
+TEST_F(ThreeViewLayoutTest, ViewsRemovedOnSetViewToTheSameContainer) {
+  views::View* child1 = new TestView();
+  views::View* child2 = new TestView();
+
+  layout_->AddView(ThreeViewLayout::START, child1);
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::START)->Contains(child1));
+
+  layout_->SetView(ThreeViewLayout::START, child2);
+  EXPECT_TRUE(GetContainer(ThreeViewLayout::START)->Contains(child2));
+  EXPECT_EQ(1, GetContainer(ThreeViewLayout::START)->child_count());
+}
+
+TEST_F(ThreeViewLayoutTest, Insets) {
+  host_->SetBounds(0, 0, 100, 10);
+  layout_->SetInsets(gfx::Insets(3));
+  views::View* start_child = new TestView(gfx::Size(10, 10));
+  views::View* center_child = new TestView(gfx::Size(100, 10));
+  views::View* end_child = new TestView(gfx::Size(10, 10));
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  layout_->SetFlexForContainer(ThreeViewLayout::CENTER, 1.f);
+  host_->Layout();
+
+  EXPECT_EQ(gfx::Rect(3, 3, 10, 4), GetBoundsInHost(start_child));
+  EXPECT_EQ(gfx::Rect(13, 3, 74, 4), GetBoundsInHost(center_child));
+  EXPECT_EQ(gfx::Rect(87, 3, 10, 4), GetBoundsInHost(end_child));
+}
+
+TEST_F(ThreeViewLayoutTest, InvisibleContainerDoesntTakeUpSpace) {
+  host_->SetBounds(0, 0, 30, 10);
+  views::View* start_child = new TestView(gfx::Size(10, 10));
+  views::View* center_child = new TestView(gfx::Size(10, 10));
+  views::View* end_child = new TestView(gfx::Size(10, 10));
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  layout_->SetContainerVisible(ThreeViewLayout::START, false);
+  host_->Layout();
+
+  EXPECT_EQ(gfx::Rect(0, 0, 0, 0), GetBoundsInHost(start_child));
+  EXPECT_EQ(0, GetBoundsInHost(center_child).x());
+  EXPECT_EQ(10, GetBoundsInHost(end_child).x());
+
+  layout_->SetContainerVisible(ThreeViewLayout::START, true);
+  host_->Layout();
+
+  EXPECT_EQ(0, GetBoundsInHost(start_child).x());
+  EXPECT_EQ(10, GetBoundsInHost(center_child).x());
+  EXPECT_EQ(20, GetBoundsInHost(end_child).x());
+}
+
+TEST_F(ThreeViewLayoutTest, NonZeroFlex) {
+  const gfx::Size kDefaultViewSize(10, 10);
+  const gfx::Size kCenterViewSize(100, 10);
+  const gfx::Size kExpectedCenterViewSize(80, 10);
+  host_->SetBounds(0, 0, 100, 10);
+  views::View* start_child = new TestView(kDefaultViewSize);
+  views::View* center_child = new TestView(kCenterViewSize);
+  views::View* end_child = new TestView(kDefaultViewSize);
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  layout_->SetFlexForContainer(ThreeViewLayout::CENTER, 1.f);
+  host_->Layout();
+
+  EXPECT_EQ(kDefaultViewSize, GetBoundsInHost(start_child).size());
+  EXPECT_EQ(kExpectedCenterViewSize, GetBoundsInHost(center_child).size());
+  EXPECT_EQ(kDefaultViewSize, GetBoundsInHost(end_child).size());
+}
+
+TEST_F(ThreeViewLayoutTest, NonZeroFlexTakesPrecedenceOverMaxSize) {

[tdanderson, 2016/10/19 18:30:59]

Can you document this expected precedence behavior somewhere in the
ThreeViewLayout header?

[bruthig, 2016/10/20 04:40:12]

Done.  And added another test because this applies to min size constraints as
well.  PTAL.

[tdanderson, 2016/10/20 18:16:49]

lg, thanks

+  const gfx::Size kViewSize(10, 10);
+  const gfx::Size kMaxCenterSize(20, 10);
+  const gfx::Size kExpectedMaxCenterSize(80, 10);
+  host_->SetBounds(0, 0, 100, 10);
+  views::View* start_child = new TestView(kViewSize);
+  views::View* center_child = new TestView(kViewSize);
+  views::View* end_child = new TestView(kViewSize);
+
+  layout_->AddView(ThreeViewLayout::START, start_child);
+  layout_->AddView(ThreeViewLayout::CENTER, center_child);
+  layout_->AddView(ThreeViewLayout::END, end_child);
+
+  layout_->SetFlexForContainer(ThreeViewLayout::CENTER, 1.f);
+  layout_->SetMaxSize(ThreeViewLayout::CENTER, kMaxCenterSize);
+  host_->Layout();
+
+  EXPECT_EQ(kViewSize, GetBoundsInHost(start_child).size());
+  EXPECT_EQ(kExpectedMaxCenterSize,
+            GetBoundsInHost(GetContainer(ThreeViewLayout::CENTER)).size());
+  EXPECT_EQ(kViewSize, GetBoundsInHost(end_child).size());
+}
+
+}  // namespace ash