Begin to move some message handling from NWW onto a framework-agnostic HWND Message handler.

ui/views/widget/native_widget_win.cc

 // Copyright (c) 2012 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 "ui/views/widget/native_widget_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include <algorithm>
@@ skipping 27 matching lines @@
 #include "ui/views/controls/textfield/native_textfield_views.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/focus/accelerator_handler.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/focus/widget_focus_manager.h"
 #include "ui/views/ime/input_method_win.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/aero_tooltip_manager.h"
 #include "ui/views/widget/child_window_message_processor.h"
 #include "ui/views/widget/drop_target_win.h"
+#include "ui/views/widget/hwnd_message_handler.h"
 #include "ui/views/widget/monitor_win.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/widget_hwnd_utils.h"
 #include "ui/views/window/native_frame_view.h"
 
 #if !defined(USE_AURA)
 #include "base/command_line.h"
 #include "ui/base/ui_base_switches.h"
@@ skipping 364 matching lines @@
       fullscreen_(false),
       metro_snap_(false),
       force_hidden_count_(0),
       lock_updates_count_(0),
       ignore_window_pos_changes_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ignore_pos_changes_factory_(this)),
       last_monitor_(NULL),
       is_right_mouse_pressed_on_caption_(false),
       restored_enabled_(false),
       destroyed_(NULL),
-      has_non_client_view_(false) {
+      has_non_client_view_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+        message_handler_(new HWNDMessageHandler(this))) {
 }
 
 NativeWidgetWin::~NativeWidgetWin() {
   if (destroyed_ != NULL)
     *destroyed_ = true;
 
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete delegate_;
   else
     CloseNow();
@@ skipping 807 matching lines @@
   }
   return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
 // Message handlers ------------------------------------------------------------
 
 void NativeWidgetWin::OnActivate(UINT action, BOOL minimized, HWND window) {
-  SetMsgHandled(FALSE);
+  message_handler_->OnActivate(action, minimized, window);
 }
 
 void NativeWidgetWin::OnActivateApp(BOOL active, DWORD thread_id) {
-  if (GetWidget()->non_client_view() && !active &&
-      thread_id != GetCurrentThreadId()) {
-    // Another application was activated, we should reset any state that
-    // disables inactive rendering now.
-    delegate_->EnableInactiveRendering();
-    // Also update the native frame if it is rendering the non-client area.
-    if (!remove_standard_frame_ && GetWidget()->ShouldUseNativeFrame())
-      DefWindowProcWithRedrawLock(WM_NCACTIVATE, FALSE, 0);
-  }
+  message_handler_->OnActivateApp(active, thread_id);
 }
 
 LRESULT NativeWidgetWin::OnAppCommand(HWND window,
                                       short app_command,
                                       WORD device,
                                       int keystate) {
-  // We treat APPCOMMAND ids as an extension of our command namespace, and just
-  // let the delegate figure out what to do...
-  BOOL is_handled = (GetWidget()->widget_delegate() &&
-      GetWidget()->widget_delegate()->ExecuteWindowsCommand(app_command)) ?
-      TRUE : FALSE;
-  SetMsgHandled(is_handled);
-  // Make sure to return TRUE if the event was handled or in some cases the
-  // system will execute the default handler which can cause bugs like going
-  // forward or back two pages instead of one.
-  return is_handled;
+  return message_handler_->OnAppCommand(window, app_command, device, keystate);
 }
 
 void NativeWidgetWin::OnCancelMode() {
-  SetMsgHandled(FALSE);
+  message_handler_->OnCancelMode();
 }
 
 void NativeWidgetWin::OnCaptureChanged(HWND hwnd) {
-  delegate_->OnMouseCaptureLost();
+  message_handler_->OnCaptureChanged(hwnd);
 }
 
 void NativeWidgetWin::OnClose() {
-  GetWidget()->Close();
+  message_handler_->OnClose();
 }
 
 void NativeWidgetWin::OnCommand(UINT notification_code,
                                 int command_id,
                                 HWND window) {
-  // If the notification code is > 1 it means it is control specific and we
-  // should ignore it.
-  if (notification_code > 1 ||
-      GetWidget()->widget_delegate()->ExecuteWindowsCommand(command_id)) {
-    SetMsgHandled(FALSE);
-  }
+  message_handler_->OnCommand(notification_code, command_id, window);
 }
 
 LRESULT NativeWidgetWin::OnCreate(CREATESTRUCT* create_struct) {
   SetNativeWindowProperty(kNativeWidgetKey, this);
   CHECK_EQ(this, GetNativeWidgetForNativeView(hwnd()));
 
   use_layered_buffer_ = !!(window_ex_style() & WS_EX_LAYERED);
 
   // Attempt to detect screen readers by sending an event with our custom id.
   if (!IsAccessibleWidget())
@@ skipping 28 matching lines @@
 
   // This message initializes the window so that focus border are shown for
   // windows.
   SendMessage(
       hwnd(), WM_CHANGEUISTATE, MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS), 0);
 
   // Bug 964884: detach the IME attached to this window.
   // We should attach IMEs only when we need to input CJK strings.
   ImmAssociateContextEx(hwnd(), NULL, 0);
 
-  if (remove_standard_frame_) {
+  if (message_handler_->remove_standard_frame()) {
     SetWindowLong(GWL_STYLE, GetWindowLong(GWL_STYLE) & ~WS_CAPTION);
     SendFrameChanged(GetNativeView());
   }
 
   // We need to allow the delegate to size its contents since the window may not
   // receive a size notification when its initial bounds are specified at window
   // creation time.
   ClientAreaSizeChanged();
 
   delegate_->OnNativeWidgetCreated();
 
   // Get access to a modifiable copy of the system menu.
   GetSystemMenu(hwnd(), false);
 
   if (base::win::GetVersion() >= base::win::VERSION_WIN7)
     RegisterTouchWindow(hwnd(), 0);
 
   return 0;
 }
 
 void NativeWidgetWin::OnDestroy() {
-  delegate_->OnNativeWidgetDestroying();
-  if (drop_target_.get()) {
-    RevokeDragDrop(hwnd());
-    drop_target_ = NULL;
-  }
+  message_handler_->OnDestroy();
 }
 
 void NativeWidgetWin::OnDisplayChange(UINT bits_per_pixel, CSize screen_size) {
-  GetWidget()->widget_delegate()->OnDisplayChanged();
+  message_handler_->OnDisplayChange(bits_per_pixel, screen_size);
 }
 
 LRESULT NativeWidgetWin::OnDwmCompositionChanged(UINT msg,
                                                  WPARAM w_param,
                                                  LPARAM l_param) {
-  if (!GetWidget()->non_client_view()) {
-    SetMsgHandled(FALSE);
-    return 0;
-  }
-
-  // For some reason, we need to hide the window while we're changing the frame
-  // type only when we're changing it in response to WM_DWMCOMPOSITIONCHANGED.
-  // If we don't, the client area will be filled with black. I'm suspecting
-  // something skia-ey.
-  // Frame type toggling caused by the user (e.g. switching theme) doesn't seem
-  // to have this requirement.
-  FrameTypeChanged();
+  message_handler_->OnDwmCompositionChanged(msg, w_param, l_param);
   return 0;
 }
 
 void NativeWidgetWin::OnEndSession(BOOL ending, UINT logoff) {
-  SetMsgHandled(FALSE);
+  message_handler_->OnEndSession(ending, logoff);
 }
 
 void NativeWidgetWin::OnEnterSizeMove() {
-  delegate_->OnNativeWidgetBeginUserBoundsChange();
-  SetMsgHandled(FALSE);
+  message_handler_->OnEnterSizeMove();
 }
 
 LRESULT NativeWidgetWin::OnEraseBkgnd(HDC dc) {
-  // This is needed for magical win32 flicker ju-ju.
-  return 1;
+  return message_handler_->OnEraseBkgnd(dc);
 }
 
 void NativeWidgetWin::OnExitMenuLoop(BOOL is_track_popup_menu) {
-  SetMsgHandled(FALSE);
+  message_handler_->OnExitMenuLoop(is_track_popup_menu);
 }
 
 void NativeWidgetWin::OnExitSizeMove() {
-  delegate_->OnNativeWidgetEndUserBoundsChange();
-  SetMsgHandled(FALSE);
+  message_handler_->OnExitSizeMove();
 }
 
 LRESULT NativeWidgetWin::OnGetObject(UINT uMsg,
                                      WPARAM w_param,
                                      LPARAM l_param) {
   LRESULT reference_result = static_cast<LRESULT>(0L);
 
   // Accessibility readers will send an OBJID_CLIENT message
   if (OBJID_CLIENT == l_param) {
     // Retrieve MSAA dispatch object for the root view.
@@ skipping 283 matching lines @@
       WM_NCACTIVATE, inactive_rendering_disabled || active, 0);
 }
 
 LRESULT NativeWidgetWin::OnNCCalcSize(BOOL mode, LPARAM l_param) {
   // We only override the default handling if we need to specify a custom
   // non-client edge width. Note that in most cases "no insets" means no
   // custom width, but in fullscreen mode or when the NonClientFrameView
   // requests it, we want a custom width of 0.
   gfx::Insets insets = GetClientAreaInsets();
   if (insets.empty() && !IsFullscreen() &&
-      !(mode && remove_standard_frame_)) {
+      !(mode && message_handler_->remove_standard_frame())) {
     SetMsgHandled(FALSE);
     return 0;
   }
 
   RECT* client_rect = mode ?
       &(reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param)->rgrc[0]) :
       reinterpret_cast<RECT*>(l_param);
   client_rect->left += insets.left();
   client_rect->top += insets.top();
   client_rect->bottom -= insets.bottom();
@@ skipping 64 matching lines @@
 }
 
 LRESULT NativeWidgetWin::OnNCHitTest(const CPoint& point) {
   if (!GetWidget()->non_client_view()) {
     SetMsgHandled(FALSE);
     return 0;
   }
 
   // If the DWM is rendering the window controls, we need to give the DWM's
   // default window procedure first chance to handle hit testing.
-  if (!remove_standard_frame_ && GetWidget()->ShouldUseNativeFrame()) {
+  if (!message_handler_->remove_standard_frame() &&
+      GetWidget()->ShouldUseNativeFrame()) {
     LRESULT result;
     if (DwmDefWindowProc(GetNativeView(), WM_NCHITTEST, 0,
                          MAKELPARAM(point.x, point.y), &result)) {
       return result;
     }
   }
 
   // First, give the NonClientView a chance to test the point to see if it
   // provides any of the non-client area.
   POINT temp = point;
@@ skipping 373 matching lines @@
     SetMsgHandled(TRUE);
     return;
   }
 
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnWindowPosChanged(WINDOWPOS* window_pos) {
   if (DidClientAreaSizeChange(window_pos))
     ClientAreaSizeChanged();
-  if (remove_standard_frame_ && window_pos->flags & SWP_FRAMECHANGED &&
-      IsAeroGlassEnabled())
+  if (message_handler_->remove_standard_frame() &&
+      window_pos->flags & SWP_FRAMECHANGED &&
+      IsAeroGlassEnabled()) {
     UpdateDWMFrame();
+  }
   if (window_pos->flags & SWP_SHOWWINDOW)
     delegate_->OnNativeWidgetVisibilityChanged(true);
   else if (window_pos->flags & SWP_HIDEWINDOW)
     delegate_->OnNativeWidgetVisibilityChanged(false);
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnFinalMessage(HWND window) {
   // We don't destroy props in WM_DESTROY as we may still get messages after
   // WM_DESTROY that assume the properties are still valid (such as WM_CLOSE).
   props_.clear();
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
 int NativeWidgetWin::GetShowState() const {
   return SW_SHOWNORMAL;
 }
 
 gfx::Insets NativeWidgetWin::GetClientAreaInsets() const {
   // Returning an empty Insets object causes the default handling in
   // NativeWidgetWin::OnNCCalcSize() to be invoked.
   if (!has_non_client_view_ ||
-      (GetWidget()->ShouldUseNativeFrame() && !remove_standard_frame_))
+      (GetWidget()->ShouldUseNativeFrame() &&
+       !message_handler_->remove_standard_frame()))
     return gfx::Insets();
 
   if (IsMaximized()) {
     // Windows automatically adds a standard width border to all sides when a
     // window is maximized.
     int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME);
     return gfx::Insets(border_thickness, border_thickness, border_thickness,
                        border_thickness);
   }
 
   // The hack below doesn't seem to be necessary when the standard frame is
   // removed.
-  if (remove_standard_frame_)
+  if (message_handler_->remove_standard_frame())
     return gfx::Insets();
   // This is weird, but highly essential. If we don't offset the bottom edge
   // of the client rect, the window client area and window area will match,
   // and when returning to glass rendering mode from non-glass, the client
   // area will not paint black as transparent. This is because (and I don't
   // know why) the client area goes from matching the window rect to being
   // something else. If the client area is not the window rect in both
   // modes, the blackness doesn't occur. Because of this, we need to tell
   // the RootView to lay out to fit the window rect, rather than the client
   // rect when using the opaque frame.
@@ skipping 38 matching lines @@
     SetFocus(GetNativeView());
   }
 }
 
 void NativeWidgetWin::ExecuteSystemMenuCommand(int command) {
   if (command)
     SendMessage(GetNativeView(), WM_SYSCOMMAND, command, 0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetWin, HWNDMessageHandlerDelegate implementation:
+
+bool NativeWidgetWin::IsWidgetWindow() const {
+  return !!GetWidget()->non_client_view();
+}
+
+bool NativeWidgetWin::IsUsingCustomFrame() const {
+  return GetWidget()->ShouldUseNativeFrame();
+}
+
+void NativeWidgetWin::HandleAppDeactivated() {
+  // Another application was activated, we should reset any state that
+  // disables inactive rendering now.
+  delegate_->EnableInactiveRendering();
+}
+
+bool NativeWidgetWin::HandleAppCommand(short command) {
+  // We treat APPCOMMAND ids as an extension of our command namespace, and just
+  // let the delegate figure out what to do...
+  return GetWidget()->widget_delegate() &&
+      GetWidget()->widget_delegate()->ExecuteWindowsCommand(command);
+}
+
+void NativeWidgetWin::HandleCaptureLost() {
+  delegate_->OnMouseCaptureLost();
+}
+
+void NativeWidgetWin::HandleClose() {
+  GetWidget()->Close();
+}
+
+bool NativeWidgetWin::HandleCommand(int command) {
+  return GetWidget()->widget_delegate()->ExecuteWindowsCommand(command);
+}
+
+void NativeWidgetWin::HandleDestroy() {
+  delegate_->OnNativeWidgetDestroying();
+  if (drop_target_.get()) {
+    RevokeDragDrop(hwnd());
+    drop_target_ = NULL;
+  }
+}
+
+void NativeWidgetWin::HandleDisplayChange() {
+  GetWidget()->widget_delegate()->OnDisplayChanged();
+}
+
+void NativeWidgetWin::HandleGlassModeChange() {
+  // For some reason, we need to hide the window while we're changing the frame
+  // type only when we're changing it in response to WM_DWMCOMPOSITIONCHANGED.
+  // If we don't, the client area will be filled with black. I'm suspecting
+  // something skia-ey.
+  // Frame type toggling caused by the user (e.g. switching theme) doesn't seem
+  // to have this requirement.
+  FrameTypeChanged();
+}
+
+void NativeWidgetWin::HandleBeginWMSizeMove() {
+  delegate_->OnNativeWidgetBeginUserBoundsChange();
+}
+
+void NativeWidgetWin::HandleEndWMSizeMove() {
+  delegate_->OnNativeWidgetEndUserBoundsChange();
+}
+
+NativeWidgetWin* NativeWidgetWin::AsNativeWidgetWin() {
+  return this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, private:
 
 // static
 void NativeWidgetWin::PostProcessActivateMessage(NativeWidgetWin* widget,
                                                  int activation_state) {
   DCHECK(widget->GetWidget()->is_top_level());
   FocusManager* focus_manager = widget->GetWidget()->GetFocusManager();
   if (WA_INACTIVE == activation_state) {
     // We might get activated/inactivated without being enabled, so we need to
     // clear restore_focus_when_enabled_.
@@ skipping 108 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 
   set_initial_class_style(class_style);
   set_window_style(window_style() | style);
   set_window_ex_style(window_ex_style() | ex_style);
 
   has_non_client_view_ = Widget::RequiresNonClientView(params.type);
-  remove_standard_frame_ = params.remove_standard_frame;
+  message_handler_->set_remove_standard_frame(params.remove_standard_frame);
 }
 
 void NativeWidgetWin::RedrawInvalidRect() {
   if (!use_layered_buffer_) {
     RECT r = { 0, 0, 0, 0 };
     if (GetUpdateRect(hwnd(), &r, FALSE) && !IsRectEmpty(&r)) {
       RedrawWindow(hwnd(), &r, NULL,
                    RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOCHILDREN);
     }
   }
@@ skipping 315 matching lines @@
 // static
 bool NativeWidgetPrivate::IsTouchDown() {
   // This currently isn't necessary because we're not generating touch events on
   // windows.  When we do, this will need to be updated.
   return false;
 }
 
 }  // namespace internal
 
 }  // namespace views