Revert of Set kCanMaximizeKey/kCanResizeKey before adding to parent.

ui/views/widget/native_widget_aura_unittest.cc

 // Copyright (c) 2012 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/views/widget/native_widget_aura.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 82 matching lines @@
   parent->SetBounds(gfx::Rect(20, 40, 480, 320));
   scoped_ptr<Widget> widget(new Widget());
   NativeWidgetAura* window = Init(parent.get(), widget.get());
   window->CenterWindow(gfx::Size(500, 600));
 
   // |window| should be no bigger than |parent|.
   EXPECT_EQ("20,40 480x320", window->GetNativeWindow()->bounds().ToString());
   widget->CloseNow();
 }
 
-class TestLayoutManagerBase : public aura::LayoutManager {
+// Used by ShowMaximizedDoesntBounceAround. See it for details.
+class TestLayoutManager : public aura::LayoutManager {
  public:
-  TestLayoutManagerBase() {}
-  virtual ~TestLayoutManagerBase() {}
+  TestLayoutManager() {}
 
-  // aura::LayoutManager:
-  virtual void OnWindowResized() OVERRIDE {}
-  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {}
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {}
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visible) OVERRIDE {}
-  virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) OVERRIDE {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestLayoutManagerBase);
-};
-
-// Used by ShowMaximizedDoesntBounceAround. See it for details.
-class MaximizeLayoutManager : public TestLayoutManagerBase {
- public:
-  MaximizeLayoutManager() {}
-  virtual ~MaximizeLayoutManager() {}
-
- private:
-  // aura::LayoutManager:
+  virtual void OnWindowResized() OVERRIDE {
+  }
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
     // This simulates what happens when adding a maximized window.
     SetChildBoundsDirect(child, gfx::Rect(0, 0, 300, 300));
   }
+  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {
+  }
+  virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
+  }
+  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
+                                              bool visible) OVERRIDE {
+  }
+  virtual void SetChildBounds(aura::Window* child,
+                              const gfx::Rect& requested_bounds) OVERRIDE {
+  }
 
-  DISALLOW_COPY_AND_ASSIGN(MaximizeLayoutManager);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestLayoutManager);
 };
 
 // This simulates BrowserView, which creates a custom RootView so that
 // OnNativeWidgetSizeChanged that is invoked during Init matters.
 class TestWidget : public views::Widget {
  public:
   TestWidget() : did_size_change_more_than_once_(false) {
   }
 
   // Returns true if the size changes to a non-empty size, and then to another
@@ skipping 16 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestWidget);
 };
 
 // Verifies the size of the widget doesn't change more than once during Init if
 // the window ends up maximized. This is important as otherwise
 // RenderWidgetHostViewAura ends up getting resized during construction, which
 // leads to noticable flashes.
 TEST_F(NativeWidgetAuraTest, ShowMaximizedDoesntBounceAround) {
   root_window()->SetBounds(gfx::Rect(0, 0, 640, 480));
-  root_window()->SetLayoutManager(new MaximizeLayoutManager);
+  root_window()->SetLayoutManager(new TestLayoutManager);
   scoped_ptr<TestWidget> widget(new TestWidget());
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = NULL;
   params.context = root_window();
   params.show_state = ui::SHOW_STATE_MAXIMIZED;
   params.bounds = gfx::Rect(10, 10, 100, 200);
   widget->Init(params);
   EXPECT_FALSE(widget->did_size_change_more_than_once());
   widget->CloseNow();
 }
 
-class PropertyTestLayoutManager : public TestLayoutManagerBase {
- public:
-  PropertyTestLayoutManager() : added_(false) {}
-  virtual ~PropertyTestLayoutManager() {}
-
-  bool added() const { return added_; }
-
- private:
-  // aura::LayoutManager:
-  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
-    EXPECT_TRUE(child->GetProperty(aura::client::kCanMaximizeKey));
-    EXPECT_TRUE(child->GetProperty(aura::client::kCanResizeKey));
-    added_ = true;
-  }
-
-  bool added_;
-
-  DISALLOW_COPY_AND_ASSIGN(PropertyTestLayoutManager);
-};
-
-class PropertyTestWidgetDelegate : public views::WidgetDelegate {
- public:
-  explicit PropertyTestWidgetDelegate(Widget* widget) : widget_(widget) {}
-  virtual ~PropertyTestWidgetDelegate() {}
-
- private:
-  // views::WidgetDelegate:
-  virtual bool CanMaximize() const OVERRIDE {
-    return true;
-  }
-  virtual bool CanResize() const OVERRIDE {
-    return true;
-  }
-  virtual Widget* GetWidget() OVERRIDE {
-    return widget_;
-  }
-  virtual const Widget* GetWidget() const OVERRIDE {
-    return widget_;
-  }
-
-  Widget* widget_;
-  DISALLOW_COPY_AND_ASSIGN(PropertyTestWidgetDelegate);
-};
-
-// Verifies that the kCanMaximizeKey/kCanReizeKey have the correct
-// value when added to the layout manager.
-TEST_F(NativeWidgetAuraTest, TestPropertiesWhenAddedToLayout) {
-  root_window()->SetBounds(gfx::Rect(0, 0, 640, 480));
-  PropertyTestLayoutManager* layout_manager = new PropertyTestLayoutManager();
-  root_window()->SetLayoutManager(layout_manager);
-  scoped_ptr<TestWidget> widget(new TestWidget());
-  Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
-  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  params.delegate = new PropertyTestWidgetDelegate(widget.get());
-  params.parent = NULL;
-  params.context = root_window();
-  widget->Init(params);
-  EXPECT_TRUE(layout_manager->added());
-  widget->CloseNow();
-}
-
 TEST_F(NativeWidgetAuraTest, GetClientAreaScreenBounds) {
   // Create a widget.
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.context = root_window();
   params.bounds.SetRect(10, 20, 300, 400);
   scoped_ptr<Widget> widget(new Widget());
   widget->Init(params);
 
   // For Aura, client area bounds match window bounds.
   gfx::Rect client_bounds = widget->GetClientAreaBoundsInScreen();
   EXPECT_EQ(10, client_bounds.x());
   EXPECT_EQ(20, client_bounds.y());
   EXPECT_EQ(300, client_bounds.width());
   EXPECT_EQ(400, client_bounds.height());
 }
 
+namespace {
+
 // View subclass that tracks whether it has gotten a gesture event.
 class GestureTrackingView : public views::View {
  public:
   GestureTrackingView()
       : got_gesture_event_(false),
         consume_gesture_event_(true) {}
 
   void set_consume_gesture_event(bool value) {
     consume_gesture_event_ = value;
   }
@@ skipping 15 matching lines @@
  private:
   // Was OnGestureEvent() invoked?
   bool got_gesture_event_;
 
   // Dictates what OnGestureEvent() returns.
   bool consume_gesture_event_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureTrackingView);
 };
 
+}  // namespace
+
 // Verifies a capture isn't set on touch press and that the view that gets
 // the press gets the release.
 TEST_F(NativeWidgetAuraTest, DontCaptureOnGesture) {
   // Create two views (both sized the same). |child| is configured not to
   // consume the gesture event.
   GestureTrackingView* view = new GestureTrackingView();
   GestureTrackingView* child = new GestureTrackingView();
   child->set_consume_gesture_event(false);
   view->SetLayoutManager(new FillLayout);
   view->AddChildView(child);
@@ skipping 162 matching lines @@
   delegate->ClearGotMove();
   // Simulate a maximize with animation.
   delete widget->GetNativeView()->RecreateLayer().release();
   widget->SetBounds(gfx::Rect(0, 0, 500, 500));
   EXPECT_TRUE(delegate->got_move());
   widget->CloseNow();
 }
 
 }  // namespace
 }  // namespace views