Relanding focus manager refactoring

views/widget/widget_win.cc

 // Copyright (c) 2006-2008 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/widget/widget_win.h"
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/path.h"
 #include "app/win_util.h"
 #include "base/gfx/native_theme.h"
@@ skipping 136 matching lines @@
       is_mouse_down_(false),
       is_window_(false),
       class_style_(CS_DBLCLKS),
       hwnd_(NULL) {
 }
 
 WidgetWin::~WidgetWin() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
-void WidgetWin::Init(HWND parent, const gfx::Rect& bounds,
-                     bool has_own_focus_manager) {
+void WidgetWin::Init(HWND parent, const gfx::Rect& bounds) {
   if (window_style_ == 0)
     window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
 
   // See if the style has been overridden.
   opaque_ = !(window_ex_style_ & WS_EX_TRANSPARENT);
   use_layered_buffer_ = (use_layered_buffer_ &&
                          !!(window_ex_style_ & WS_EX_LAYERED));
 
   // Force creation of the RootView if it hasn't been created yet.
   GetRootView();
@@ skipping 11 matching lines @@
                          window_style_, bounds.x(), bounds.y(), bounds.width(),
                          bounds.height(), parent, NULL, NULL, this);
   DCHECK(hwnd_);
   SetWindowSupportsRerouteMouseWheel(hwnd_);
 
   // The window procedure should have set the data for us.
   DCHECK(win_util::GetWindowUserData(hwnd_) == this);
 
   root_view_->OnWidgetCreated();
 
-  if (has_own_focus_manager) {
-    FocusManager::CreateFocusManager(hwnd_, GetRootView());
+  if ((window_style_ & WS_CHILD) == 0) {
+    // Top-level widgets get a FocusManager.
+    focus_manager_.reset(new FocusManager(this));
   }
 
   // Sets the RootView as a property, so the automation can introspect windows.
   SetRootViewForHWND(hwnd_, root_view_.get());
 
   MessageLoopForUI::current()->AddObserver(this);
 
   // Windows special DWM window frame requires a special tooltip manager so
   // that window controls in Chrome windows don't flicker when you move your
   // mouse over them. See comment in aero_tooltip_manager.h.
@@ skipping 57 matching lines @@
 void WidgetWin::SetShape(const gfx::Path& shape) {
   SetWindowRgn(shape.CreateHRGN(), TRUE);
 }
 
 void WidgetWin::Close() {
   if (!IsWindow())
     return;  // No need to do anything.
 
   // Let's hide ourselves right away.
   Hide();
+
   if (close_widget_factory_.empty()) {
     // And we delay the close so that if we are called from an ATL callback,
     // we don't destroy the window before the callback returned (as the caller
     // may delete ourselves on destroy and the ATL callback would still
     // dereference us when the callback returns).
     MessageLoop::current()->PostTask(FROM_HERE,
         close_widget_factory_.NewRunnableMethod(
             &WidgetWin::CloseNow));
   }
 }
@@ skipping 133 matching lines @@
 }
 
 Window* WidgetWin::GetWindow() {
   return GetWindowImpl(hwnd_);
 }
 
 const Window* WidgetWin::GetWindow() const {
   return GetWindowImpl(hwnd_);
 }
 
+FocusManager* WidgetWin::GetFocusManager() {
+  if (focus_manager_.get())
+    return focus_manager_.get();
+
+  WidgetWin* widget = static_cast<WidgetWin*>(GetRootWidget());
+  if (widget && widget != this) {
+    // WidgetWin subclasses may override GetFocusManager(), for example for
+    // dealing with cases where the widget has been unparented.
+    return widget->GetFocusManager();
+  }
+  return NULL;
+}
+
 void WidgetWin::SetUseLayeredBuffer(bool use_layered_buffer) {
   if (use_layered_buffer_ == use_layered_buffer)
     return;
 
   use_layered_buffer_ = use_layered_buffer;
   if (!hwnd_)
     return;
 
   if (use_layered_buffer_) {
     // Force creation of the buffer at the right size.
@@ skipping 21 matching lines @@
     reinterpret_cast<RootView*>(GetProp(hwnd, kRootViewWindowProperty));
   if (root_view)
     return root_view;
 
   // Enumerate all children and check if they have a RootView.
   EnumChildWindows(hwnd, EnumChildProc, reinterpret_cast<LPARAM>(&root_view));
 
   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) {
 }
 
 void WidgetWin::DidProcessMessage(const MSG& msg) {
   if (root_view_->NeedsPainting(true)) {
     PaintNow(root_view_->GetScheduledPaintRect());
   }
 }
 
-///////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // FocusTraversable
 
 View* WidgetWin::FindNextFocusableView(
     View* starting_view, bool reverse, Direction direction,
     bool check_starting_view, FocusTraversable** focus_traversable,
     View** focus_traversable_view) {
   return root_view_->FindNextFocusableView(starting_view,
                                            reverse,
                                            direction,
                                            check_starting_view,
@@ skipping 546 matching lines @@
 
   // First allow messages sent by child controls to be processed directly by
   // their associated views. If such a view is present, it will handle the
   // message *instead of* this WidgetWin.
   if (ProcessNativeControlMessage(message, w_param, l_param, &result))
     return result;
 
   // 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) {
-    widget->hwnd_ = NULL;
+  if (message == WM_NCDESTROY)
     widget->OnFinalMessage(window);
-  }
   if (message == WM_ACTIVATE)
     PostProcessActivateMessage(widget, LOWORD(w_param));
   return result;
 }
 
 // static
 void WidgetWin::PostProcessActivateMessage(WidgetWin* widget,
                                            int activation_state) {
-  FocusManager* focus_manager =
-      FocusManager::GetFocusManager(widget->GetNativeView());
-  if (!focus_manager) {
+  if (!widget->focus_manager_.get()) {
     NOTREACHED();
     return;
   }
   if (WA_INACTIVE == activation_state) {
-    focus_manager->StoreFocusedView();
+    widget->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.
-    focus_manager->RestoreFocusedView();
+    widget->focus_manager_->RestoreFocusedView();
   }
 }
 }  // namespace views