Re-land:

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 23 matching lines @@
 #include "views/test/test_views_delegate.h"
 #elif defined(OS_LINUX)
 #include "views/widget/widget_gtk.h"
 #include "views/window/window_gtk.h"
 #endif
 #if defined(TOUCH_UI)
 #include "views/touchui/gesture_manager.h"
 #endif
 
 using ::testing::_;
-using namespace views;
 
-namespace {
+namespace views {
 
 class ViewTest : public ViewsTestBase {
  public:
   ViewTest() {
   }
 
   virtual ~ViewTest() {
   }
 };
 
-/*
-
-// 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.
-    // Invoke paint directly.
-    gfx::Rect paint_rect = root->GetScheduledPaintRect();
-    gfx::CanvasSkia canvas(paint_rect.width(), paint_rect.height(), true);
-    canvas.TranslateInt(-paint_rect.x(), -paint_rect.y());
-    canvas.ClipRectInt(0, 0, paint_rect.width(), paint_rect.height());
-    root->Paint(&canvas);
-  }
-}
-
-typedef CWinTraits<WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS> CVTWTraits;
-
-// A trivial window implementation that tracks whether or not it has been
-// painted. This is used by the painting test to determine if paint will result
-// in an empty region.
-class EmptyWindow : public CWindowImpl<EmptyWindow,
-                                       CWindow,
-                                       CVTWTraits> {
- public:
-  DECLARE_FRAME_WND_CLASS(L"Chrome_ChromeViewsEmptyWindow", 0)
-
-  BEGIN_MSG_MAP_EX(EmptyWindow)
-    MSG_WM_PAINT(OnPaint)
-  END_MSG_MAP()
-
-  EmptyWindow::EmptyWindow(const CRect& bounds) : empty_paint_(false) {
-    Create(NULL, static_cast<RECT>(bounds));
-    ShowWindow(SW_SHOW);
-  }
-
-  EmptyWindow::~EmptyWindow() {
-    ShowWindow(SW_HIDE);
-    DestroyWindow();
-  }
-
-  void EmptyWindow::OnPaint(HDC dc) {
-    PAINTSTRUCT ps;
-    HDC paint_dc = BeginPaint(&ps);
-    if (!empty_paint_ && (ps.rcPaint.top - ps.rcPaint.bottom) == 0 &&
-        (ps.rcPaint.right - ps.rcPaint.left) == 0) {
-      empty_paint_ = true;
-    }
-    EndPaint(&ps);
-  }
-
-  bool empty_paint() {
-    return empty_paint_;
-  }
-
- private:
-  bool empty_paint_;
-
-  DISALLOW_COPY_AND_ASSIGN(EmptyWindow);
-};
-*/
-
 ////////////////////////////////////////////////////////////////////////////////
 //
 // A view subclass for testing purpose
 //
 ////////////////////////////////////////////////////////////////////////////////
 class TestView : public View {
  public:
   TestView() : View() {
   }
 
@@ skipping 128 matching lines @@
 void TestView::ViewHierarchyChanged(bool is_add, View *parent, View *child) {
   if (is_add) {
     child_added_ = true;
   } else {
     child_removed_ = true;
   }
   parent_ = parent;
   child_ = child;
 }
 
-}  // namespace
-
 TEST_F(ViewTest, AddRemoveNotifications) {
   TestView* v1 = new TestView();
   v1->SetBounds(0, 0, 300, 300);
 
   TestView* v2 = new TestView();
   v2->SetBounds(0, 0, 300, 300);
 
   TestView* v3 = new TestView();
   v3->SetBounds(0, 0, 300, 300);
 
@@ skipping 74 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(Widget::CreateWidget());
+  scoped_ptr<Widget> widget(new Widget);
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
   params.bounds = gfx::Rect(50, 50, 650, 650);
   widget->Init(params);
   RootView* root = widget->GetRootView();
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
   v1->Reset();
@@ skipping 219 matching lines @@
 }
 
 /* This test is disabled because it is flakey on some systems.
 TEST_F(ViewTest, DISABLED_Painting) {
   // Determine if InvalidateRect generates an empty paint rectangle.
   EmptyWindow paint_window(CRect(50, 50, 650, 650));
   paint_window.RedrawWindow(CRect(0, 0, 600, 600), NULL,
                             RDW_UPDATENOW | RDW_INVALIDATE | RDW_ALLCHILDREN);
   bool empty_paint = paint_window.empty_paint();
 
-  views::WidgetWin window;
+  WidgetWin window;
   window.set_delete_on_destroy(false);
   window.set_window_style(WS_OVERLAPPEDWINDOW);
   window.Init(NULL, gfx::Rect(50, 50, 650, 650), NULL);
   RootView* root = window.GetRootView();
 
   TestView* v1 = new TestView();
   v1->SetBounds(0, 0, 650, 650);
   root->AddChildView(v1);
 
   TestView* v2 = new TestView();
@@ skipping 40 matching lines @@
   CheckRect(v1->last_clip_, tmp_rect);
 
   // Make sure v4 was not painted
   tmp_rect.setEmpty();
   CheckRect(v4->last_clip_, tmp_rect);
 
   window.DestroyWindow();
 }
 */
 
+#if defined(OS_WIN)
 TEST_F(ViewTest, RemoveNotification) {
-  views::ViewStorage* vs = views::ViewStorage::GetInstance();
-  views::Widget* widget = Widget::CreateWidget();
-  views::RootView* root_view = widget->GetRootView();
+#elif defined(TOOLKIT_USES_GTK)
+// TODO(beng): stopped working with widget hierarchy split,
+//             http://crbug.com/82364
+TEST_F(ViewTest, DISABLED_RemoveNotification) {
+#endif
+  ViewStorage* vs = ViewStorage::GetInstance();
+  Widget* widget = new Widget;
+  widget->Init(Widget::InitParams(Widget::InitParams::TYPE_WINDOW));
+  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 40 matching lines @@
 
   // Now try removing a view with a hierarchy of depth 1.
   v11->RemoveChildView(v113);
   EXPECT_EQ(stored_views - 3, vs->view_count());
   EXPECT_EQ(NULL, vs->RetrieveView(s113));
   EXPECT_EQ(NULL, vs->RetrieveView(s1131));
   delete v113;  // We won't use this one anymore.
 
   // Now remove even more.
   root_view->RemoveChildView(v1);
-  EXPECT_EQ(stored_views - 8, vs->view_count());
   EXPECT_EQ(NULL, vs->RetrieveView(s1));
   EXPECT_EQ(NULL, vs->RetrieveView(s11));
   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 widget;
+  // Synchronously closing the window deletes the view hierarchy, which should
+  // remove all its views from ViewStorage.
+  widget->CloseNow();
   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));
 }
 
 namespace {
-class HitTestView : public views::View {
+class HitTestView : public View {
  public:
   explicit HitTestView(bool has_hittest_mask)
       : has_hittest_mask_(has_hittest_mask) {
   }
   virtual ~HitTestView() {}
 
  protected:
-  // Overridden from views::View:
+  // Overridden from View:
   virtual bool HasHitTestMask() const {
     return has_hittest_mask_;
   }
   virtual void GetHitTestMask(gfx::Path* mask) const {
     DCHECK(has_hittest_mask_);
     DCHECK(mask);
 
     SkScalar w = SkIntToScalar(width());
     SkScalar h = SkIntToScalar(height());
 
     // Create a triangular mask within the bounds of this View.
     mask->moveTo(w / 2, 0);
     mask->lineTo(w, h);
     mask->lineTo(0, h);
     mask->close();
   }
 
  private:
   bool has_hittest_mask_;
 
   DISALLOW_COPY_AND_ASSIGN(HitTestView);
 };
 
-gfx::Point ConvertPointToView(views::View* view, const gfx::Point& p) {
+gfx::Point ConvertPointToView(View* view, const gfx::Point& p) {
   gfx::Point tmp(p);
-  views::View::ConvertPointToView(view->GetRootView(), view, &tmp);
+  View::ConvertPointToView(view->GetRootView(), view, &tmp);
   return tmp;
 }
 }
 
 TEST_F(ViewTest, HitTestMasks) {
-  scoped_ptr<views::Widget> widget(Widget::CreateWidget());
-  views::RootView* root_view = widget->GetRootView();
+  Widget* widget = new Widget;
+  widget->Init(Widget::InitParams(Widget::InitParams::TYPE_WINDOW));
+  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);
   root_view->AddChildView(v2);
 
   gfx::Point v1_centerpoint = v1_bounds.CenterPoint();
   gfx::Point v2_centerpoint = v2_bounds.CenterPoint();
   gfx::Point v1_origin = v1_bounds.origin();
   gfx::Point v2_origin = v2_bounds.origin();
 
   // Test HitTest
   EXPECT_TRUE(v1->HitTest(ConvertPointToView(v1, v1_centerpoint)));
   EXPECT_TRUE(v2->HitTest(ConvertPointToView(v2, v2_centerpoint)));
 
   EXPECT_TRUE(v1->HitTest(ConvertPointToView(v1, v1_origin)));
   EXPECT_FALSE(v2->HitTest(ConvertPointToView(v2, v2_origin)));
 
   // Test GetEventHandlerForPoint
   EXPECT_EQ(v1, root_view->GetEventHandlerForPoint(v1_centerpoint));
   EXPECT_EQ(v2, root_view->GetEventHandlerForPoint(v2_centerpoint));
   EXPECT_EQ(v1, root_view->GetEventHandlerForPoint(v1_origin));
   EXPECT_EQ(root_view, root_view->GetEventHandlerForPoint(v2_origin));
+
+  widget->CloseNow();
 }
 
 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* widget = Widget::CreateWidget();
+  Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::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());
   EXPECT_EQ(kEmptyString, textfield->text());
 
   // Test selection related methods.
   textfield->SetText(kText);
   EXPECT_EQ(kEmptyString, textfield->GetSelectedText());
   textfield->SelectAll();
   EXPECT_EQ(kText, textfield->text());
   textfield->ClearSelection();
   EXPECT_EQ(kEmptyString, textfield->GetSelectedText());
+
+  widget->CloseNow();
 }
 
 #if defined(OS_WIN)
 
 // Tests that the Textfield view respond appropiately to cut/copy/paste.
 TEST_F(ViewTest, TextfieldCutCopyPaste) {
   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* widget = Widget::CreateWidget();
+  Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::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);
 
@@ skipping 79 matching lines @@
   EXPECT_EQ(kNormalText, std::wstring(buffer));
 
   // Copy from read_only so the string we are pasting is not the same as the
   // current one.
   read_only->SelectAll();
   ::SendMessage(read_only->GetTestingHandle(), WM_COPY, 0, 0);
   normal->SelectAll();
   ::SendMessage(normal->GetTestingHandle(), WM_PASTE, 0, 0);
   ::GetWindowText(normal->GetTestingHandle(), buffer, 1024);
   EXPECT_EQ(kReadOnlyText, std::wstring(buffer));
+  widget->CloseNow();
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accelerators
 ////////////////////////////////////////////////////////////////////////////////
 bool TestView::AcceleratorPressed(const Accelerator& accelerator) {
   accelerator_count_map_[accelerator]++;
   return true;
 }
 
 #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);
+  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.
-  scoped_ptr<Widget> widget(Widget::CreateWidget());
+  scoped_ptr<Widget> widget(new Widget);
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
   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());
+  FocusManager* focus_manager = 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);
+  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);
   EXPECT_EQ(view->accelerator_count_map_[escape_accelerator], 0);
 
   // Now register the escape key and hit it again.
   view->AddAccelerator(escape_accelerator);
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 1);
   EXPECT_EQ(view->accelerator_count_map_[escape_accelerator], 1);
 
@@ skipping 20 matching lines @@
   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();
 }
 #endif
 
 #if defined(OS_WIN)
 TEST_F(ViewTest, HiddenViewWithAccelerator) {
-  views::Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
+  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);
 
-  scoped_ptr<Widget> widget(Widget::CreateWidget());
+  scoped_ptr<Widget> widget(new Widget);
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
   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());
+  FocusManager* focus_manager = 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));
 
@@ skipping 71 matching lines @@
 // under the mouse.
 // TODO(jcampan): http://crbug.com/10572 Disabled as it fails on the Vista build
 //                bot.
 // Note that this fails for a variety of reasons:
 // - focused view is apparently reset across window activations and never
 //   properly restored
 // - this test depends on you not having any other window visible open under the
 //   area that it opens the test windows. --beng
 TEST_F(ViewTest, DISABLED_RerouteMouseWheelTest) {
   TestViewWithControls* view_with_controls = new TestViewWithControls();
-  views::Window* window1 =
-      views::Window::CreateChromeWindow(
-          NULL, gfx::Rect(0, 0, 100, 100),
-          new SimpleWindowDelegate(view_with_controls));
+  Window* window1 = Window::CreateChromeWindow(
+      NULL, gfx::Rect(0, 0, 100, 100),
+      new SimpleWindowDelegate(view_with_controls));
   window1->Show();
   ScrollView* scroll_view = new ScrollView();
   scroll_view->SetContents(new ScrollableTestView());
-  views::Window* window2 =
-      views::Window::CreateChromeWindow(NULL, gfx::Rect(200, 200, 100, 100),
-                                        new SimpleWindowDelegate(scroll_view));
+  Window* window2 = Window::CreateChromeWindow(
+      NULL, gfx::Rect(200, 200, 100, 100),
+      new SimpleWindowDelegate(scroll_view));
   window2->Show();
   EXPECT_EQ(0, scroll_view->GetVisibleRect().y());
 
   // Make the window1 active, as this is what it would be in real-world.
   window1->Activate();
 
   // Let's send a mouse-wheel message to the different controls and check that
   // it is rerouted to the window under the mouse (effectively scrolling the
   // scroll-view).
 
@@ skipping 14 matching lines @@
 
   // Then the text-field.
   ::SendMessage(view_with_controls->text_field_->GetTestingHandle(),
                 WM_MOUSEWHEEL, MAKEWPARAM(0, -20), MAKELPARAM(250, 250));
   EXPECT_EQ(80, scroll_view->GetVisibleRect().y());
 
   // Ensure we don't scroll when the mouse is not over that window.
   ::SendMessage(view_with_controls->text_field_->GetTestingHandle(),
                 WM_MOUSEWHEEL, MAKEWPARAM(0, -20), MAKELPARAM(50, 50));
   EXPECT_EQ(80, scroll_view->GetVisibleRect().y());
+
+  window1->CloseNow();
+  window2->CloseNow();
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Dialogs' default button
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace ui {
-class MockMenuModel : public MenuModel {
+class MockMenuModel : public ui::MenuModel {
  public:
   MOCK_CONST_METHOD0(HasIcons, bool());
   MOCK_CONST_METHOD1(GetFirstItemIndex, int(gfx::NativeMenu native_menu));
   MOCK_CONST_METHOD0(GetItemCount, int());
   MOCK_CONST_METHOD1(GetTypeAt, ItemType(int index));
   MOCK_CONST_METHOD1(GetCommandIdAt, int(int index));
   MOCK_CONST_METHOD1(GetLabelAt, string16(int index));
   MOCK_CONST_METHOD1(IsItemDynamicAt, bool(int index));
   MOCK_CONST_METHOD1(GetLabelFontAt, const gfx::Font* (int index));
   MOCK_CONST_METHOD2(GetAcceleratorAt, bool(int index,
       ui::Accelerator* accelerator));
   MOCK_CONST_METHOD1(IsItemCheckedAt, bool(int index));
   MOCK_CONST_METHOD1(GetGroupIdAt, int(int index));
   MOCK_METHOD2(GetIconAt, bool(int index, SkBitmap* icon));
-  MOCK_CONST_METHOD1(GetButtonMenuItemAt, ButtonMenuItemModel*(int index));
+  MOCK_CONST_METHOD1(GetButtonMenuItemAt, ui::ButtonMenuItemModel*(int index));
   MOCK_CONST_METHOD1(IsEnabledAt, bool(int index));
   MOCK_CONST_METHOD1(IsVisibleAt, bool(int index));
   MOCK_CONST_METHOD1(GetSubmenuModelAt, MenuModel*(int index));
   MOCK_METHOD1(HighlightChangedTo, void(int index));
   MOCK_METHOD1(ActivatedAt, void(int index));
   MOCK_METHOD2(ActivatedAtWithDisposition, void(int index,
       int disposition));
   MOCK_METHOD0(MenuWillShow, void());
   MOCK_METHOD0(MenuClosed, void());
-  MOCK_METHOD1(SetMenuModelDelegate, void(MenuModelDelegate* delegate));
+  MOCK_METHOD1(SetMenuModelDelegate, void(ui::MenuModelDelegate* delegate));
   MOCK_METHOD3(GetModelAndIndexForCommandId, bool(int command_id,
       MenuModel** model, int* index));
 };
-}
 
 class TestDialog : public DialogDelegate, public ButtonListener {
  public:
-  explicit TestDialog(ui::MockMenuModel* mock_menu_model)
+  explicit TestDialog(MockMenuModel* mock_menu_model)
       : contents_(NULL),
         button1_(NULL),
         button2_(NULL),
         checkbox_(NULL),
         button_drop_(NULL),
         last_pressed_button_(NULL),
         mock_menu_model_(mock_menu_model),
         canceled_(false),
         oked_(false) {
   }
 
-  // views::DialogDelegate implementation:
+  // DialogDelegate implementation:
   virtual int GetDefaultDialogButton() const {
     return MessageBoxFlags::DIALOGBUTTON_OK;
   }
 
   virtual View* GetContentsView() {
     if (!contents_) {
       contents_ = new View();
       button1_ = new NativeButtonBase(this, L"Button1");
       button2_ = new NativeButtonBase(this, L"Button2");
       checkbox_ = new Checkbox(L"My checkbox");
@@ skipping 10 matching lines @@
   // buttons to our heart's content).
   virtual bool Cancel() {
     canceled_ = true;
     return false;
   }
   virtual bool Accept() {
     oked_ = true;
     return false;
   }
 
-  // views::ButtonListener implementation.
-  virtual void ButtonPressed(Button* sender, const views::Event& event) {
+  // ButtonListener implementation.
+  virtual void ButtonPressed(Button* sender, const Event& event) {
     last_pressed_button_ = sender;
   }
 
   void ResetStates() {
     oked_ = false;
     canceled_ = false;
     last_pressed_button_ = NULL;
   }
 
   // Set up expectations for methods that are called when an (empty) menu is
   // shown from a drop down button.
   void ExpectShowDropMenu() {
     if (mock_menu_model_) {
       EXPECT_CALL(*mock_menu_model_, HasIcons());
       EXPECT_CALL(*mock_menu_model_, GetFirstItemIndex(_));
       EXPECT_CALL(*mock_menu_model_, GetItemCount());
       EXPECT_CALL(*mock_menu_model_, MenuClosed());
     }
   }
 
   View* contents_;
   NativeButtonBase* button1_;
   NativeButtonBase* button2_;
   NativeButtonBase* checkbox_;
   ButtonDropDown* button_drop_;
   Button* last_pressed_button_;
-  ui::MockMenuModel* mock_menu_model_;
+  MockMenuModel* mock_menu_model_;
 
   bool canceled_;
   bool oked_;
 };
 
 class DefaultButtonTest : public ViewTest {
  public:
   enum ButtonID {
     OK,
     CANCEL,
     BUTTON1,
     BUTTON2
   };
 
   DefaultButtonTest()
       : focus_manager_(NULL),
         test_dialog_(NULL),
         client_view_(NULL),
         ok_button_(NULL),
         cancel_button_(NULL) {
   }
 
   virtual void SetUp() {
     test_dialog_ = new TestDialog(NULL);
-    views::Window* window =
-        views::Window::CreateChromeWindow(NULL, gfx::Rect(0, 0, 100, 100),
-                                          test_dialog_);
+    Window* window = Window::CreateChromeWindow(NULL, gfx::Rect(0, 0, 100, 100),
+                                                test_dialog_);
     window->Show();
     focus_manager_ = test_dialog_->contents_->GetFocusManager();
     ASSERT_TRUE(focus_manager_ != NULL);
     client_view_ =
-        static_cast<views::DialogClientView*>(window->client_view());
+        static_cast<DialogClientView*>(window->client_view());
     ok_button_ = client_view_->ok_button();
     cancel_button_ = client_view_->cancel_button();
   }
 
   void SimulatePressingEnterAndCheckDefaultButton(ButtonID button_id) {
     KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0);
     focus_manager_->OnKeyEvent(event);
     switch (button_id) {
       case OK:
         EXPECT_TRUE(test_dialog_->oked_);
@@ skipping 14 matching lines @@
       case BUTTON2:
         EXPECT_FALSE(test_dialog_->oked_);
         EXPECT_FALSE(test_dialog_->canceled_);
         EXPECT_TRUE(test_dialog_->last_pressed_button_ ==
             test_dialog_->button2_);
         break;
     }
     test_dialog_->ResetStates();
   }
 
-  views::FocusManager* focus_manager_;
+  FocusManager* focus_manager_;
   TestDialog* test_dialog_;
   DialogClientView* client_view_;
-  views::NativeButton* ok_button_;
-  views::NativeButton* cancel_button_;
+  NativeButton* ok_button_;
+  NativeButton* cancel_button_;
 };
 
 TEST_F(DefaultButtonTest, DialogDefaultButtonTest) {
   // Window has just been shown, we expect the default button specified in the
   // DialogDelegate.
   EXPECT_TRUE(ok_button_->is_default());
 
   // Simulate pressing enter, that should trigger the OK button.
   SimulatePressingEnterAndCheckDefaultButton(OK);
 
@@ skipping 38 matching lines @@
 
 class ButtonDropDownTest : public ViewTest {
  public:
   ButtonDropDownTest()
       : test_dialog_(NULL),
         button_as_view_(NULL) {
   }
 
   virtual void SetUp() {
     test_dialog_ = new TestDialog(&mock_menu_model_);
-    views::Window* window =
-        views::Window::CreateChromeWindow(NULL, gfx::Rect(0, 0, 100, 100),
-                                          test_dialog_);
+    Window* window = Window::CreateChromeWindow(NULL, gfx::Rect(0, 0, 100, 100),
+                                                test_dialog_);
     window->Show();
     test_dialog_->button_drop_->SetBounds(0, 0, 100, 100);
     // We have to cast the button back into a View in order to invoke it's
     // OnMouseReleased method.
     button_as_view_ = static_cast<View*>(test_dialog_->button_drop_);
   }
 
   TestDialog* test_dialog_;
-  ui::MockMenuModel mock_menu_model_;
+  MockMenuModel mock_menu_model_;
   // This is owned by test_dialog_.
   View* button_as_view_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ButtonDropDownTest);
 };
 
 // Ensure that regular clicks on the drop down button still work. (i.e. - the
 // click events are processed and the listener gets the click)
 TEST_F(ButtonDropDownTest, RegularClickTest) {
@@ skipping 24 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // View hierarchy / Visibility changes
 ////////////////////////////////////////////////////////////////////////////////
 /*
 TEST_F(ViewTest, ChangeVisibility) {
 #if defined(OS_LINUX)
   // Make CRITICAL messages fatal
   // TODO(oshima): we probably should enable this for entire tests on linux.
   g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
 #endif
-  scoped_ptr<views::Widget> window(CreateWidget());
+  scoped_ptr<Widget> window(CreateWidget());
   window->Init(NULL, gfx::Rect(0, 0, 500, 300));
-  views::RootView* root_view = window->GetRootView();
+  RootView* root_view = window->GetRootView();
   NativeButtonBase* native = new NativeButtonBase(NULL, L"Native");
 
   root_view->SetContentsView(native);
   native->SetVisible(true);
 
   root_view->RemoveChildView(native);
   native->SetVisible(false);
   // Change visibility to true with no widget.
   native->SetVisible(true);
 
   root_view->SetContentsView(native);
   native->SetVisible(true);
 }
 */
 
 ////////////////////////////////////////////////////////////////////////////////
 // Native view hierachy
 ////////////////////////////////////////////////////////////////////////////////
-class TestNativeViewHierarchy : public views::View {
+class TestNativeViewHierarchy : public View {
  public:
   TestNativeViewHierarchy() {
   }
 
   virtual void NativeViewHierarchyChanged(bool attached,
                                           gfx::NativeView native_view,
                                           RootView* root_view) {
     NotificationInfo info;
     info.attached = attached;
     info.native_view = native_view;
     info.root_view = root_view;
     notifications_.push_back(info);
   };
   struct NotificationInfo {
     bool attached;
     gfx::NativeView native_view;
     RootView* root_view;
   };
   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_ = Widget::CreateWidget();
+    native_host_ = new NativeViewHost();
+    host_ = new Widget;
     Widget::InitParams params(Widget::InitParams::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] = Widget::CreateWidget();
+      windows_[i] = new Widget;
       Widget::InitParams params(Widget::InitParams::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();
     }
     host_->Close();
     // Will close and self-delete widgets - no need to manually delete them.
     view_test_->RunPendingMessages();
   }
 
   void CheckEnumeratingNativeWidgets() {
-    if (!host_->GetWindow())
+    if (!host_->GetContainingWindow())
       return;
     NativeWidget::NativeWidgets widgets;
     NativeWidget::GetAllNativeWidgets(host_->GetNativeView(), &widgets);
     EXPECT_EQ(TestNativeViewHierarchy::kTotalViews + 1, widgets.size());
     // Unfortunately there is no guarantee the sequence of views here so always
     // go through all of them.
     for (NativeWidget::NativeWidgets::iterator i = widgets.begin();
          i != widgets.end(); ++i) {
       RootView* root_view = (*i)->GetWidget()->GetRootView();
       if (host_->GetRootView() == root_view)
@@ skipping 25 matching lines @@
       EXPECT_EQ(host_->GetNativeView(),
           test_views_[i]->notifications_[0].native_view);
       EXPECT_EQ(root_views_[i], test_views_[i]->notifications_[0].root_view);
       EXPECT_TRUE(test_views_[i]->notifications_[1].attached);
       EXPECT_EQ(host_->GetNativeView(),
           test_views_[i]->notifications_[1].native_view);
       EXPECT_EQ(root_views_[i], test_views_[i]->notifications_[1].root_view);
     }
   }
 
-  views::NativeViewHost* native_host_;
-  views::Widget* host_;
-  views::Widget* windows_[TestNativeViewHierarchy::kTotalViews];
-  views::RootView* root_views_[TestNativeViewHierarchy::kTotalViews];
+  NativeViewHost* native_host_;
+  Widget* host_;
+  Widget* windows_[TestNativeViewHierarchy::kTotalViews];
+  RootView* root_views_[TestNativeViewHierarchy::kTotalViews];
   TestNativeViewHierarchy* test_views_[TestNativeViewHierarchy::kTotalViews];
   ViewTest* view_test_;
 };
 
 TEST_F(ViewTest, ChangeNativeViewHierarchyFindRoots) {
   // TODO(georgey): Fix the test for Linux
 #if defined(OS_WIN)
   TestChangeNativeViewHierarchy test(this);
   test.CheckEnumeratingNativeWidgets();
 #endif
@@ skipping 34 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 = Widget::CreateWidget();
+  Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::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|.
@@ skipping 16 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 = Widget::CreateWidget();
+  Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::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|.
 
@@ skipping 129 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(Widget::CreateWidget());
+  scoped_ptr<Widget> widget(new Widget);
   Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
   params.delete_on_destroy = false;
   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);
@@ skipping 45 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);
 }
+
+}  // namespace views