Minimum size for aura window

ui/aura/window_unittest.cc

 // Copyright (c) 2011 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 "ui/aura/window.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/desktop_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/hit_test.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/aura_test_base.h"
+#include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_desktop_delegate.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/layer.h"
+#include "ui/gfx/screen.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
 namespace aura {
 namespace test {
 
 namespace {
 
 // Used for verifying destruction methods are invoked.
 class DestroyTrackingDelegateImpl : public TestWindowDelegate {
  public:
@@ skipping 310 matching lines @@
   ASSERT_EQ(2u, parent.children().size());
   EXPECT_EQ(&child1, parent.children()[1]);
   EXPECT_EQ(&child2, parent.children()[0]);
   ASSERT_EQ(2u, parent.layer()->children().size());
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
 }
 
 // Various destruction assertions.
 TEST_F(WindowTest, CaptureTests) {
-  Desktop* desktop = Desktop::GetInstance();
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
   EXPECT_EQ(0, delegate.capture_lost_count());
+  EventGenerator generator(gfx::Point(50, 50));
+  generator.PressLeftButton();
+  EXPECT_EQ(1, delegate.mouse_event_count());
+  generator.ReleaseLeftButton();
 
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(50, 50),
-                                   ui::EF_LEFT_BUTTON_DOWN));
-  EXPECT_EQ(1, delegate.mouse_event_count());
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_RELEASED, gfx::Point(50, 50),
-                                   ui::EF_LEFT_BUTTON_DOWN));
   EXPECT_EQ(2, delegate.mouse_event_count());
   delegate.set_mouse_event_count(0);
 
   window->ReleaseCapture();
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(1, delegate.capture_lost_count());
 
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(50, 50),
-                                   ui::EF_LEFT_BUTTON_DOWN));
+  generator.PressLeftButton();
   EXPECT_EQ(0, delegate.mouse_event_count());
 }
 
 // Verifies capture is reset when a window is destroyed.
 TEST_F(WindowTest, ReleaseCaptureOnDestroy) {
   Desktop* desktop = Desktop::GetInstance();
   internal::RootWindow* root =
       static_cast<internal::RootWindow*>(desktop->window());
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
@@ skipping 74 matching lines @@
 
 class ActivateWindowDelegate : public TestWindowDelegate {
  public:
   ActivateWindowDelegate()
       : activate_(true),
         activated_count_(0),
         lost_active_count_(0),
         should_activate_count_(0) {
   }
 
+  ActivateWindowDelegate(bool activate)
+      : activate_(activate),
+        activated_count_(0),
+        lost_active_count_(0),
+        should_activate_count_(0) {
+  }
+
   void set_activate(bool v) { activate_ = v; }
   int activated_count() const { return activated_count_; }
   int lost_active_count() const { return lost_active_count_; }
   int should_activate_count() const { return should_activate_count_; }
   void Clear() {
     activated_count_ = lost_active_count_ = should_activate_count_ = 0;
   }
 
   virtual bool ShouldActivate(MouseEvent* event) OVERRIDE {
     should_activate_count_++;
@@ skipping 34 matching lines @@
   desktop->SetActiveWindow(w1.get(), NULL);
   EXPECT_EQ(w1.get(), desktop->active_window());
   EXPECT_EQ(w1.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(1, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
   d1.Clear();
 
   // Click on window2.
   gfx::Point press_point = w2->bounds().CenterPoint();
   Window::ConvertPointToWindow(w2->parent(), desktop->window(), &press_point);
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_PRESSED, press_point, 0));
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_RELEASED, press_point, 0));
+  EventGenerator generator(press_point);
+  generator.ClickLeftButton();
 
   // Window2 should have become active.
   EXPECT_EQ(w2.get(), desktop->active_window());
   EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(0, d1.activated_count());
   EXPECT_EQ(1, d1.lost_active_count());
   EXPECT_EQ(1, d2.activated_count());
   EXPECT_EQ(0, d2.lost_active_count());
   d1.Clear();
   d2.Clear();
 
   // Click back on window1, but set it up so w1 doesn't activate on click.
   press_point = w1->bounds().CenterPoint();
   Window::ConvertPointToWindow(w1->parent(), desktop->window(), &press_point);
   d1.set_activate(false);
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_PRESSED, press_point, 0));
-  desktop->OnMouseEvent(MouseEvent(ui::ET_MOUSE_RELEASED, press_point, 0));
+  generator.ClickLeftButton();
 
   // Window2 should still be active and focused.
   EXPECT_EQ(w2.get(), desktop->active_window());
   EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(0, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
   EXPECT_EQ(0, d2.activated_count());
   EXPECT_EQ(0, d2.lost_active_count());
   d1.Clear();
   d2.Clear();
@@ skipping 159 matching lines @@
   EXPECT_EQ(original_bounds, w->bounds());
 
   // Fullscreen
   w->Fullscreen();
   EXPECT_EQ(ui::SHOW_STATE_FULLSCREEN, w->show_state());
   EXPECT_EQ(desktop_bounds, w->bounds());
   w->Restore();
   EXPECT_EQ(ui::SHOW_STATE_NORMAL, w->show_state());
   EXPECT_EQ(original_bounds, w->bounds());
 
-  // Fullscreen twice
+  // Calling Fullscreen() twice should have no additional effect.
   w->Fullscreen();
   w->Fullscreen();
   EXPECT_EQ(desktop_bounds, w->bounds());
   w->Restore();
   EXPECT_EQ(ui::SHOW_STATE_NORMAL, w->show_state());
   EXPECT_EQ(original_bounds, w->bounds());
+
+  // Calling SetBounds() in fullscreen mode should only update the
+  // restore bounds not change the bounds of the window.
+  gfx::Rect new_bounds(50, 50, 50, 50);
+  w->Fullscreen();
+  w->SetBounds(new_bounds);
+  EXPECT_EQ(desktop_bounds, w->bounds());
+  w->Restore();
+  EXPECT_EQ(new_bounds, w->bounds());
 }
 
 TEST_F(WindowTest, Maximized) {
   gfx::Rect original_bounds = gfx::Rect(100, 100, 100, 100);
   gfx::Rect desktop_bounds(Desktop::GetInstance()->GetSize());
   scoped_ptr<Window> w(CreateTestWindowWithDelegate(
       NULL, 1, original_bounds, NULL));
   EXPECT_EQ(original_bounds, w->bounds());
 
   // Maximized
@@ skipping 21 matching lines @@
   EXPECT_EQ(max_bounds, w->bounds());
   w->Fullscreen();
   EXPECT_EQ(ui::SHOW_STATE_FULLSCREEN, w->show_state());
   EXPECT_EQ(desktop_bounds, w->bounds());
   w->Maximize();
   EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED, w->show_state());
   EXPECT_EQ(max_bounds, w->bounds());
   w->Restore();
   EXPECT_EQ(ui::SHOW_STATE_NORMAL, w->show_state());
   EXPECT_EQ(original_bounds, w->bounds());
+
+  // Calling SetBounds() in maximized mode mode should only update the
+  // restore bounds not change the bounds of the window.
+  gfx::Rect new_bounds(50, 50, 50, 50);
+  w->Maximize();
+  w->SetBounds(new_bounds);
+  EXPECT_EQ(max_bounds, w->bounds());
+  w->Restore();
+  EXPECT_EQ(new_bounds, w->bounds());
 }
 
 // Various assertions for activating/deactivating.
 TEST_F(WindowTest, Deactivate) {
   TestWindowDelegate d1;
   TestWindowDelegate d2;
   scoped_ptr<Window> w1(
       CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(), NULL));
   scoped_ptr<Window> w2(
       CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(), NULL));
@@ skipping 29 matching lines @@
   Window* root = Desktop::GetInstance()->window();
   EXPECT_FALSE(root->IsOrContainsFullscreenWindow());
 
   w11->Fullscreen();
   EXPECT_TRUE(root->IsOrContainsFullscreenWindow());
 
   w11->Hide();
   EXPECT_FALSE(root->IsOrContainsFullscreenWindow());
 }
 
+class ToplevelWindowTest : public WindowTest {
+ public:
+  ToplevelWindowTest() {}
+  virtual ~ToplevelWindowTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    WindowTest::SetUp();
+    toplevel_container_.Init();
+    toplevel_container_.SetParent(aura::Desktop::GetInstance()->window());
+    toplevel_container_.SetBounds(
+        aura::Desktop::GetInstance()->window()->bounds());
+    toplevel_container_.Show();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    toplevel_container_.Hide();
+    toplevel_container_.SetParent(NULL);
+    WindowTest::TearDown();
+  }
+
+  Window* CreateTestToplevelWindow(
+      WindowDelegate* delegate, const gfx::Rect& bounds) {
+    return CreateTestWindowWithDelegate(
+        delegate, 0 /* id */, bounds, &toplevel_container_);
+  }
+
+  ToplevelWindowContainer toplevel_container_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ToplevelWindowTest);
+};
+
+// A window delegate that returns the specified window component type.
+// Default type is |HTNOWHERE|.
+class ComponentWindowDelegate : public TestWindowDelegate {

[Ben Goodger (Google), 2011/10/15 05:36:30]

This class and the test class above looks very similar to code in
toplevel_event_filter_unittest.cc. Since you're effectively testing its
functionality, you should move some of these tests into that file instead, and
you won't need this.

+ public:
+  ComponentWindowDelegate() : window_component_(HTNOWHERE) {}
+  ComponentWindowDelegate(int component) : window_component_(component) {}
+  virtual ~ComponentWindowDelegate() {}
+
+  virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
+    return window_component_;
+  }
+
+  void set_window_component(int component) {
+    window_component_ = component;
+  }
+
+ private:
+  int window_component_;
+};
+
+TEST_F(ToplevelWindowTest, TopMostActivate) {
+  ActivateWindowDelegate activate;
+  ActivateWindowDelegate non_activate(false);
+
+  scoped_ptr<Window> w1(CreateTestToplevelWindow(&non_activate, gfx::Rect()));
+  scoped_ptr<Window> w2(CreateTestToplevelWindow(&activate, gfx::Rect()));
+  scoped_ptr<Window> w3(CreateTestToplevelWindow(&non_activate, gfx::Rect()));
+  EXPECT_EQ(w2.get(), toplevel_container_.GetTopmostWindowToActivate(NULL));
+}
+
+TEST_F(ToplevelWindowTest, WindowDrag) {
+  ComponentWindowDelegate dd(HTCAPTION);
+  gfx::Rect bounds(100, 100, 100, 100);
+  scoped_ptr<Window> w1(CreateTestToplevelWindow(&dd, bounds));
+
+  EXPECT_EQ(bounds, w1->bounds());
+  EventGenerator generator;
+  generator.MoveMouseTo(150, 150);
+  generator.DragMouseTo(300, 200);
+  EXPECT_EQ(gfx::Rect(250, 150, 100, 100), w1->bounds());
+
+  // Maximized window cannot be dragged.
+  w1->Maximize();
+  generator.DragMouseTo(200, 150);
+  gfx::Rect workarea = gfx::Screen::GetMonitorWorkAreaNearestWindow(w1.get());
+  EXPECT_EQ(workarea, w1->bounds());
+  w1->Restore();
+
+  // Fullscreen cannot be dragged either.
+  w1->Fullscreen();
+  gfx::Rect monitor = gfx::Screen::GetMonitorAreaNearestWindow(w1.get());
+  generator.DragMouseTo(250, 200);
+  EXPECT_EQ(monitor, w1->bounds());
+}
+
+TEST_F(ToplevelWindowTest, WindowResize) {

[Ben Goodger (Google), 2011/10/15 05:36:30]

We already have tests for this in toplevel_event_filter_unittest, so i think you
can just skip this entire function.

+  ComponentWindowDelegate dd;
+  gfx::Rect bounds(100, 100, 100, 100);
+  scoped_ptr<Window> w1(CreateTestToplevelWindow(&dd, bounds));
+  EXPECT_EQ(bounds, w1->bounds());
+
+  // Resize using left edge.
+  dd.set_window_component(HTLEFT);
+  EventGenerator generator;
+  generator.MoveMouseTo(110, 150);
+  generator.DragMouseTo(50, 1000);
+  EXPECT_EQ(gfx::Rect(40, 100, 160, 100), w1->bounds());
+  // Move y coord to normal and drag again to right.
+  generator.MoveMouseTo(50, 150);
+  generator.DragMouseTo(70, 1000);
+  EXPECT_EQ(gfx::Rect(60, 100, 140, 100), w1->bounds());
+
+  // Resize using right edge.
+  w1->SetBounds(bounds);
+  dd.set_window_component(HTRIGHT);
+  generator.MoveMouseTo(190, 150);
+  generator.DragMouseTo(250, 1000);
+  EXPECT_EQ(gfx::Rect(100, 100, 160, 100), w1->bounds());
+  // Move y coord to normal and drag again to left.
+  generator.MoveMouseTo(250, 100);
+  generator.DragMouseTo(150, 1000);
+  EXPECT_EQ(gfx::Rect(100, 100, 60, 100), w1->bounds());
+
+  // Resize using top edge.
+  w1->SetBounds(bounds);
+  dd.set_window_component(HTTOP);
+  generator.MoveMouseTo(150, 110);
+  generator.DragMouseTo(1000, 50);
+  EXPECT_EQ(gfx::Rect(100, 40, 100, 160), w1->bounds());
+  // Move x coord to normal and drag again to bottom.
+  generator.MoveMouseTo(150, 50);
+  generator.DragMouseTo(1000, 150);
+  EXPECT_EQ(gfx::Rect(100, 140, 100, 60), w1->bounds());
+
+  // Resize using bottom edge.
+  w1->SetBounds(bounds);
+  dd.set_window_component(HTBOTTOM);
+  generator.MoveMouseTo(150, 190);
+  generator.DragMouseTo(1000, 250);
+  EXPECT_EQ(gfx::Rect(100, 100, 100, 160), w1->bounds());
+  // Move x coord to normal and drag again to bottom.
+  generator.MoveMouseTo(150, 250);
+  generator.DragMouseTo(1000, 150);
+  EXPECT_EQ(gfx::Rect(100, 100, 100, 60), w1->bounds());
+
+  // Resize using bottom right edge.
+  w1->SetBounds(bounds);
+  dd.set_window_component(HTBOTTOMRIGHT);
+  generator.MoveMouseTo(190, 190);
+  generator.DragMouseTo(300, 300);
+  EXPECT_EQ(gfx::Rect(100, 100, 210, 210), w1->bounds());
+  generator.DragMouseTo(150, 150);
+  EXPECT_EQ(gfx::Rect(100, 100, 60, 60), w1->bounds());
+
+  // Minimum size must be enforced.
+  w1->set_minimum_size(gfx::Size(30, 30));

[Ben Goodger (Google), 2011/10/15 05:36:30]

...except for this bit, which you can add a new test for in the other file.

+  generator.DragMouseTo(100, 100);
+  EXPECT_EQ(gfx::Rect(100, 100, 30, 30), w1->bounds());
+  generator.DragMouseTo(50, 50);
+  EXPECT_EQ(gfx::Rect(100, 100, 30, 30), w1->bounds());
+}
+
 class WindowObserverTest : public WindowTest,
                            public WindowObserver {
  public:
   WindowObserverTest() : added_count_(0), removed_count_(0) {}
 
   virtual ~WindowObserverTest() {}
 
   // Returns a description of the WindowObserver methods that have been invoked.
   std::string WindowObserverCountStateAndClear() {
     std::string result(
@@ skipping 88 matching lines @@
 
   w3->Activate();
   EXPECT_EQ(w2.get(), active());
 
   w1->Activate();
   EXPECT_EQ(w1.get(), active());
 }
 
 }  // namespace test
 }  // namespace aura