Rework the way Widget::Init works:

views/view_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 <map>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/base/clipboard/clipboard.h"
@@ skipping 34 matching lines @@
 
 namespace {
 
 class ViewTest : public ViewsTestBase {
  public:
   ViewTest() {
   }
 
   virtual ~ViewTest() {
   }
-
-  Widget* CreateWidget() {
-    return Widget::CreateWidget(
-        Widget::CreateParams(Widget::CreateParams::TYPE_WINDOW));
-  }
 };
 
 /*
 
 // Paints the RootView.
 void PaintRootView(views::RootView* root, bool empty_paint) {
   if (!empty_paint) {
     root->PaintNow();
   } else {
     // User isn't logged in, so that PaintNow will generate an empty rectangle.
@@ skipping 289 matching lines @@
   location_.SetPoint(event.x(), event.y());
 }
 
 TEST_F(ViewTest, MouseEvent) {
   TestView* v1 = new TestView();
   v1->SetBounds(0, 0, 300, 300);
 
   TestView* v2 = new TestView();
   v2->SetBounds(100, 100, 100, 100);
 
-  scoped_ptr<Widget> widget(CreateWidget());
+  scoped_ptr<Widget> widget(Widget::CreateWidget());
   Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
-  widget->SetCreateParams(params);
-  widget->Init(NULL, gfx::Rect(50, 50, 650, 650));
+  params.bounds = gfx::Rect(50, 50, 650, 650);
+  widget->Init(params);
   RootView* root = widget->GetRootView();
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
   v1->Reset();
   v2->Reset();
 
   MouseEvent pressed(ui::ET_MOUSE_PRESSED,
                      110,
@@ skipping 84 matching lines @@
 
   TestView* v1 = new TestView();
   v1->SetBounds(0, 0, 300, 300);
 
   TestView* v2 = new TestView();
   v2->SetBounds(100, 100, 100, 100);
 
   TestView* v3 = new TestViewIgnoreTouch();
   v3->SetBounds(0, 0, 100, 100);
 
-  scoped_ptr<Widget> window(CreateWidget());
-#if defined(OS_WIN)
-  // This code would need to be here when we support
-  // touch on windows?
-  WidgetWin* window_win = static_cast<WidgetWin*>(window.get());
-  window_win->set_delete_on_destroy(false);
-  window_win->set_window_style(WS_OVERLAPPEDWINDOW);
-  window_win->Init(NULL, gfx::Rect(50, 50, 650, 650));
-#endif
+  scoped_ptr<Widget> widget(Widget::CreateWidget());
+  Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+  params.delete_on_destroy = false;
+  params.bounds = gfx::Rect(50, 50, 650, 650);
+  widget->Init(params);
   RootView* root = window->GetRootView();
 
   root->AddChildView(v1);
   root->SetGestureManager(gm);
   v1->AddChildView(v2);
   v2->AddChildView(v3);
 
   // |v3| completely obscures |v2|, but all the touch events on |v3| should
   // reach |v2| because |v3| doesn't process any touch events.
 
@@ skipping 74 matching lines @@
   EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_RELEASED);
   EXPECT_EQ(v2->location_.x(), -100);
   EXPECT_EQ(v2->location_.y(), -100);
   // Make sure v1 did not receive the event
   EXPECT_EQ(v1->last_touch_event_type_, 0);
 
   EXPECT_EQ(gm->last_touch_event_, 0);
   EXPECT_EQ(NULL, gm->last_view_);
   EXPECT_EQ(gm->previously_handled_flag_, false);
 
-  window->CloseNow();
+  widget->CloseNow();
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Painting
 ////////////////////////////////////////////////////////////////////////////////
 
 void TestView::Paint(gfx::Canvas* canvas) {
   canvas->AsCanvasSkia()->getClipBounds(&last_clip_);
 }
@@ skipping 74 matching lines @@
   // Make sure v4 was not painted
   tmp_rect.setEmpty();
   CheckRect(v4->last_clip_, tmp_rect);
 
   window.DestroyWindow();
 }
 */
 
 TEST_F(ViewTest, RemoveNotification) {
   views::ViewStorage* vs = views::ViewStorage::GetInstance();
-  views::Widget* window = CreateWidget();
-  views::RootView* root_view = window->GetRootView();
+  views::Widget* widget = Widget::CreateWidget();
+  views::RootView* root_view = widget->GetRootView();
 
   View* v1 = new View;
   int s1 = vs->CreateStorageID();
   vs->StoreView(s1, v1);
   root_view->AddChildView(v1);
   View* v11 = new View;
   int s11 = vs->CreateStorageID();
   vs->StoreView(s11, v11);
   v1->AddChildView(v11);
   View* v111 = new View;
@@ skipping 53 matching lines @@
   EXPECT_EQ(NULL, vs->RetrieveView(s12));
   EXPECT_EQ(NULL, vs->RetrieveView(s111));
   EXPECT_EQ(NULL, vs->RetrieveView(s112));
 
   // Put v1 back for more tests.
   root_view->AddChildView(v1);
   vs->StoreView(s1, v1);
 
   // Now delete the root view (deleting the window will trigger a delete of the
   // RootView) and make sure we are notified that the views were removed.
-  delete window;
+  delete widget;
   EXPECT_EQ(stored_views - 10, vs->view_count());
   EXPECT_EQ(NULL, vs->RetrieveView(s1));
   EXPECT_EQ(NULL, vs->RetrieveView(s12));
   EXPECT_EQ(NULL, vs->RetrieveView(s11));
   EXPECT_EQ(NULL, vs->RetrieveView(s12));
   EXPECT_EQ(NULL, vs->RetrieveView(s21));
   EXPECT_EQ(NULL, vs->RetrieveView(s111));
   EXPECT_EQ(NULL, vs->RetrieveView(s112));
 }
 
@@ skipping 31 matching lines @@
 };
 
 gfx::Point ConvertPointToView(views::View* view, const gfx::Point& p) {
   gfx::Point tmp(p);
   views::View::ConvertPointToView(view->GetRootView(), view, &tmp);
   return tmp;
 }
 }
 
 TEST_F(ViewTest, HitTestMasks) {
-  scoped_ptr<views::Widget> window(CreateWidget());
-  views::RootView* root_view = window->GetRootView();
+  scoped_ptr<views::Widget> widget(Widget::CreateWidget());
+  views::RootView* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 500, 500);
 
   gfx::Rect v1_bounds = gfx::Rect(0, 0, 100, 100);
   HitTestView* v1 = new HitTestView(false);
   v1->SetBoundsRect(v1_bounds);
   root_view->AddChildView(v1);
 
   gfx::Rect v2_bounds = gfx::Rect(105, 0, 100, 100);
   HitTestView* v2 = new HitTestView(true);
   v2->SetBoundsRect(v2_bounds);
@@ skipping 19 matching lines @@
 }
 
 TEST_F(ViewTest, Textfield) {
   const string16 kText = ASCIIToUTF16("Reality is that which, when you stop "
                                       "believing it, doesn't go away.");
   const string16 kExtraText = ASCIIToUTF16("Pretty deep, Philip!");
   const string16 kEmptyString;
 
   ui::Clipboard clipboard;
 
-  Widget* window = CreateWidget();
-  window->Init(NULL, gfx::Rect(0, 0, 100, 100));
-  RootView* root_view = window->GetRootView();
+  Widget* widget = Widget::CreateWidget();
+  Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+  params.bounds = gfx::Rect(0, 0, 100, 100);
+  widget->Init(params);
+  RootView* root_view = widget->GetRootView();
 
   Textfield* textfield = new Textfield();
   root_view->AddChildView(textfield);
 
   // Test setting, appending text.
   textfield->SetText(kText);
   EXPECT_EQ(kText, textfield->text());
   textfield->AppendText(kExtraText);
   EXPECT_EQ(kText + kExtraText, textfield->text());
   textfield->SetText(string16());
@@ skipping 13 matching lines @@
 // Tests that the Textfield view respond appropiately to cut/copy/paste.
 TEST_F(ViewTest, TextfieldCutCopyPaste) {
   views::ViewsDelegate::views_delegate = new TestViewsDelegate;
 
   const std::wstring kNormalText = L"Normal";
   const std::wstring kReadOnlyText = L"Read only";
   const std::wstring kPasswordText = L"Password! ** Secret stuff **";
 
   ui::Clipboard clipboard;
 
-  Widget* window = CreateWidget();
-#if defined(OS_WIN)
-  static_cast<WidgetWin*>(window)->Init(NULL, gfx::Rect(0, 0, 100, 100));
-#endif
-  RootView* root_view = window->GetRootView();
+  Widget* widget = Widget::CreateWidget();
+  Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+  params.bounds = gfx::Rect(0, 0, 100, 100);
+  widget->Init(params);
+  RootView* root_view = widget->GetRootView();
 
   Textfield* normal = new Textfield();
   Textfield* read_only = new Textfield();
   read_only->SetReadOnly(true);
   Textfield* password = new Textfield(Textfield::STYLE_PASSWORD);
 
   root_view->AddChildView(normal);
   root_view->AddChildView(read_only);
   root_view->AddChildView(password);
 
@@ skipping 99 matching lines @@
 #if defined(OS_WIN)
 TEST_F(ViewTest, ActivateAccelerator) {
   // Register a keyboard accelerator before the view is added to a window.
   views::Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 0);
 
   // Create a window and add the view as its child.
-  WidgetWin widget;
+  scoped_ptr<Widget> widget(Widget::CreateWidget());
   Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
-  widget.SetCreateParams(params);
-  widget.Init(NULL, gfx::Rect(0, 0, 100, 100));
-  RootView* root = widget.GetRootView();
+  params.bounds = gfx::Rect(0, 0, 100, 100);
+  widget->Init(params);
+  RootView* root = widget->GetRootView();
   root->AddChildView(view);
 
   // Get the focus manager.
   views::FocusManager* focus_manager =
-      views::FocusManager::GetFocusManagerForNativeView(widget.GetNativeView());
+      views::FocusManager::GetFocusManagerForNativeView(
+          widget->GetNativeView());
   ASSERT_TRUE(focus_manager);
 
   // Hit the return key and see if it takes effect.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 1);
 
   // Hit the escape key. Nothing should happen.
   views::Accelerator escape_accelerator(ui::VKEY_ESCAPE, false, false, false);
   EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 1);
@@ skipping 22 matching lines @@
 
   // Remove all the accelerators.
   view->ResetAccelerators();
   EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 2);
   EXPECT_EQ(view->accelerator_count_map_[escape_accelerator], 2);
   EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 2);
   EXPECT_EQ(view->accelerator_count_map_[escape_accelerator], 2);
 
-  widget.CloseNow();
+  widget->CloseNow();
 }
 #endif
 
 #if defined(OS_WIN)
 TEST_F(ViewTest, HiddenViewWithAccelerator) {
   views::Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 0);
 
-  WidgetWin widget;
+  scoped_ptr<Widget> widget(Widget::CreateWidget());
   Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
-  widget.SetCreateParams(params);
-  widget.Init(NULL, gfx::Rect(0, 0, 100, 100));
-  RootView* root = widget.GetRootView();
+  params.bounds = gfx::Rect(0, 0, 100, 100);
+  widget->Init(params);
+  RootView* root = widget->GetRootView();
   root->AddChildView(view);
 
   views::FocusManager* focus_manager =
-      views::FocusManager::GetFocusManagerForNativeView(widget.GetNativeView());
+      views::FocusManager::GetFocusManagerForNativeView(
+          widget->GetNativeView());
   ASSERT_TRUE(focus_manager);
 
   view->SetVisible(false);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   view->SetVisible(true);
   EXPECT_EQ(view,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
-  widget.CloseNow();
+  widget->CloseNow();
 }
 #endif
 
 #if defined(OS_WIN)
 ////////////////////////////////////////////////////////////////////////////////
 // Mouse-wheel message rerouting
 ////////////////////////////////////////////////////////////////////////////////
 class ButtonTest : public NativeButtonBase {
  public:
   ButtonTest(ButtonListener* listener, const std::wstring& label)
@@ skipping 451 matching lines @@
   };
   static const size_t kTotalViews = 2;
   std::vector<NotificationInfo> notifications_;
 };
 
 class TestChangeNativeViewHierarchy {
  public:
   explicit TestChangeNativeViewHierarchy(ViewTest *view_test) {
     view_test_ = view_test;
     native_host_ = new views::NativeViewHost();
-    host_ = view_test->CreateWidget();
-    host_->Init(NULL, gfx::Rect(0, 0, 500, 300));
+    host_ = Widget::CreateWidget();
+    Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+    params.bounds = gfx::Rect(0, 0, 500, 300);
+    host_->Init(params);
     host_->GetRootView()->AddChildView(native_host_);
     for (size_t i = 0; i < TestNativeViewHierarchy::kTotalViews; ++i) {
-      windows_[i] = view_test->CreateWidget();
-      windows_[i]->Init(host_->GetNativeView(), gfx::Rect(0, 0, 500, 300));
+      windows_[i] = Widget::CreateWidget();
+      Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+      params.parent = host_->GetNativeView();
+      params.bounds = gfx::Rect(0, 0, 500, 300);
+      windows_[i]->Init(params);
       root_views_[i] = windows_[i]->GetRootView();
       test_views_[i] = new TestNativeViewHierarchy;
       root_views_[i]->AddChildView(test_views_[i]);
     }
   }
 
   ~TestChangeNativeViewHierarchy() {
     for (size_t i = 0; i < TestNativeViewHierarchy::kTotalViews; ++i) {
       windows_[i]->Close();
     }
@@ skipping 100 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TransformPaintView);
 };
 
 TEST_F(ViewTest, TransformPaint) {
   TransformPaintView* v1 = new TransformPaintView();
   v1->SetBounds(0, 0, 500, 300);
 
   TestView* v2 = new TestView();
   v2->SetBounds(100, 100, 200, 100);
 
-  Widget* widget = CreateWidget();
-#if defined(OS_WIN)
-  WidgetWin* window_win = static_cast<WidgetWin*>(widget);
-  window_win->set_window_style(WS_OVERLAPPEDWINDOW);
-  window_win->Init(NULL, gfx::Rect(50, 50, 650, 650));
-#endif
+  Widget* widget = Widget::CreateWidget();
+  Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+  params.bounds = gfx::Rect(50, 50, 650, 650);
+  widget->Init(params);
   widget->Show();
   RootView* root = widget->GetRootView();
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
   // At this moment, |v2| occupies (100, 100) to (300, 200) in |root|.
   v1->ClearScheduledPaintRect();
   v2->SchedulePaint();
 
@@ skipping 13 matching lines @@
   widget->CloseNow();
 }
 
 TEST_F(ViewTest, TransformEvent) {
   TestView* v1 = new TestView();
   v1->SetBounds(0, 0, 500, 300);
 
   TestView* v2 = new TestView();
   v2->SetBounds(100, 100, 200, 100);
 
-  Widget* widget = CreateWidget();
-#if defined(OS_WIN)
-  WidgetWin* window_win = static_cast<WidgetWin*>(widget);
-  window_win->set_window_style(WS_OVERLAPPEDWINDOW);
-  window_win->Init(NULL, gfx::Rect(50, 50, 650, 650));
-#endif
+  Widget* widget = Widget::CreateWidget();
+  Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
+  params.bounds = gfx::Rect(50, 50, 650, 650);
+  widget->Init(params);
   RootView* root = widget->GetRootView();
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
   // At this moment, |v2| occupies (100, 100) to (300, 200) in |root|.
 
   // Rotate |v1| counter-clockwise.
   v1->SetRotation(-90.0);
   v1->SetTranslateY(500);
@@ skipping 126 matching lines @@
   bool received_notification_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibleBoundsView);
 };
 
 #if defined(OS_WIN)
 // TODO(beng): This can be cross platform when widget construction/init is.
 TEST_F(ViewTest, OnVisibleBoundsChanged) {
   gfx::Rect viewport_bounds(0, 0, 100, 100);
 
-  scoped_ptr<Widget> widget(CreateWidget());
+  scoped_ptr<Widget> widget(Widget::CreateWidget());
   Widget::CreateParams params(Widget::CreateParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
-  widget->SetCreateParams(params);
-  widget->Init(NULL, viewport_bounds);
+  params.bounds = viewport_bounds;
+  widget->Init(params);
   widget->GetRootView()->SetBoundsRect(viewport_bounds);
 
   View* viewport = new View;
   widget->GetRootView()->SetContentsView(viewport);
   View* contents = new View;
   viewport->AddChildView(contents);
   viewport->SetBoundsRect(viewport_bounds);
   contents->SetBounds(0, 0, 100, 200);
 
   // Create a view that cares about visible bounds notifications, and position
@@ skipping 41 matching lines @@
   top_view->scheduled_paint_rects_.clear();
   child_view->SetBounds(30, 30, 20, 20);
   EXPECT_EQ(2U, top_view->scheduled_paint_rects_.size());
 
   // There should be 2 rects, spanning from (10, 10) to (50, 50).
   gfx::Rect paint_rect =
       top_view->scheduled_paint_rects_[0].Union(
           top_view->scheduled_paint_rects_[1]);
   EXPECT_EQ(gfx::Rect(10, 10, 40, 40), paint_rect);
 }