Adds window resizing

components/mus/example/wm/move_loop_unittest.cc

+// Copyright 2015 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 "components/mus/example/wm/move_loop.h"
+
+#include "components/mus/public/cpp/tests/test_window.h"
+#include "mojo/converters/input_events/input_events_type_converters.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+
+using MoveLoopTest = testing::Test;
+
+namespace {
+
+// Sets the client area for |window|. Padding is provided on the top so that
+// there is a movable region. All other edges are sized to
+// |MoveLoop::kResizeSize|.
+void SetClientArea(mus::Window* window) {
+  if (window->bounds().IsEmpty())
+    window->SetBounds(gfx::Rect(100, 200, 300, 400));
+
+  gfx::Rect client_area(window->bounds().size());
+  client_area.Inset(MoveLoop::kResizeSize, MoveLoop::kResizeSize + 10,
+                    MoveLoop::kResizeSize, MoveLoop::kResizeSize);
+  window->SetClientArea(client_area);
+}
+
+mus::mojom::EventPtr CreatePointerDownEvent(const gfx::Point& location) {
+  const ui::TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(location), 1,
+                             base::TimeDelta());
+  return mus::mojom::Event::From(static_cast<const ui::Event&>(event));
+}
+
+mus::mojom::EventPtr CreatePointerMove(const gfx::Point& location) {
+  const ui::TouchEvent event(ui::ET_TOUCH_MOVED, gfx::PointF(location), 1,
+                             base::TimeDelta());
+  return mus::mojom::Event::From(static_cast<const ui::Event&>(event));
+}
+
+enum class HorizontalLocation {
+  LEFT,
+  MIDDLE,
+  RIGHT,
+};
+
+enum class VerticalLocation {
+  TOP_MOVE,
+  TOP_RESIZE,
+  MIDDLE,
+  BOTTOM,
+};
+
+int HorizontalLocationToPoint(const mus::Window* window,
+                              HorizontalLocation loc) {
+  if (loc == HorizontalLocation::LEFT)
+    return 0;
+  return loc == HorizontalLocation::MIDDLE ? window->bounds().width() / 2
+                                           : window->bounds().width() - 1;
+}
+
+int VerticalLocationToPoint(const mus::Window* window, VerticalLocation loc) {
+  switch (loc) {
+    case VerticalLocation::TOP_MOVE:
+      return MoveLoop::kResizeSize + 1;
+    case VerticalLocation::TOP_RESIZE:
+      return 0;
+    case VerticalLocation::MIDDLE:
+      return window->bounds().height() / 2;
+    case VerticalLocation::BOTTOM:
+      return window->bounds().height() - 1;
+  }
+  return 0;
+}
+
+gfx::Point LocationToPoint(const mus::Window* window,
+                           HorizontalLocation h_loc,
+                           VerticalLocation v_loc) {
+  return gfx::Point(HorizontalLocationToPoint(window, h_loc),
+                    VerticalLocationToPoint(window, v_loc));
+}
+
+}  // namespace
+
+TEST_F(MoveLoopTest, Move) {
+  struct TestData {
+    HorizontalLocation initial_h_loc;
+    VerticalLocation initial_v_loc;
+    // Number of values in delta_* that are valid. For example, if this is 1
+    // then only one move is generated with thye point |delta_x[0]|,
+    // |delta_y[0]|.
+    int delta_count;
+    int delta_x[3];
+    int delta_y[3];
+    gfx::Rect expected_bounds;
+  } data[] = {
+      // Move.
+      {HorizontalLocation::MIDDLE,
+       VerticalLocation::TOP_MOVE,
+       1,
+       {1, 0, 0},
+       {2, 0, 0},
+       gfx::Rect(101, 202, 300, 400)},
+
+      // Resize from top, left.
+      {HorizontalLocation::LEFT,
+       VerticalLocation::TOP_RESIZE,
+       1,
+       {1, 0, 0},
+       {2, 0, 0},
+       gfx::Rect(101, 202, 299, 398)},
+
+      // Resize from left.
+      {HorizontalLocation::LEFT,
+       VerticalLocation::MIDDLE,
+       1,
+       {1, 0, 0},
+       {2, 0, 0},
+       gfx::Rect(101, 200, 299, 400)},
+
+      // Resize from bottom, left.
+      {HorizontalLocation::LEFT,
+       VerticalLocation::BOTTOM,
+       1,
+       {-1, 0, 0},
+       {-2, 0, 0},
+       gfx::Rect(99, 200, 301, 398)},
+
+      // Resize from bottom.
+      {HorizontalLocation::MIDDLE,
+       VerticalLocation::BOTTOM,
+       1,
+       {-1, 0, 0},
+       {4, 0, 0},
+       gfx::Rect(100, 200, 300, 404)},
+
+      // Resize from bottom, right.
+      {HorizontalLocation::RIGHT,
+       VerticalLocation::BOTTOM,
+       1,
+       {-3, 0, 0},
+       {4, 0, 0},
+       gfx::Rect(100, 200, 297, 404)},
+
+      // Resize from right.
+      {HorizontalLocation::RIGHT,
+       VerticalLocation::MIDDLE,
+       1,
+       {6, 0, 0},
+       {-4, 0, 0},
+       gfx::Rect(100, 200, 306, 400)},
+
+      // Resize from top, right.
+      {HorizontalLocation::RIGHT,
+       VerticalLocation::TOP_RESIZE,
+       1,
+       {6, 0, 0},
+       {5, 0, 0},
+       gfx::Rect(100, 205, 306, 395)},
+  };
+
+  for (size_t i = 0; i < arraysize(data); ++i) {
+    mus::TestWindow window;
+    SetClientArea(&window);
+    gfx::Point pointer_location(
+        LocationToPoint(&window, data[i].initial_h_loc, data[i].initial_v_loc));
+    scoped_ptr<MoveLoop> move_loop =
+        MoveLoop::Create(&window, *CreatePointerDownEvent(pointer_location));
+    ASSERT_TRUE(move_loop.get()) << i;
+    for (int j = 0; j < data[i].delta_count; ++j) {
+      pointer_location.Offset(data[i].delta_x[j], data[i].delta_y[j]);
+      ASSERT_EQ(MoveLoop::MoveResult::CONTINUE,
+                move_loop->Move(*CreatePointerMove(pointer_location)))
+          << i << " " << j;
+    }
+    ASSERT_EQ(data[i].expected_bounds, window.bounds());
+  }
+}