Streamline the layout of the BrowserView's children TabContents views....

views/controls/single_split_view_unittest.cc

+// Copyright (c) 2010 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 "base/logging.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "views/controls/single_split_view.h"
+
+using ::testing::_;
+using ::testing::Return;
+
+namespace {
+
+static void VerifySplitViewLayout(const views::SingleSplitView& split) {
+  ASSERT_EQ(2, split.GetChildViewCount());
+
+  views::View* leading = split.GetChildViewAt(0);
+  views::View* trailing = split.GetChildViewAt(1);
+
+  if (split.bounds().IsEmpty()) {
+    EXPECT_TRUE(leading->bounds().IsEmpty());
+    EXPECT_TRUE(trailing->bounds().IsEmpty());
+    return;
+  }
+
+  EXPECT_FALSE(leading->bounds().IsEmpty());
+  EXPECT_FALSE(trailing->bounds().IsEmpty());
+  EXPECT_FALSE(leading->bounds().Intersects(trailing->bounds()));
+
+  if (split.orientation() == views::SingleSplitView::HORIZONTAL_SPLIT) {
+    EXPECT_EQ(leading->bounds().height(), split.bounds().height());
+    EXPECT_EQ(trailing->bounds().height(), split.bounds().height());
+    EXPECT_LT(leading->bounds().width() + trailing->bounds().width(),
+              split.bounds().width());
+  } else if (split.orientation() == views::SingleSplitView::VERTICAL_SPLIT) {
+    EXPECT_EQ(leading->bounds().width(), split.bounds().width());
+    EXPECT_EQ(trailing->bounds().width(), split.bounds().width());
+    EXPECT_LT(leading->bounds().height() + trailing->bounds().height(),
+              split.bounds().height());
+  } else {
+    NOTREACHED();
+  }
+}
+
+class MockObserver : public views::SingleSplitView::Observer {
+ public:
+  MOCK_METHOD1(SplitHandleMoved, bool(views::SingleSplitView*));
+};
+
+}  // namespace
+
+namespace views {
+
+TEST(SingleSplitViewTest, Resize) {
+  // Test cases to iterate through for horizontal and vertical split views.
+  struct TestCase {
+    // Split view resize policy for this test case.
+    bool resize_leading_on_bounds_change;
+    // Split view size to set.
+    int primary_axis_size;
+    int secondary_axis_size;
+    // Expected divider offset.
+    int divider_offset;
+  } test_cases[] = {
+    // The initial split size is 100x100, divider at 33.
+    { true, 100, 100, 33 },
+    // Grow the split view, leading view should grow.
+    { true, 1000, 100, 933 },
+    // Shrink the split view, leading view should shrink.
+    { true, 200, 100, 133 },
+    // Minimize the split view, divider should not move.
+    { true, 0, 0, 133 },
+    // Restore the split view, divider should not move.
+    { false, 500, 100, 133 },
+    // Resize the split view by secondary axis, divider should not move.
+    { false,  500, 600, 133 }
+  };
+
+  SingleSplitView::Orientation orientations[] = {
+    SingleSplitView::HORIZONTAL_SPLIT,
+    SingleSplitView::VERTICAL_SPLIT
+  };
+
+  for (int orientation = 0; orientation < arraysize(orientations);
+       ++orientation) {
+    // Create a split view.
+    SingleSplitView split(
+        new View(), new View(), orientations[orientation], NULL);
+
+    // Set initial size and divider offset.
+    split.SetBounds(0, 0, 100, 100);
+    split.set_divider_offset(33);
+    split.Layout();
+
+    // Run all test cases.
+    for (int i = 0; i < arraysize(test_cases); ++i) {
+      split.set_resize_leading_on_bounds_change(
+          test_cases[i].resize_leading_on_bounds_change);
+      if (split.orientation() == SingleSplitView::HORIZONTAL_SPLIT) {
+        split.SetBounds(0, 0, test_cases[i].primary_axis_size,
+                        test_cases[i].secondary_axis_size);
+      } else {
+        split.SetBounds(0, 0, test_cases[i].secondary_axis_size,
+                        test_cases[i].primary_axis_size);
+      }
+
+      EXPECT_EQ(test_cases[i].divider_offset, split.divider_offset());
+      VerifySplitViewLayout(split);
+    }
+
+    // Special cases, one of the child views is hidden.
+    split.GetChildViewAt(0)->SetVisible(false);
+    split.Layout();
+
+    EXPECT_EQ(split.bounds().size(),
+              split.GetChildViewAt(1)->bounds().size());
+
+    split.GetChildViewAt(0)->SetVisible(true);
+    split.GetChildViewAt(1)->SetVisible(false);
+    split.Layout();
+
+    EXPECT_EQ(split.bounds().size(),
+              split.GetChildViewAt(0)->bounds().size());
+  }
+}
+
+TEST(SingleSplitViewTest, MouseDrag) {
+  MockObserver observer;
+  SingleSplitView split(
+      new View(), new View(), SingleSplitView::VERTICAL_SPLIT, &observer);
+
+  ON_CALL(observer, SplitHandleMoved(_))
+      .WillByDefault(Return(true));
+  // SplitHandleMoved is expected to be called once for every mouse move.
+  EXPECT_CALL(observer, SplitHandleMoved(_))
+      .Times(2);
+
+  split.SetBounds(0, 0, 10, 100);
+  const int kInitialDividerOffset = 33;
+  const int kMouseOffset = 2;  // Mouse offset in the divider.
+  const int kMouseMoveDelta = 7;
+  split.set_divider_offset(kInitialDividerOffset);
+  split.Layout();
+
+  // Drag divider to the right, in 2 steps.
+  ASSERT_TRUE(split.OnMousePressed(MouseEvent(
+      Event::ET_MOUSE_PRESSED, 7,
+      kInitialDividerOffset + kMouseOffset, 0)));
+  EXPECT_EQ(kInitialDividerOffset, split.divider_offset());
+
+  ASSERT_TRUE(split.OnMouseDragged(MouseEvent(
+      Event::ET_MOUSE_DRAGGED, 5,
+      kInitialDividerOffset + kMouseOffset + kMouseMoveDelta, 0)));
+  EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta, split.divider_offset());
+
+  ASSERT_TRUE(split.OnMouseDragged(MouseEvent(
+      Event::ET_MOUSE_DRAGGED, 6,
+      kInitialDividerOffset + kMouseOffset + kMouseMoveDelta * 2, 0)));
+  EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta * 2,
+            split.divider_offset());
+
+  split.OnMouseReleased(MouseEvent(
+      Event::ET_MOUSE_RELEASED, 7,
+      kInitialDividerOffset + kMouseOffset + kMouseMoveDelta * 2, 0), false);
+  EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta * 2,
+            split.divider_offset());
+}
+
+}  // namespace views