Move maximize/fullscreen/restore to shell

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"
@@ skipping 813 matching lines @@
   w121->Focus();
   EXPECT_EQ(w121.get(), w1->GetFocusManager()->GetFocusedWindow());
 
   // An attempt to focus 111 should be ignored and w121 should retain focus,
   // since a consumes_events_ window with a child is in the z-index above w111.
   EXPECT_FALSE(w111->CanFocus());
   w111->Focus();
   EXPECT_EQ(w121.get(), w1->GetFocusManager()->GetFocusedWindow());
 }
 
-TEST_F(WindowTest, Fullscreen) {
-  gfx::Rect original_bounds = gfx::Rect(100, 100, 100, 100);
-  gfx::Rect desktop_bounds(Desktop::GetInstance()->GetHostSize());
-  scoped_ptr<Window> w(CreateTestWindowWithDelegate(
-      NULL, 1, original_bounds, NULL));
-  EXPECT_EQ(original_bounds, w->bounds());
-
-  // Restoreing the restored window.
-  w->Restore();
-  EXPECT_EQ(ui::SHOW_STATE_NORMAL, w->show_state());
-  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());
-
-  // 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(
-      gfx::Screen::GetMonitorWorkAreaNearestPoint(gfx::Point()));
-  scoped_ptr<Window> w(CreateTestWindowWithDelegate(
-      NULL, 1, original_bounds, NULL));
-  EXPECT_EQ(original_bounds, w->bounds());
-
-  // Maximized
-  w->Maximize();
-  EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED, w->show_state());
-  gfx::Rect max_bounds(desktop_bounds);
-  EXPECT_EQ(max_bounds, w->bounds());
-  w->Restore();
-  EXPECT_EQ(ui::SHOW_STATE_NORMAL, w->show_state());
-  EXPECT_EQ(original_bounds, w->bounds());
-
-  // Maximize twice
-  w->Maximize();
-  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());
-
-  // Maximized -> Fullscreen -> Maximized -> Normal
-  w->Maximize();
-  EXPECT_EQ(ui::SHOW_STATE_MAXIMIZED, w->show_state());
-  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));
   Window* parent = w1->parent();
   parent->Show();
@@ skipping 11 matching lines @@
   EXPECT_FALSE(w2->IsActive());
   EXPECT_EQ(w1.get(), parent->children()[1]);
 
   // Deactivate w1 and make sure w2 becomes active and frontmost.
   w1->Deactivate();
   EXPECT_FALSE(w1->IsActive());
   EXPECT_TRUE(w2->IsActive());
   EXPECT_EQ(w2.get(), parent->children()[1]);
 }
 
-TEST_F(WindowTest, IsOrContainsFullscreenWindow) {
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(NULL, 1, gfx::Rect(0, 0, 100, 100), NULL));
-  scoped_ptr<Window> w11(
-      CreateTestWindow(SK_ColorWHITE, 11, gfx::Rect(0, 0, 10, 10), w1.get()));
-
-  Window* root = Desktop::GetInstance();
-  EXPECT_FALSE(root->IsOrContainsFullscreenWindow());
-
-  w11->Fullscreen();
-  EXPECT_TRUE(root->IsOrContainsFullscreenWindow());
-
-  w11->Hide();
-  EXPECT_FALSE(root->IsOrContainsFullscreenWindow());
-}
-
 #if !defined(OS_WIN)
 // Tests transformation on the desktop.
 TEST_F(WindowTest, Transform) {
   Desktop* desktop = Desktop::GetInstance();
   desktop->ShowDesktop();
   gfx::Size size = desktop->GetHostSize();
   EXPECT_EQ(gfx::Rect(size),
             gfx::Screen::GetMonitorAreaNearestPoint(gfx::Point()));
 
   // Rotate it clock-wise 90 degrees.
@@ skipping 103 matching lines @@
 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));
 }
 
-// Tests that maximized windows get resized after desktop is resized.
-TEST_F(ToplevelWindowTest, MaximizeAfterDesktopResize) {
-  gfx::Rect window_bounds(10, 10, 300, 400);
-  scoped_ptr<Window> w1(CreateTestToplevelWindow(NULL, window_bounds));
-
-  w1->Show();
-  EXPECT_EQ(window_bounds, w1->bounds());
-
-  w1->Maximize();
-  EXPECT_EQ(gfx::Screen::GetMonitorWorkAreaNearestWindow(w1.get()),
-                                                         w1->bounds());
-
-  // Resize the desktop.
-  Desktop* desktop = Desktop::GetInstance();
-  gfx::Size desktop_size = desktop->GetHostSize();
-  desktop->SetBounds(gfx::Rect(0, 0, desktop_size.width() + 100,
-                                 desktop_size.height() + 200));
-
-  EXPECT_EQ(gfx::Screen::GetMonitorWorkAreaNearestWindow(w1.get()),
-                                                         w1->bounds());
-
-  w1->Restore();
-  EXPECT_EQ(window_bounds, w1->bounds());
-}
-
-// Tests that fullscreen windows get resized after desktop is resized.
-TEST_F(ToplevelWindowTest, FullscreenAfterDesktopResize) {
-  gfx::Rect window_bounds(10, 10, 300, 400);
-  scoped_ptr<Window> w1(CreateTestToplevelWindow(NULL, window_bounds));
-
-  w1->Show();
-  EXPECT_EQ(window_bounds, w1->bounds());
-
-  w1->Fullscreen();
-  EXPECT_EQ(gfx::Screen::GetMonitorAreaNearestWindow(w1.get()), w1->bounds());
-
-  // Resize the desktop.
-  Desktop* desktop = Desktop::GetInstance();
-  gfx::Size desktop_size = desktop->GetHostSize();
-  desktop->SetBounds(gfx::Rect(0, 0, desktop_size.width() + 100,
-                                 desktop_size.height() + 200));
-
-  EXPECT_EQ(gfx::Screen::GetMonitorAreaNearestWindow(w1.get()), w1->bounds());
-
-  w1->Restore();
-  EXPECT_EQ(window_bounds, w1->bounds());
-}
-
 TEST_F(WindowTest, Property) {
   scoped_ptr<Window> w(CreateTestWindowWithId(0, NULL));
   const gfx::NativeView target = const_cast<const gfx::NativeView>(w.get());
   const char* key = "test";
   EXPECT_EQ(NULL, w->GetProperty(key));
+  EXPECT_EQ(0, w->GetIntProperty(key));
   EXPECT_EQ(NULL, ui::ViewProp::GetValue(target, key));
 
+  w->SetIntProperty(key, 1);
+  EXPECT_EQ(1, w->GetIntProperty(key));
   void* value = reinterpret_cast<void*>(static_cast<intptr_t>(1));
-  w->SetProperty(key, value);
-  EXPECT_EQ(value, w->GetProperty(key));
   EXPECT_EQ(value, ui::ViewProp::GetValue(target, key));
 
   // Overwrite the property with different value type.
   w->SetProperty(key, static_cast<void*>(const_cast<char*>("string")));
   std::string expected("string");
-  EXPECT_EQ(expected,
-            static_cast<const char*>(w->GetProperty(key)));
+  EXPECT_EQ(expected, static_cast<const char*>(w->GetProperty(key)));
   EXPECT_EQ(expected,
             static_cast<const char*>(ui::ViewProp::GetValue(target, key)));
 
   // Non-existent property.
   EXPECT_EQ(NULL, w->GetProperty("foo"));
+  EXPECT_EQ(0, w->GetIntProperty("foo"));
   EXPECT_EQ(NULL, ui::ViewProp::GetValue(target, "foo"));
 
   // Set NULL and make sure the property is gone.
   w->SetProperty(key, NULL);
   EXPECT_EQ(NULL, w->GetProperty(key));
+  EXPECT_EQ(0, w->GetIntProperty(key));
   EXPECT_EQ(NULL, ui::ViewProp::GetValue(target, key));
 }
 
 class WindowObserverTest : public WindowTest,
                            public WindowObserver {
  public:
   struct VisibilityInfo {
     bool window_visible;
     bool visible_param;
   };
 
   WindowObserverTest()
       : added_count_(0),
         removed_count_(0),
-        destroyed_count_(0) {
+        destroyed_count_(0),
+        old_property_value_(NULL),
+        new_property_value_(NULL) {
   }
 
   virtual ~WindowObserverTest() {}
 
   const VisibilityInfo* GetVisibilityInfo() const {
     return visibility_info_.get();
   }
 
   void ResetVisibilityInfo() {
     visibility_info_.reset();
   }
 
   // Returns a description of the WindowObserver methods that have been invoked.
   std::string WindowObserverCountStateAndClear() {
     std::string result(
         base::StringPrintf("added=%d removed=%d",
         added_count_, removed_count_));
     added_count_ = removed_count_ = 0;
     return result;
   }
 
   int DestroyedCountAndClear() {
     int result = destroyed_count_;
     destroyed_count_ = 0;
     return result;
   }
 
+  std::string PropertyChangeInfoAndClear() {

[sky, 2011/10/31 23:17:34]

Add a description of what this does.

[oshima, 2011/11/01 00:40:33]

Done.

+    std::string result(
+        base::StringPrintf("name=%s old=%p new=%p",
+                           property_name_.c_str(),
+                           old_property_value_,
+                           new_property_value_));
+    property_name_.clear();
+    old_property_value_ = NULL;
+    new_property_value_ = NULL;
+    return result;
+  }
+
  private:
   virtual void OnWindowAdded(Window* new_window) OVERRIDE {
     added_count_++;
   }
 
   virtual void OnWillRemoveWindow(Window* window) OVERRIDE {
     removed_count_++;
   }
 
   virtual void OnWindowVisibilityChanged(Window* window,
                                          bool visible) OVERRIDE {
     visibility_info_.reset(new VisibilityInfo);
     visibility_info_->window_visible = window->IsVisible();
     visibility_info_->visible_param = visible;
   }
 
   virtual void OnWindowDestroyed(Window* window) OVERRIDE {
     destroyed_count_++;
   }
 
+  virtual void OnPropertyChanged(Window* window,
+                                 const char* name,
+                                 void* old) OVERRIDE {
+    property_name_ = std::string(name);
+    old_property_value_ = old;
+    new_property_value_ = window->GetProperty(name);
+  }
+
   int added_count_;
   int removed_count_;
   int destroyed_count_;
   scoped_ptr<VisibilityInfo> visibility_info_;
+  std::string property_name_;
+  void* old_property_value_;
+  void* new_property_value_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserverTest);
 };
 
 // Various assertions for WindowObserver.
 TEST_F(WindowObserverTest, WindowObserver) {
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
   w1->AddObserver(this);
 
   // Create a new window as a child of w1, our observer should be notified.
@@ skipping 66 matching lines @@
   EXPECT_EQ(1, DestroyedCountAndClear());
 
   // Observe on child and delete parent window should fire a notification.
   scoped_ptr<Window> parent(CreateTestWindowWithId(1, NULL));
   Window* child = CreateTestWindowWithId(1, parent.get());  // owned by parent
   child->AddObserver(this);
   parent.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 }
 
+TEST_F(WindowObserverTest, PropertyChanged) {
+  // Setting property should fire a property change notification.
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+  w1->AddObserver(this);
+  w1->SetIntProperty("test", 1);
+  EXPECT_EQ("name=test old=(nil) new=0x1", PropertyChangeInfoAndClear());
+  w1->SetIntProperty("test", 2);
+  EXPECT_EQ("name=test old=0x1 new=0x2", PropertyChangeInfoAndClear());
+  w1->SetProperty("test", NULL);
+  EXPECT_EQ("name=test old=0x2 new=(nil)", PropertyChangeInfoAndClear());
+
+  // Sanity check to see if |PropertyChangeInfoAndClear| really clears.
+  EXPECT_EQ("name= old=(nil) new=(nil)", PropertyChangeInfoAndClear());
+}
+
 class DesktopObserverTest : public WindowTest,
                             public DesktopObserver {
  public:
   DesktopObserverTest() : active_(NULL) {
   }
 
   virtual ~DesktopObserverTest() {}
 
   Window* active() const { return active_; }
 
@@ skipping 33 matching lines @@
 
   w3->Activate();
   EXPECT_EQ(w2.get(), active());
 
   w1->Activate();
   EXPECT_EQ(w1.get(), active());
 }
 
 }  // namespace test
 }  // namespace aura