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/base/keycodes/keyboard_codes.h"
 
 namespace aura {
 namespace test {
@@ skipping 340 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();
+  aura::Desktop* desktop = aura::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);
 
   desktop->OnTouchEvent(TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(50, 50),
                                    0));
   EXPECT_EQ(1, delegate.touch_event_count());
   delegate.set_touch_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());
 
   desktop->OnTouchEvent(TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(50, 50),
                                    0));
   EXPECT_EQ(0, delegate.touch_event_count());
 }
 
 // Verifies capture is reset when a window is destroyed.
 TEST_F(WindowTest, ReleaseCaptureOnDestroy) {
   Desktop* desktop = Desktop::GetInstance();
@@ skipping 78 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(Event* 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 224 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);
+};
+
+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));
+}
+
 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