Re-land:

views/focus/focus_manager_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/logging.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 112 matching lines @@
 
   virtual void SetUp() {
     window_ = Window::CreateChromeWindow(NULL, bounds(), this);
     InitContentView();
     window_->Show();
   }
 
   virtual void TearDown() {
     if (focus_change_listener_)
       GetFocusManager()->RemoveFocusChangeListener(focus_change_listener_);
-    window_->CloseWindow();
+    window_->Close();
 
     // Flush the message loop to make Purify happy.
     message_loop()->RunAllPending();
   }
 
   FocusManager* GetFocusManager() {
-#if defined(OS_WIN)
-    return static_cast<WindowWin*>(window_)->GetFocusManager();
-#elif defined(OS_LINUX)
-    return static_cast<WindowGtk*>(window_)->GetFocusManager();
-#else
-    NOTIMPLEMENTED();
-#endif
+    return window_->GetFocusManager();
   }
 
   void FocusNativeView(gfx::NativeView native_view) {
 #if defined(OS_WIN)
   ::SendMessage(native_view, WM_SETFOCUS, NULL, NULL);
 #else
     gint return_val;
     GdkEventFocus event;
     event.type = GDK_FOCUS_CHANGE;
     event.window =
@@ skipping 126 matching lines @@
 
   virtual FocusTraversable* GetFocusTraversable() {
     return widget_->GetRootView();
   }
 
   virtual void ViewHierarchyChanged(bool is_add, View *parent, View *child) {
     NativeViewHost::ViewHierarchyChanged(is_add, parent, child);
 
     if (child == this && is_add) {
       if (!widget_) {
-        widget_ = Widget::CreateWidget();
+        widget_ = new Widget;
         Widget::InitParams params(Widget::InitParams::TYPE_CONTROL);
 #if defined(OS_WIN)
         params.parent = parent->GetRootView()->GetWidget()->GetNativeView();
 #elif defined(TOOLKIT_USES_GTK)
         params.parent = native_view();
 #endif
         widget_->Init(params);
         widget_->SetFocusTraversableParentView(this);
         widget_->SetContentsView(child_);
       }
@@ skipping 1291 matching lines @@
   ATOM atom = RegisterClassEx(&class_ex);
   ASSERT_TRUE(atom);
 
   // Create a native dialog window.
   HWND hwnd = CreateWindowEx(0, class_ex.lpszClassName, NULL,
                              WS_OVERLAPPEDWINDOW, 0, 0, 200, 200,
                              NULL, NULL, NULL, NULL);
   ASSERT_TRUE(hwnd);
 
   // Create a view window parented to native dialog.
-  scoped_ptr<Widget> widget1(Widget::CreateWidget());
+  scoped_ptr<Widget> widget1(new Widget);
   Widget::InitParams params(Widget::InitParams::TYPE_CONTROL);
   params.delete_on_destroy = false;
   params.parent = hwnd;
   params.bounds = gfx::Rect(0, 0, 100, 100);
   widget1->Init(params);
 
   // Get the focus manager directly from the first window.  Should exist
   // because the first window is the root widget.
   views::FocusManager* focus_manager_member1 = widget1->GetFocusManager();
   EXPECT_TRUE(focus_manager_member1);
 
   // Create another view window parented to the first view window.
-  scoped_ptr<Widget> widget2(Widget::CreateWidget());
+  scoped_ptr<Widget> widget2(new Widget);
   params.parent = widget1->GetNativeView();
   widget2->Init(params);
 
   // Get the focus manager directly from the second window. Should return the
   // first window's focus manager.
   views::FocusManager* focus_manager_member2 = widget2->GetFocusManager();
   EXPECT_EQ(focus_manager_member2, focus_manager_member1);
 
   // Get the focus manager indirectly using the first window handle. Should
   // return the first window's focus manager.
   views::FocusManager* focus_manager_indirect =
       views::FocusManager::GetFocusManagerForNativeView(
           widget1->GetNativeView());
   EXPECT_EQ(focus_manager_indirect, focus_manager_member1);
 
   // Get the focus manager indirectly using the second window handle. Should
   // return the first window's focus manager.
   focus_manager_indirect =
       views::FocusManager::GetFocusManagerForNativeView(
           widget2->GetNativeView());
   EXPECT_EQ(focus_manager_indirect, focus_manager_member1);
 
   DestroyWindow(hwnd);
 }
 #endif
 
-#if defined(OS_CHROMEOS)
 class FocusManagerDtorTest : public FocusManagerTest {
  protected:
   typedef std::vector<std::string> DtorTrackVector;
 
   class FocusManagerDtorTracked : public FocusManager {
    public:
     FocusManagerDtorTracked(Widget* widget, DtorTrackVector* dtor_tracker)
       : FocusManager(widget),
         dtor_tracker_(dtor_tracker) {
     }
@@ skipping 12 matching lines @@
         : NativeButton(NULL, text),
           dtor_tracker_(dtor_tracker) {
     };
     virtual ~NativeButtonDtorTracked() {
       dtor_tracker_->push_back("NativeButtonDtorTracked");
     }
 
     DtorTrackVector* dtor_tracker_;
   };
 
-  class WindowGtkDtorTracked : public WindowGtk {
+  class WindowDtorTracked : public Window {
    public:
-    WindowGtkDtorTracked(WindowDelegate* window_delegate,
-                         DtorTrackVector* dtor_tracker)
+    WindowDtorTracked(WindowDelegate* window_delegate,
+                      DtorTrackVector* dtor_tracker)
         : dtor_tracker_(dtor_tracker) {
-      tracked_focus_manager_ = new FocusManagerDtorTracked(this,
-          dtor_tracker_);
+      tracked_focus_manager_ = new FocusManagerDtorTracked(this, dtor_tracker_);
       Window::InitParams params(window_delegate);
       params.widget_init_params.bounds = gfx::Rect(0, 0, 100, 100);
-      GetWindow()->InitWindow(params);
+      InitWindow(params);
       ReplaceFocusManager(tracked_focus_manager_);
     }
 
-    virtual ~WindowGtkDtorTracked() {
+    virtual ~WindowDtorTracked() {
       dtor_tracker_->push_back("WindowGtkDtorTracked");
     }
 
     FocusManagerDtorTracked* tracked_focus_manager_;
     DtorTrackVector* dtor_tracker_;
   };
 
  public:
   virtual void SetUp() {
-   // Create WindowGtkDtorTracked that uses FocusManagerDtorTracked.
-   window_ = new WindowGtkDtorTracked(this, &dtor_tracker_);
-   ASSERT_TRUE(GetFocusManager() ==
-        static_cast<WindowGtkDtorTracked*>(window_)->tracked_focus_manager_);
-
-   window_->Show();
+    // Create WindowGtkDtorTracked that uses FocusManagerDtorTracked.
+    window_ = new WindowDtorTracked(this, &dtor_tracker_);
+    ASSERT_TRUE(GetFocusManager() == static_cast<WindowDtorTracked*>(
+        window_)->tracked_focus_manager_);
+    window_->Show();
   }
 
   virtual void TearDown() {
     if (window_) {
-      window_->CloseWindow();
+      window_->Close();
       message_loop()->RunAllPending();
     }
   }
 
   DtorTrackVector dtor_tracker_;
 };
 
 TEST_F(FocusManagerDtorTest, FocusManagerDestructedLast) {
   // Setup views hierarchy.
   TabbedPane* tabbed_pane = new TabbedPane();
   content_view_->AddChildView(tabbed_pane);
 
   NativeButtonDtorTracked* button = new NativeButtonDtorTracked(L"button",
                                                                 &dtor_tracker_);
   tabbed_pane->AddTab(L"Awesome tab", button);
 
   // Close the window.
-  window_->CloseWindow();
+  window_->Close();
   message_loop()->RunAllPending();
 
   // Test window, button and focus manager should all be destructed.
   ASSERT_EQ(3, static_cast<int>(dtor_tracker_.size()));
 
   // Focus manager should be the last one to destruct.
   ASSERT_STREQ("FocusManagerDtorTracked", dtor_tracker_[2].c_str());
 
   // Clear window_ so that we don't try to close it again.
   window_ = NULL;
 }
 
-#endif  // defined(OS_CHROMEOS)
 
 }  // namespace views