Revert :

Changed by: jcampan@chromium.org
Changed at: Fri 19 Jun 2009 21:22:47
Branch: src
Revision: 18889
Comments:
Relanding focus manager refactoring with build fix, see:http://codereview.chromium.org/125148BUG=NoneTEST=NoneTBR=ben
Review URL: http://codereview.chromium.org/141013

Because it creates hundreds of new reliability crashes.

TBR:jcampan

Review URL: http://codereview.chromium.org/140064

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@18904 0039d316-1c4b-4281-b951-d872f2087c98

22 files changed, 353 insertions, 169 deletions

diff --git a/views/controls/menu/chrome_menu.cc b/views/controls/menu/chrome_menu.cc
index f6e3950..b05552f 100644
--- a/views/controls/menu/chrome_menu.cc
+++ b/views/controls/menu/chrome_menu.cc
@@ -685,7 +685,7 @@ class MenuHost : public WidgetWin {
             const gfx::Rect& bounds,
             View* contents_view,
             bool do_capture) {
-    WidgetWin::Init(parent, bounds);
+    WidgetWin::Init(parent, bounds, true);
     SetContentsView(contents_view);
     // We don't want to take focus away from the hosting window.
     ShowWindow(SW_SHOWNA);
diff --git a/views/controls/native_control.cc b/views/controls/native_control.cc
index 5fd8349..2df961e 100644
--- a/views/controls/native_control.cc
+++ b/views/controls/native_control.cc
@@ -367,7 +367,8 @@ LRESULT CALLBACK NativeControl::NativeControlWndProc(HWND window, UINT message,
       return 0;
   } else if (message == WM_SETFOCUS) {
     // Let the focus manager know that the focus changed.
-    FocusManager* focus_manager = native_control->GetFocusManager();
+    FocusManager* focus_manager =
+        FocusManager::GetFocusManager(native_control->GetNativeControlHWND());
     if (focus_manager) {
       focus_manager->SetFocusedView(native_control);
     } else {
diff --git a/views/controls/native_control_win.cc b/views/controls/native_control_win.cc
index 32c7261..b6111fd 100644
--- a/views/controls/native_control_win.cc
+++ b/views/controls/native_control_win.cc
@@ -196,7 +196,8 @@ LRESULT NativeControlWin::NativeControlWndProc(HWND window,
       return 0;
   } else if (message == WM_SETFOCUS) {
     // Let the focus manager know that the focus changed.
-    FocusManager* focus_manager = native_control->GetFocusManager();
+    FocusManager* focus_manager =
+        FocusManager::GetFocusManager(native_control->native_view());
     if (focus_manager) {
       focus_manager->SetFocusedView(native_control->focus_view());
     } else {
diff --git a/views/controls/tabbed_pane.cc b/views/controls/tabbed_pane.cc
index b7c41bc..a162131 100644
--- a/views/controls/tabbed_pane.cc
+++ b/views/controls/tabbed_pane.cc
@@ -172,7 +172,7 @@ HWND TabbedPane::CreateNativeControl(HWND parent_container) {
 
   // Create the view container which is a child of the TabControl.
   content_window_ = new WidgetWin();
-  content_window_->Init(tab_control_, gfx::Rect());
+  content_window_->Init(tab_control_, gfx::Rect(), false);
 
   // Explicitly setting the WS_EX_LAYOUTRTL property for the HWND (see above
   // for a thorough explanation regarding why we waited until |content_window_|
diff --git a/views/controls/textfield/native_textfield_win.cc b/views/controls/textfield/native_textfield_win.cc
index cda6629..1ccf651 100644
--- a/views/controls/textfield/native_textfield_win.cc
+++ b/views/controls/textfield/native_textfield_win.cc
@@ -681,7 +681,8 @@ void NativeTextfieldWin::OnPaste() {
 void NativeTextfieldWin::OnSetFocus(HWND hwnd) {
   SetMsgHandled(FALSE);  // We still want the default processing of the message.
 
-  views::FocusManager* focus_manager = textfield_->GetFocusManager();
+  views::FocusManager* focus_manager =
+      views::FocusManager::GetFocusManager(m_hWnd);
   if (!focus_manager) {
     NOTREACHED();
     return;
diff --git a/views/controls/tree/tree_view.cc b/views/controls/tree/tree_view.cc
index 5a2fb42..95a7210 100755
--- a/views/controls/tree/tree_view.cc
+++ b/views/controls/tree/tree_view.cc
@@ -471,11 +471,13 @@ bool TreeView::OnKeyDown(int virtual_key_code) {
   } else if (virtual_key_code == VK_RETURN && !process_enter_) {
     Widget* widget = GetWidget();
     DCHECK(widget);
+    FocusManager* fm = FocusManager::GetFocusManager(widget->GetNativeView());
+    DCHECK(fm);
     Accelerator accelerator(Accelerator(static_cast<int>(virtual_key_code),
                                         win_util::IsShiftPressed(),
                                         win_util::IsCtrlPressed(),
                                         win_util::IsAltPressed()));
-    GetFocusManager()->ProcessAccelerator(accelerator);
+    fm->ProcessAccelerator(accelerator);
     return true;
   }
   return false;
diff --git a/views/focus/external_focus_tracker.cc b/views/focus/external_focus_tracker.cc
index b08d287..8f8bfdf 100644
--- a/views/focus/external_focus_tracker.cc
+++ b/views/focus/external_focus_tracker.cc
@@ -4,7 +4,6 @@
 
 #include "views/focus/external_focus_tracker.h"
 
-#include "base/logging.h"
 #include "views/view.h"
 #include "views/focus/view_storage.h"
 
@@ -14,8 +13,6 @@ ExternalFocusTracker::ExternalFocusTracker(View* parent_view,
                                            FocusManager* focus_manager)
     : focus_manager_(focus_manager),
       parent_view_(parent_view) {
-  DCHECK(focus_manager);
-  DCHECK(parent_view);
   view_storage_ = ViewStorage::GetSharedInstance();
   last_focused_view_storage_id_ = view_storage_->CreateStorageID();
   // Store the view which is focused when we're created.
diff --git a/views/focus/focus_manager.cc b/views/focus/focus_manager.cc
index dc26649..f4b67ff 100644
--- a/views/focus/focus_manager.cc
+++ b/views/focus/focus_manager.cc
@@ -12,6 +12,7 @@
 #include <gtk/gtk.h>
 #endif
 
+#include "base/histogram.h"
 #include "base/logging.h"
 #include "views/accelerator.h"
 #include "views/focus/view_storage.h"
@@ -23,17 +24,158 @@
 #include "base/win_util.h"
 #endif
 
+// The following keys are used in SetProp/GetProp to associate additional
+// information needed for focus tracking with a window.
+
+// Maps to the FocusManager instance for a top level window. See
+// CreateFocusManager/DestoryFocusManager for usage.
+static const wchar_t* const kFocusManagerKey = L"__VIEW_CONTAINER__";
+
+// Maps to the View associated with a window.
+// We register views with window so we can:
+// - keep in sync the native focus with the view focus (when the native
+//   component gets the focus, we get the WM_SETFOCUS event and we can focus the
+//   associated view).
+// - prevent tab key events from being sent to views.
+static const wchar_t* const kViewKey = L"__CHROME_VIEW__";
+
+// A property set to 1 to indicate whether the focus manager has subclassed that
+// window.  We are doing this to ensure we are not subclassing several times.
+// Subclassing twice is not a problem if no one is subclassing the HWND between
+// the 2 subclassings (the 2nd subclassing is ignored since the WinProc is the
+// same as the current one).  However if some other app goes and subclasses the
+// HWND between the 2 subclassings, we will end up subclassing twice.
+// This flag lets us test that whether we have or not subclassed yet.
+static const wchar_t* const kFocusSubclassInstalled =
+    L"__FOCUS_SUBCLASS_INSTALLED__";
+
 namespace views {
 
+#if defined(OS_WIN)
+// Callback installed via InstallFocusSubclass.
+static LRESULT CALLBACK FocusWindowCallback(HWND window, UINT message,
+                                            WPARAM wParam, LPARAM lParam) {
+  if (!::IsWindow(window)) {
+    // QEMU has reported crashes when calling GetProp (this seems to happen for
+    // some weird messages, not sure what they are).
+    // Here we are just trying to avoid the crasher.
+    NOTREACHED();
+    return 0;
+  }
+
+  WNDPROC original_handler = win_util::GetSuperclassWNDPROC(window);
+  DCHECK(original_handler);
+  FocusManager* focus_manager = FocusManager::GetFocusManager(window);
+  // There are cases when we have no FocusManager for the window. This happens
+  // because we subclass certain windows (such as the TabContents window)
+  // but that window may not have an associated FocusManager.
+  if (focus_manager) {
+    switch (message) {
+      case WM_NCDESTROY:
+        if (!focus_manager->OnNCDestroy(window))
+          return 0;
+        break;
+      default:
+        break;
+    }
+  }
+  return CallWindowProc(original_handler, window, message, wParam, lParam);
+}
+
+#endif
+
 // FocusManager -----------------------------------------------------
 
-FocusManager::FocusManager(Widget* widget)
-    : widget_(widget),
-      focused_view_(NULL) {
-  DCHECK(widget_);
+#if defined(OS_WIN)
+// static
+FocusManager* FocusManager::CreateFocusManager(HWND window,
+                                               RootView* root_view) {
+  DCHECK(window);
+  DCHECK(root_view);
+  InstallFocusSubclass(window, NULL);
+  FocusManager* focus_manager = new FocusManager(window, root_view);
+  SetProp(window, kFocusManagerKey, focus_manager);
+
+  return focus_manager;
+}
+
+// static
+void FocusManager::InstallFocusSubclass(HWND window, View* view) {
+  DCHECK(window);
+
+  bool already_subclassed =
+      reinterpret_cast<bool>(GetProp(window,
+                                     kFocusSubclassInstalled));
+  if (already_subclassed &&
+      !win_util::IsSubclassed(window, &FocusWindowCallback)) {
+    NOTREACHED() << "window sub-classed by someone other than the FocusManager";
+    // Track in UMA so we know if this case happens.
+    UMA_HISTOGRAM_COUNTS("FocusManager.MultipleSubclass", 1);
+  } else {
+    win_util::Subclass(window, &FocusWindowCallback);
+    SetProp(window, kFocusSubclassInstalled, reinterpret_cast<HANDLE>(true));
+  }
+  if (view)
+    SetProp(window, kViewKey, view);
+}
+
+void FocusManager::UninstallFocusSubclass(HWND window) {
+  DCHECK(window);
+  if (win_util::Unsubclass(window, &FocusWindowCallback)) {
+    RemoveProp(window, kViewKey);
+    RemoveProp(window, kFocusSubclassInstalled);
+  }
+}
+
+#endif
+
+// static
+FocusManager* FocusManager::GetFocusManager(gfx::NativeView window) {
+#if defined(OS_WIN)
+  DCHECK(window);
+
+  // In case parent windows belong to a different process, yet
+  // have the kFocusManagerKey property set, we have to be careful
+  // to also check the process id of the window we're checking.
+  DWORD window_pid = 0, current_pid = GetCurrentProcessId();
+  FocusManager* focus_manager;
+  for (focus_manager = NULL; focus_manager == NULL && IsWindow(window);
+       window = GetParent(window)) {
+    GetWindowThreadProcessId(window, &window_pid);
+    if (current_pid != window_pid)
+      break;
+    focus_manager = reinterpret_cast<FocusManager*>(
+        GetProp(window, kFocusManagerKey));
+  }
+  return focus_manager;
+#else
+  NOTIMPLEMENTED();
+  return NULL;
+#endif
+}
+
+#if defined(OS_WIN)
+// static
+View* FocusManager::GetViewForWindow(gfx::NativeView window, bool look_in_parents) {
+  DCHECK(window);
+  do {
+    View* v = reinterpret_cast<View*>(GetProp(window, kViewKey));
+    if (v)
+      return v;
+  } while (look_in_parents && (window = ::GetParent(window)));
+  return NULL;
+}
+
+FocusManager::FocusManager(HWND root, RootView* root_view)
+    : root_(root),
+      top_root_view_(root_view),
+      focused_view_(NULL),
+      ignore_set_focus_msg_(false) {
   stored_focused_view_storage_id_ =
       ViewStorage::GetSharedInstance()->CreateStorageID();
+  DCHECK(root_);
 }
+#endif
 
 FocusManager::~FocusManager() {
   // If there are still registered FocusChange listeners, chances are they were
@@ -43,12 +185,29 @@ FocusManager::~FocusManager() {
 
 #if defined(OS_WIN)
 // Message handlers.
+bool FocusManager::OnNCDestroy(HWND window) {
+  // Window is being destroyed, undo the subclassing.
+  FocusManager::UninstallFocusSubclass(window);
+
+  if (window == root_) {
+    // We are the top window.
+
+    DCHECK(GetProp(window, kFocusManagerKey));
+
+    // Make sure this is called on the window that was set with the
+    // FocusManager.
+    RemoveProp(window, kFocusManagerKey);
+
+    delete this;
+  }
+  return true;
+}
+
 bool FocusManager::OnKeyDown(HWND window, UINT message, WPARAM wparam,
                              LPARAM lparam) {
   DCHECK((message == WM_KEYDOWN) || (message == WM_SYSKEYDOWN));
-  HWND hwnd = widget_->GetNativeView();
 
-  if (!IsWindowVisible(hwnd)) {
+  if (!IsWindowVisible(root_)) {
     // We got a message for a hidden window. Because WidgetWin::Close hides the
     // window, then destroys it, it it possible to get a message after we've
     // hidden the window. If we allow the message to be dispatched chances are
@@ -86,10 +245,9 @@ bool FocusManager::OnKeyDown(HWND window, UINT message, WPARAM wparam,
   // Note that we don't do focus traversal if the root window is not part of the
   // active window hierarchy as this would mean we have no focused view and
   // would focus the first focusable view.
-  HWND top_window = widget_->GetNativeView();
   HWND active_window = ::GetActiveWindow();
-  if ((active_window == top_window || ::IsChild(active_window, top_window)) &&
-       IsTabTraversalKeyEvent(key_event)) {
+  if ((active_window == root_ || ::IsChild(active_window, root_)) &&
+      IsTabTraversalKeyEvent(key_event)) {
     AdvanceFocus(win_util::IsShiftPressed());
     return false;
   }
@@ -166,10 +324,9 @@ bool FocusManager::ContainsView(View* view) {
   if (!widget)
     return false;
 
-  gfx::NativeView top_window = widget_->GetNativeView();
   gfx::NativeView window = widget->GetNativeView();
   while (window) {
-    if (window == top_window)
+    if (window == root_)
       return true;
 #if defined(OS_WIN)
     window = ::GetParent(window);
@@ -220,7 +377,7 @@ View* FocusManager::GetNextFocusableView(View* original_starting_view,
       starting_view = original_starting_view;
     }
   } else {
-    focus_traversable = widget_->GetRootView();
+    focus_traversable = top_root_view_;
   }
 
   // Traverse the FocusTraversable tree down to find the focusable view.
@@ -300,9 +457,30 @@ void FocusManager::SetFocusedView(View* view) {
 
 void FocusManager::ClearFocus() {
   SetFocusedView(NULL);
-  ClearNativeFocus();
+  ClearHWNDFocus();
 }
 
+void FocusManager::ClearHWNDFocus() {
+  // Keep the top root window focused so we get keyboard events.
+  ignore_set_focus_msg_ = true;
+#if defined(OS_WIN)
+  ::SetFocus(root_);
+#else
+  NOTIMPLEMENTED();
+#endif
+  ignore_set_focus_msg_ = false;
+}
+
+#if defined(OS_WIN)
+void FocusManager::FocusHWND(HWND hwnd) {
+  ignore_set_focus_msg_ = true;
+  // Only reset focus if hwnd is not already focused.
+  if (hwnd && ::GetFocus() != hwnd)
+    ::SetFocus(hwnd);
+  ignore_set_focus_msg_ = false;
+}
+#endif
+
 void FocusManager::StoreFocusedView() {
   ViewStorage* view_storage = ViewStorage::GetSharedInstance();
   if (!view_storage) {
@@ -357,6 +535,19 @@ void FocusManager::ClearStoredFocusedView() {
   view_storage->RemoveView(stored_focused_view_storage_id_);
 }
 
+FocusManager* FocusManager::GetParentFocusManager() const {
+#if defined(OS_WIN)
+  HWND parent = ::GetParent(root_);
+#else
+  GtkWidget* parent = gtk_widget_get_parent(root_);
+#endif
+  // If we are a top window, we don't have a parent FocusManager.
+  if (!parent)
+    return NULL;
+
+  return GetFocusManager(parent);
+}
+
 // Find the next (previous if reverse is true) focusable view for the specified
 // FocusTraversable, starting at the specified view, traversing down the
 // FocusTraversable hierarchy.
@@ -438,6 +629,13 @@ bool FocusManager::ProcessAccelerator(const Accelerator& accelerator) {
     }
   }
 
+  // When dealing with child windows that have their own FocusManager (such
+  // as ConstrainedWindow), we still want the parent FocusManager to process
+  // the accelerator if the child window did not process it.
+  FocusManager* parent_focus_manager = GetParentFocusManager();
+  if (parent_focus_manager)
+    return parent_focus_manager->ProcessAccelerator(accelerator);
+
   return false;
 }
 
diff --git a/views/focus/focus_manager.h b/views/focus/focus_manager.h
index 8b4c8c9a..fb48188 100644
--- a/views/focus/focus_manager.h
+++ b/views/focus/focus_manager.h
@@ -20,7 +20,7 @@
 // focused views and handle keyboard accelerators.
 //
 // There are 2 types of focus:
-// - the native focus, which is the focus that an gfx::NativeView has.
+// - the native focus, which is the focus that an HWND has.
 // - the view focus, which is the focus that a views::View has.
 //
 // Each native view must register with their Focus Manager so the focus manager
@@ -32,9 +32,13 @@
 // This is already done for you if you subclass the NativeControl class or if
 // you use the NativeViewHost class.
 //
-// When creating a top window (derived from views::Widget) that is not a child
-// window, it creates and owns a FocusManager to manage the focus for itself and
-// all its child windows.
+// When creating a top window, if it derives from WidgetWin, the
+// |has_own_focus_manager| of the Init method lets you specify whether that
+// window should have its own focus manager (so focus traversal stays confined
+// in that window). If you are not deriving from WidgetWin or one of its
+// derived classes (Window, FramelessWindow, ConstrainedWindow), you must
+// create a FocusManager when the window is created (it is automatically deleted
+// when the window is destroyed).
 //
 // The FocusTraversable interface exposes the methods a class should implement
 // in order to be able to be focus traversed when tab key is pressed.
@@ -73,9 +77,8 @@
 
 namespace views {
 
-class RootView;
 class View;
-class Widget;
+class RootView;
 
 // The FocusTraversable interface is used by components that want to process
 // focus traversal events (due to Tab/Shift-Tab key events).
@@ -150,10 +153,22 @@ class FocusChangeListener {
 
 class FocusManager {
  public:
-  explicit FocusManager(Widget* widget);
-  ~FocusManager();
+#if defined(OS_WIN)
+  // Creates a FocusManager for the specified window. Top level windows
+  // must invoked this when created.
+  // The RootView specified should be the top RootView of the window.
+  // This also invokes InstallFocusSubclass.
+  static FocusManager* CreateFocusManager(HWND window, RootView* root_view);
+#endif
+
+  static FocusManager* GetFocusManager(gfx::NativeView window);
 
 #if defined(OS_WIN)
+  // Message handlers (for messages received from registered windows).
+  // Should return true if the message should be forwarded to the window
+  // original proc function, false otherwise.
+  bool OnSetFocus(HWND window);
+  bool OnNCDestroy(HWND window);
   // OnKeyDown covers WM_KEYDOWN and WM_SYSKEYDOWN.
   bool OnKeyDown(HWND window,
                  UINT message,
@@ -180,10 +195,27 @@ class FocusManager {
   // the native focus (so we still get keyboard events).
   void ClearFocus();
 
+  // Clears the HWND that has the focus by focusing the HWND from the top
+  // RootView (so we still get keyboard events).
+  // Note that this does not change the currently focused view.
+  void ClearHWNDFocus();
+
+#if defined(OS_WIN)
+  // Focus the specified |hwnd| without changing the focused view.
+  void FocusHWND(HWND hwnd);
+#endif
+
   // Validates the focused view, clearing it if the window it belongs too is not
   // attached to the window hierarchy anymore.
   void ValidateFocusedView();
 
+#if defined(OS_WIN)
+  // Returns the view associated with the specified window if any.
+  // If |look_in_parents| is true, it goes up the window parents until it find
+  // a view.
+  static View* GetViewForWindow(HWND window, bool look_in_parents);
+#endif
+
   // Stores and restores the focused view. Used when the window becomes
   // active/inactive.
   void StoreFocusedView();
@@ -192,6 +224,11 @@ class FocusManager {
   // Clears the stored focused view.
   void ClearStoredFocusedView();
 
+  // Returns the FocusManager of the parent window of the window that is the
+  // root of this FocusManager. This is useful with ConstrainedWindows that have
+  // their own FocusManager and need to return focus to the browser when closed.
+  FocusManager* GetParentFocusManager() const;
+
   // Register a keyboard accelerator for the specified target. If multiple
   // targets are registered for an accelerator, a target registered later has
   // higher priority.
@@ -243,17 +280,22 @@ class FocusManager {
   // pressed).
   static bool IsTabTraversalKeyEvent(const KeyEvent& key_event);
 
-  // Sets the focus to the specified native view.
-  virtual void FocusNativeView(gfx::NativeView native_view);
+ private:
+#if defined(OS_WIN)
+  explicit FocusManager(HWND root, RootView* root_view);
 
-  // Clears the native view having the focus.
-  virtual void ClearNativeFocus();
+  // Subclasses the specified window. The subclassed window procedure listens
+  // for WM_SETFOCUS notification and keeps the FocusManager's focus owner
+  // property in sync.
+  // It's not necessary to explicitly invoke Uninstall, it's automatically done
+  // when the window is destroyed and Uninstall wasn't invoked.
+  static void InstallFocusSubclass(HWND window, View* view);
 
-  // Retrieves the FocusManager associated with the passed native view.
-  static FocusManager* GetFocusManagerForNativeView(
-      gfx::NativeView native_view);
+  // Uninstalls the window subclass installed by InstallFocusSubclass.
+  static void UninstallFocusSubclass(HWND window);
+#endif
+  ~FocusManager();
 
- private:
   // Returns the next focusable view.
   View* GetNextFocusableView(View* starting_view, bool reverse, bool dont_loop);
 
@@ -265,8 +307,8 @@ class FocusManager {
                           View* starting_view,
                           bool reverse);
 
-  // The top-level Widget this FocusManager is associated with.
-  Widget* widget_;
+  // The RootView of the window associated with this FocusManager.
+  RootView* top_root_view_;
 
   // The view that currently is focused.
   View* focused_view_;
@@ -275,6 +317,13 @@ class FocusManager {
   // had focus.
   int stored_focused_view_storage_id_;
 
+  // The window associated with this focus manager.
+  gfx::NativeView root_;
+
+  // Used to allow setting the focus on an HWND without changing the currently
+  // focused view.
+  bool ignore_set_focus_msg_;
+
   // The accelerators and associated targets.
   typedef std::list<AcceleratorTarget*> AcceleratorTargetList;
   typedef std::map<Accelerator, AcceleratorTargetList> AcceleratorMap;
diff --git a/views/focus/focus_manager_gtk.cc b/views/focus/focus_manager_gtk.cc
deleted file mode 100644
index f6454d2..0000000
--- a/views/focus/focus_manager_gtk.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2006-2009 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 "views/focus/focus_manager.h"
-
-#include "base/logging.h"
-
-namespace views {
-
-void FocusManager::ClearNativeFocus() {
-  NOTIMPLEMENTED();
-}
-
-void FocusManager::FocusNativeView(gfx::NativeView native_view) {
-  NOTIMPLEMENTED();
-}
-
-// static
-FocusManager* FocusManager::GetFocusManagerForNativeView(
-    gfx::NativeView native_view) {
-  NOTIMPLEMENTED();
-}
-
-}  // namespace views
diff --git a/views/focus/focus_manager_unittest.cc b/views/focus/focus_manager_unittest.cc
index 7fff0bd..cc56271 100644
--- a/views/focus/focus_manager_unittest.cc
+++ b/views/focus/focus_manager_unittest.cc
@@ -119,7 +119,7 @@ class BorderView : public NativeControl {
                                         parent_container, NULL, NULL, NULL);
     // Create the view container which is a child of the TabControl.
     widget_ = new WidgetWin();
-    widget_->Init(tab_control, gfx::Rect());
+    widget_->Init(tab_control, gfx::Rect(), false);
     widget_->SetContentsView(child_);
     widget_->SetFocusTraversableParentView(this);
     ResizeContents(tab_control);
@@ -210,8 +210,7 @@ class FocusManagerTest : public testing::Test, public WindowDelegate {
   }
 
   FocusManager* GetFocusManager() {
-    return FocusManager::GetFocusManagerForNativeView(
-        window_->GetNativeWindow());
+    return FocusManager::GetFocusManager(window_->GetNativeWindow());
   }
 
   // WindowDelegate Implementation.
diff --git a/views/focus/focus_manager_win.cc b/views/focus/focus_manager_win.cc
deleted file mode 100644
index a3d01f9..0000000
--- a/views/focus/focus_manager_win.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2006-2009 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 "views/focus/focus_manager.h"
-
-#include "views/view.h"
-#include "views/widget/widget_win.h"
-
-namespace views {
-
-void FocusManager::ClearNativeFocus() {
-  // Keep the top root window focused so we get keyboard events.
-  ::SetFocus(widget_->GetNativeView());
-}
-
-void FocusManager::FocusNativeView(gfx::NativeView native_view) {
-  // Only reset focus if hwnd is not already focused.
-  if (native_view && ::GetFocus() != native_view)
-    ::SetFocus(native_view);
-}
-
-// static
-FocusManager* FocusManager::GetFocusManagerForNativeView(
-    gfx::NativeView native_view) {
-  HWND root = ::GetAncestor(native_view, GA_ROOT);
-  if (!root)
-    return NULL;
-  WidgetWin* widget = WidgetWin::GetWidget(root);
-  return widget ? widget->GetFocusManager() : NULL;
-}
-
-}  // namespace views
diff --git a/views/view.cc b/views/view.cc
index 820f3ec..0280aef 100644
--- a/views/view.cc
+++ b/views/view.cc
@@ -264,11 +264,6 @@ void View::SetFocusable(bool focusable) {
   focusable_ = focusable;
 }
 
-FocusManager* View::GetFocusManager() {
-  Widget* widget = GetWidget();
-  return widget ? widget->GetFocusManager() : NULL;
-}
-
 bool View::HasFocus() {
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager)
diff --git a/views/view_unittest.cc b/views/view_unittest.cc
index 829c682..6484653 100644
--- a/views/view_unittest.cc
+++ b/views/view_unittest.cc
@@ -306,7 +306,7 @@ TEST_F(ViewTest, MouseEvent) {
   views::WidgetWin window;
   window.set_delete_on_destroy(false);
   window.set_window_style(WS_OVERLAPPEDWINDOW);
-  window.Init(NULL, gfx::Rect(50, 50, 650, 650));
+  window.Init(NULL, gfx::Rect(50, 50, 650, 650), false);
   RootView* root = window.GetRootView();
 
   root->AddChildView(v1);
@@ -647,7 +647,7 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
   Clipboard clipboard;
 
   WidgetWin* window = new WidgetWin;
-  window->Init(NULL, gfx::Rect(0, 0, 100, 100));
+  window->Init(NULL, gfx::Rect(0, 0, 100, 100), true);
   RootView* root_view = window->GetRootView();
 
   Textfield* normal = new Textfield();
@@ -769,7 +769,7 @@ TEST_F(ViewTest, ActivateAccelerator) {
 
   // Create a window and add the view as its child.
   WidgetWin window;
-  window.Init(NULL, gfx::Rect(0, 0, 100, 100));
+  window.Init(NULL, gfx::Rect(0, 0, 100, 100), true);
   window.set_delete_on_destroy(false);
   window.set_window_style(WS_OVERLAPPEDWINDOW);
   RootView* root = window.GetRootView();
@@ -777,7 +777,7 @@ TEST_F(ViewTest, ActivateAccelerator) {
 
   // Get the focus manager.
   views::FocusManager* focus_manager =
-      views::FocusManager::GetFocusManagerForNativeView(window.GetNativeView());
+      views::FocusManager::GetFocusManager(window.GetNativeView());
   ASSERT_TRUE(focus_manager);
 
   // Hit the return key and see if it takes effect.
@@ -1032,7 +1032,7 @@ class DefaultButtonTest : public ViewTest {
                                           dialog_view_);
     window->Show();
     native_window_ = window->GetNativeWindow();
-    focus_manager_ = FocusManager::GetFocusManagerForNativeView(native_window_);
+    focus_manager_ = FocusManager::GetFocusManager(native_window_);
     client_view_ =
         static_cast<views::DialogClientView*>(window->GetClientView());
     ok_button_ = client_view_->ok_button();
diff --git a/views/view_win.cc b/views/view_win.cc
index bf265f9..c61363d 100644
--- a/views/view_win.cc
+++ b/views/view_win.cc
@@ -17,6 +17,18 @@
 
 namespace views {
 
+FocusManager* View::GetFocusManager() {
+  Widget* widget = GetWidget();
+  if (!widget)
+    return NULL;
+
+  HWND hwnd = widget->GetNativeView();
+  if (!hwnd)
+    return NULL;
+
+  return FocusManager::GetFocusManager(hwnd);
+}
+
 void View::DoDrag(const MouseEvent& e, int press_x, int press_y) {
   int drag_operations = GetDragOperations(press_x, press_y);
   if (drag_operations == DragDropTypes::DRAG_NONE)
@@ -43,7 +55,7 @@ void View::Focus() {
   // messages.
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager)
-    focus_manager->FocusNativeView(GetRootView()->GetWidget()->GetNativeView());
+    focus_manager->FocusHWND(GetRootView()->GetWidget()->GetNativeView());
 }
 
 int View::GetHorizontalDragThreshold() {
diff --git a/views/views.gyp b/views/views.gyp
index 8715403..b83ccae 100644
--- a/views/views.gyp
+++ b/views/views.gyp
@@ -42,9 +42,9 @@
       'type': '<(library)',
       'msvs_guid': '6F9258E5-294F-47B2-919D-17FFE7A8B751',
       'dependencies': [
-        '../app/app.gyp:app_base',
-        '../app/app.gyp:app_strings',
-        '../app/app.gyp:app_resources',
+        '../app/app.gyp:app_base',      
+        '../app/app.gyp:app_strings',      
+        '../app/app.gyp:app_resources',      
         '../skia/skia.gyp:skia',
         '../third_party/icu38/icu38.gyp:icui18n',
         '../third_party/icu38/icu38.gyp:icuuc',
@@ -174,8 +174,6 @@
         'fill_layout.h',
         'focus/external_focus_tracker.cc',
         'focus/external_focus_tracker.h',
-        'focus/focus_manager_gtk.cc',
-        'focus/focus_manager_win.cc',
         'focus/focus_manager.cc',
         'focus/focus_manager.h',
         'focus/focus_util_win.cc',
diff --git a/views/widget/accelerator_handler.cc b/views/widget/accelerator_handler.cc
index c171b50..386357f 100644
--- a/views/widget/accelerator_handler.cc
+++ b/views/widget/accelerator_handler.cc
@@ -15,8 +15,7 @@ bool AcceleratorHandler::Dispatch(const MSG& msg) {
   bool process_message = true;
 
   if (msg.message >= WM_KEYFIRST && msg.message <= WM_KEYLAST) {
-    FocusManager* focus_manager =
-        FocusManager::GetFocusManagerForNativeView(msg.hwnd);
+    FocusManager* focus_manager = FocusManager::GetFocusManager(msg.hwnd);
     if (focus_manager) {
       // FocusManager::OnKeyDown and OnKeyUp return false if this message has
       // been consumed and should not be propagated further.
diff --git a/views/widget/root_view.cc b/views/widget/root_view.cc
index 751786a..367c720 100644
--- a/views/widget/root_view.cc
+++ b/views/widget/root_view.cc
@@ -46,7 +46,7 @@ class PaintTask : public Task {
   // The target root view.
   RootView* root_view_;
 
-  DISALLOW_COPY_AND_ASSIGN(PaintTask);
+  DISALLOW_EVIL_CONSTRUCTORS(PaintTask);
 };
 
 const char RootView::kViewClassName[] = "views/RootView";
@@ -262,11 +262,23 @@ void RootView::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
       default_keyboard_handler_ = NULL;
     }
 
-    FocusManager* focus_manager = widget_->GetFocusManager();
-    // An unparanted RootView does not have a FocusManager.
-    if (focus_manager)
+    // For a given widget hierarchy, focus is tracked by a FocusManager attached
+    // to our nearest enclosing Window. <-- Important Assumption!
+    // We may not have access to our window if this function is called as a
+    // result of teardown during the deletion of the RootView and its hierarchy,
+    // so we don't bother notifying the FocusManager in that case because it
+    // will have already been destroyed (the Widget that contains us is
+    // NCDESTROY'ed which in turn destroys the focus manager _before_ the
+    // RootView is deleted.)
+#if defined(OS_WIN)
+    Window* window = GetWindow();
+    if (window) {
+      FocusManager* focus_manager =
+          FocusManager::GetFocusManager(window->GetNativeWindow());
       focus_manager->ViewRemoved(parent, child);
+    }
     ViewStorage::GetSharedInstance()->ViewRemoved(parent, child);
+#endif
   }
 }
 
@@ -509,6 +521,7 @@ void RootView::OnWidgetDestroyed() {
   // TODO(port): Port RootViewDropTarget and this goes away.
   NOTIMPLEMENTED();
 #endif
+  widget_ = NULL;
 }
 
 void RootView::ProcessMouseDragCanceled() {
diff --git a/views/widget/widget.h b/views/widget/widget.h
index 9c4c5ef..1dabf08 100644
--- a/views/widget/widget.h
+++ b/views/widget/widget.h
@@ -17,7 +17,6 @@ class Rect;
 namespace views {
 
 class Accelerator;
-class FocusManager;
 class RootView;
 class TooltipManager;
 class Window;
@@ -106,17 +105,13 @@ class Widget {
   virtual Window* GetWindow() { return NULL; }
   virtual const Window* GetWindow() const { return NULL; }
 
-  // Gets the theme provider.
+  // Get the theme provider.
   virtual ThemeProvider* GetThemeProvider() const { return NULL; }
 
-  // Gets the default theme provider; this is necessary for when a widget has
+  // Get the default theme provider; this is necessary for when a widget has
   // no profile (and ThemeProvider) associated with it. The default theme
   // provider provides a default set of bitmaps that such widgets can use.
   virtual ThemeProvider* GetDefaultThemeProvider() { return NULL; }
-
-  // Returns the FocusManager for this widget.
-  // Note that all widgets in a widget hierarchy share the same focus manager.
-  virtual FocusManager* GetFocusManager() { return NULL; }
 };
 
 }  // namespace views
diff --git a/views/widget/widget_win.cc b/views/widget/widget_win.cc
index 8f280d1..1fe3416 100644
--- a/views/widget/widget_win.cc
+++ b/views/widget/widget_win.cc
@@ -154,7 +154,8 @@ WidgetWin::~WidgetWin() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
-void WidgetWin::Init(HWND parent, const gfx::Rect& bounds) {
+void WidgetWin::Init(HWND parent, const gfx::Rect& bounds,
+                     bool has_own_focus_manager) {
   if (window_style_ == 0)
     window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
 
@@ -186,9 +187,8 @@ void WidgetWin::Init(HWND parent, const gfx::Rect& bounds) {
 
   root_view_->OnWidgetCreated();
 
-  if ((window_style_ & WS_CHILD) == 0) {
-    // Top-level widgets get a FocusManager.
-    focus_manager_.reset(new FocusManager(this));
+  if (has_own_focus_manager) {
+    FocusManager::CreateFocusManager(hwnd_, GetRootView());
   }
 
   // Sets the RootView as a property, so the automation can introspect windows.
@@ -419,18 +419,6 @@ const Window* WidgetWin::GetWindow() const {
   return GetWindowImpl(hwnd_);
 }
 
-FocusManager* WidgetWin::GetFocusManager() {
-  if (focus_manager_.get())
-    return focus_manager_.get();
-
-  HWND root = ::GetAncestor(hwnd_, GA_ROOT);
-  if (!root)
-    return NULL;
-
-  WidgetWin* widget = GetWidget(root);
-  return widget ?  widget->focus_manager_.get() : NULL;
-}
-
 void WidgetWin::SetUseLayeredBuffer(bool use_layered_buffer) {
   if (use_layered_buffer_ == use_layered_buffer)
     return;
@@ -472,12 +460,7 @@ RootView* WidgetWin::FindRootView(HWND hwnd) {
   return root_view;
 }
 
-// static
-WidgetWin* WidgetWin::GetWidget(HWND hwnd) {
-  return reinterpret_cast<WidgetWin*>(win_util::GetWindowUserData(hwnd));
-}
-
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 // MessageLoop::Observer
 
 void WidgetWin::WillProcessMessage(const MSG& msg) {
@@ -489,7 +472,7 @@ void WidgetWin::DidProcessMessage(const MSG& msg) {
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 // FocusTraversable
 
 View* WidgetWin::FindNextFocusableView(
@@ -1056,8 +1039,10 @@ LRESULT CALLBACK WidgetWin::WndProc(HWND window, UINT message,
   // Otherwise we handle everything else.
   if (!widget->ProcessWindowMessage(window, message, w_param, l_param, result))
     result = DefWindowProc(window, message, w_param, l_param);
-  if (message == WM_NCDESTROY)
+  if (message == WM_NCDESTROY) {
+    widget->hwnd_ = NULL;
     widget->OnFinalMessage(window);
+  }
   if (message == WM_ACTIVATE)
     PostProcessActivateMessage(widget, LOWORD(w_param));
   return result;
@@ -1066,16 +1051,18 @@ LRESULT CALLBACK WidgetWin::WndProc(HWND window, UINT message,
 // static
 void WidgetWin::PostProcessActivateMessage(WidgetWin* widget,
                                            int activation_state) {
-  if (!widget->focus_manager_.get()) {
+  FocusManager* focus_manager =
+      FocusManager::GetFocusManager(widget->GetNativeView());
+  if (!focus_manager) {
     NOTREACHED();
     return;
   }
   if (WA_INACTIVE == activation_state) {
-    widget->focus_manager_->StoreFocusedView();
+    focus_manager->StoreFocusedView();
   } else {
     // We must restore the focus after the message has been DefProc'ed as it
     // does set the focus to the last focused HWND.
-    widget->focus_manager_->RestoreFocusedView();
+    focus_manager->RestoreFocusedView();
   }
 }
 }  // namespace views
diff --git a/views/widget/widget_win.h b/views/widget/widget_win.h
index 6ae1141..b8500c7 100644
--- a/views/widget/widget_win.h
+++ b/views/widget/widget_win.h
@@ -78,7 +78,11 @@ class WidgetWin : public Widget,
   // this view, you are responsible for its destruction. If this value is NULL,
   // the caller is responsible for populating the RootView, and sizing its
   // contents as the window is sized.
-  void Init(HWND parent, const gfx::Rect& bounds);
+  // If |has_own_focus_manager| is true, the focus traversal stay confined to
+  // the window.
+  void Init(HWND parent,
+            const gfx::Rect& bounds,
+            bool has_own_focus_manager);
 
   // Sets the specified view as the contents of this Widget. There can only
   // be one contnets view child of this Widget's RootView. This view is sized to
@@ -118,9 +122,6 @@ class WidgetWin : public Widget,
   // Returns the RootView associated with the specified HWND (if any).
   static RootView* FindRootView(HWND hwnd);
 
-  // Returns the Widget associated with the specified HWND (if any).
-  static WidgetWin* GetWidget(HWND hwnd);
-
   // All classes registered by WidgetWin start with this name.
   static const wchar_t* const kBaseClassName;
 
@@ -229,7 +230,6 @@ class WidgetWin : public Widget,
   virtual ThemeProvider* GetThemeProvider() const;
   virtual Window* GetWindow();
   virtual const Window* GetWindow() const;
-  virtual FocusManager* GetFocusManager();
 
   // Overridden from MessageLoop::Observer:
   void WillProcessMessage(const MSG& msg);
@@ -327,6 +327,7 @@ class WidgetWin : public Widget,
   }
 
  protected:
+
   // Call close instead of this to Destroy the window.
   BOOL DestroyWindow() {
     DCHECK(::IsWindow(GetNativeView()));
@@ -522,12 +523,6 @@ class WidgetWin : public Widget,
   // the TooltipManager.
   scoped_ptr<TooltipManagerWin> tooltip_manager_;
 
-  // The focus manager keeping track of focus for this Widget and any of its
-  // children.  NULL for non top-level widgets.
-  // WARNING: RootView's destructor calls into the FocusManager. As such, this
-  // must be destroyed AFTER root_view_.
-  scoped_ptr<FocusManager> focus_manager_;
-
   // The root of the View hierarchy attached to this window.
   // WARNING: see warning in tooltip_manager_ for ordering dependencies with
   // this and tooltip_manager_.
diff --git a/views/window/window_win.cc b/views/window/window_win.cc
index 9f53ae2..fc809932 100755
--- a/views/window/window_win.cc
+++ b/views/window/window_win.cc
@@ -513,7 +513,7 @@ void WindowWin::Init(HWND parent, const gfx::Rect& bounds) {
   if (window_ex_style() == 0)
     set_window_ex_style(CalculateWindowExStyle());
 
-  WidgetWin::Init(parent, bounds);
+  WidgetWin::Init(parent, bounds, true);
   win_util::SetWindowUserData(GetNativeView(), this);
 
   // Create the ClientView, add it to the NonClientView and add the