Adds the ability for classes other than native control to process

views/widget/widget_win.cc

 // Copyright (c) 2010 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/keyboard_code_conversion_win.h"
 #include "app/l10n_util_win.h"
 #include "app/system_monitor.h"
 #include "app/win_util.h"
 #include "app/win/scoped_prop.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/native_theme_win.h"
 #include "gfx/path.h"
 #include "views/accessibility/view_accessibility.h"
 #include "views/controls/native_control_win.h"
 #include "views/focus/focus_util_win.h"
 #include "views/views_delegate.h"
 #include "views/widget/aero_tooltip_manager.h"
+#include "views/widget/child_window_message_processor.h"
 #include "views/widget/default_theme_provider.h"
 #include "views/widget/drop_target_win.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/window_win.h"
 
 namespace views {
 
 // Property used to link the HWND to its RootView.
 static const wchar_t* const kRootViewWindowProperty = L"__ROOT_VIEW__";
 static const wchar_t* kWidgetKey = L"__VIEWS_WIDGET__";
 
 bool WidgetWin::screen_reader_active_ = false;
 
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 #define OBJID_CUSTOM 1
 
 RootView* GetRootViewForHWND(HWND hwnd) {
   return reinterpret_cast<RootView*>(::GetProp(hwnd, kRootViewWindowProperty));
 }
 
-NativeControlWin* GetNativeControlWinForHWND(HWND hwnd) {
-  return reinterpret_cast<NativeControlWin*>(
-      GetProp(hwnd, NativeControlWin::kNativeControlWinKey));
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
     : close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       has_capture_(false),
       use_layered_buffer_(true),
       layered_alpha_(255),
       delete_on_destroy_(true),
@@ skipping 1107 matching lines @@
     return NULL;
   }
   View* focused_view = focus_manager->GetFocusedView();
   if (!focused_view)
     return NULL;
   return focused_view->GetRootView();
 }
 
 // Get the source HWND of the specified message. Depending on the message, the
 // source HWND is encoded in either the WPARAM or the LPARAM value.
-HWND GetControlHWNDForMessage(UINT message, WPARAM w_param, LPARAM l_param) {
+static HWND GetControlHWNDForMessage(UINT message,
+                                     WPARAM w_param,
+                                     LPARAM l_param) {
   // Each of the following messages can be sent by a child HWND and must be
   // forwarded to its associated NativeControlWin for handling.
   switch (message) {
     case WM_NOTIFY:
       return reinterpret_cast<NMHDR*>(l_param)->hwndFrom;
     case WM_COMMAND:
       return reinterpret_cast<HWND>(l_param);
     case WM_CONTEXTMENU:
       return reinterpret_cast<HWND>(w_param);
     case WM_CTLCOLORBTN:
     case WM_CTLCOLORSTATIC:
       return reinterpret_cast<HWND>(l_param);
   }
   return NULL;
 }
 
 HICON WidgetWin::GetDefaultWindowIcon() const {
   if (ViewsDelegate::views_delegate)
     return ViewsDelegate::views_delegate->GetDefaultWindowIcon();
   return NULL;
 }
 
-// Some messages may be sent to us by a child HWND managed by
-// NativeControlWin. If this is the case, this function will forward those
-// messages on to the object associated with the source HWND and return true,
-// in which case the window procedure must not do any further processing of
-// the message. If there is no associated NativeControlWin, the return value
-// will be false and the WndProc can continue processing the message normally.
-// |l_result| contains the result of the message processing by the control and
-// must be returned by the WndProc if the return value is true.
-bool ProcessNativeControlMessage(UINT message,
-                                 WPARAM w_param,
-                                 LPARAM l_param,
-                                 LRESULT* l_result) {
+// Some messages may be sent to us by a child HWND. If this is the case, this
+// function will forward those messages on to the object associated with the
+// source HWND and return true, in which case the window procedure must not do
+// any further processing of the message. If there is no associated
+// ChildWindowMessageProcessor, the return value will be false and the WndProc
+// can continue processing the message normally.  |l_result| contains the result
+// of the message processing by the control and must be returned by the WndProc
+// if the return value is true.
+static bool ProcessChildWindowMessage(UINT message,
+                                      WPARAM w_param,
+                                      LPARAM l_param,
+                                      LRESULT* l_result) {
   *l_result = 0;
 
   HWND control_hwnd = GetControlHWNDForMessage(message, w_param, l_param);
   if (IsWindow(control_hwnd)) {
-    NativeControlWin* wrapper = GetNativeControlWinForHWND(control_hwnd);
-    if (wrapper)
-      return wrapper->ProcessMessage(message, w_param, l_param, l_result);
+    ChildWindowMessageProcessor* processor =
+        ChildWindowMessageProcessor::Get(control_hwnd);
+    if (processor)
+      return processor->ProcessMessage(message, w_param, l_param, l_result);
   }
 
   return false;
 }
 
 LRESULT WidgetWin::OnWndProc(UINT message, WPARAM w_param, LPARAM l_param) {
   HWND window = hwnd();
   LRESULT result = 0;
 
   // 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))
+  if (ProcessChildWindowMessage(message, w_param, l_param, &result))
     return result;
 
   // Otherwise we handle everything else.
   if (!ProcessWindowMessage(window, message, w_param, l_param, result))
     result = DefWindowProc(window, message, w_param, l_param);
   if (message == WM_NCDESTROY) {
     MessageLoopForUI::current()->RemoveObserver(this);
     OnFinalMessage(window);
   }
   if (message == WM_ACTIVATE)
@@ skipping 128 matching lines @@
 Widget* Widget::GetWidgetFromNativeWindow(gfx::NativeWindow native_window) {
   return Widget::GetWidgetFromNativeView(native_window);
 }
 
 // static
 void Widget::NotifyLocaleChanged() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace views