Move more message handlers from NativeWidgetWin to HWNDMessageHandler.

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 1443 matching lines @@
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnImeMessages(UINT message,
                                        WPARAM w_param,
                                        LPARAM l_param) {
   return message_handler_->OnImeMessages(message, w_param, l_param);
 }
 
 void NativeWidgetWin::OnInitMenu(HMENU menu) {
-  bool is_fullscreen = IsFullscreen();
-  bool is_minimized = IsMinimized();
-  bool is_maximized = IsMaximized();
-  bool is_restored = !is_fullscreen && !is_minimized && !is_maximized;
-
-  ScopedRedrawLock lock(this);
-  EnableMenuItem(menu, SC_RESTORE, is_minimized || is_maximized);
-  EnableMenuItem(menu, SC_MOVE, is_restored);
-  EnableMenuItem(menu, SC_SIZE,
-                 GetWidget()->widget_delegate()->CanResize() && is_restored);
-  EnableMenuItem(menu, SC_MAXIMIZE,
-                 GetWidget()->widget_delegate()->CanMaximize() &&
-                     !is_fullscreen && !is_maximized);
-  EnableMenuItem(menu, SC_MINIMIZE,
-                 GetWidget()->widget_delegate()->CanMaximize() &&
-                     !is_minimized);
+  message_handler_->OnInitMenu(menu);
 }
 
 void NativeWidgetWin::OnInitMenuPopup(HMENU menu,
                                       UINT position,
                                       BOOL is_system_menu) {
-  SetMsgHandled(FALSE);
+  message_handler_->OnInitMenu(menu);
 }
 
 void NativeWidgetWin::OnInputLangChange(DWORD character_set,
                                         HKL input_language_id) {
   message_handler_->OnInputLangChange(character_set, input_language_id);
 }
 
 LRESULT NativeWidgetWin::OnKeyEvent(UINT message,
                                     WPARAM w_param,
                                     LPARAM l_param) {
-  MSG msg = { hwnd(), message, w_param, l_param };
-  ui::KeyEvent key(msg, message == WM_CHAR);
-  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
-  if (input_method)
-    input_method->DispatchKeyEvent(key);
-  else
-    DispatchKeyEventPostIME(key);
-  return 0;
+  return message_handler_->OnKeyEvent(message, w_param, l_param);
 }
 
 void NativeWidgetWin::OnKillFocus(HWND focused_window) {
-  delegate_->OnNativeBlur(focused_window);
-  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
-  if (input_method)
-    input_method->OnBlur();
-  SetMsgHandled(FALSE);
+  message_handler_->OnKillFocus(focused_window);
 }
 
 LRESULT NativeWidgetWin::OnMouseActivate(UINT message,
                                          WPARAM w_param,
                                          LPARAM l_param) {
   // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
   //             line.
   if (GetWidget()->non_client_view())
     return delegate_->CanActivate() ? MA_ACTIVATE : MA_NOACTIVATEANDEAT;
   if (GetWindowLong(GWL_EXSTYLE) & WS_EX_NOACTIVATE)
@@ skipping 226 matching lines @@
   // window from the left edge look slightly less broken.
   // We special case when left or top insets are 0, since these conditions
   // actually require another repaint to correct the layout after glass gets
   // turned on and off.
   if (insets.left() == 0 || insets.top() == 0)
     return 0;
   return mode ? WVR_REDRAW : 0;
 }
 
 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 (!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;
-  MapWindowPoints(HWND_DESKTOP, GetNativeView(), &temp, 1);
-  int component = delegate_->GetNonClientComponent(gfx::Point(temp));
-  if (component != HTNOWHERE)
-    return component;
-
-  // Otherwise, we let Windows do all the native frame non-client handling for
-  // us.
-  SetMsgHandled(FALSE);
-  return 0;
+  return message_handler_->OnNCHitTest(point);
 }
 
 void NativeWidgetWin::OnNCPaint(HRGN rgn) {
   // We only do non-client painting if we're not using the native frame.
   // It's required to avoid some native painting artifacts from appearing when
   // the window is resized.
   if (!GetWidget()->non_client_view() || GetWidget()->ShouldUseNativeFrame()) {
     SetMsgHandled(FALSE);
     return;
   }
@@ skipping 124 matching lines @@
 LRESULT NativeWidgetWin::OnReflectedMessage(UINT msg,
                                             WPARAM w_param,
                                             LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 LRESULT NativeWidgetWin::OnSetCursor(UINT message,
                                      WPARAM w_param,
                                      LPARAM l_param) {
-  // Using ScopedRedrawLock here frequently allows content behind this window to
-  // paint in front of this window, causing glaring rendering artifacts.
-  // If omitting ScopedRedrawLock here triggers caption rendering artifacts via
-  // DefWindowProc message handling, we'll need to find a better solution.
-  SetMsgHandled(FALSE);
-  return 0;
+  return message_handler_->OnSetCursor(message, w_param, l_param);
 }
 
 void NativeWidgetWin::OnSetFocus(HWND old_focused_window) {
-  delegate_->OnNativeFocus(old_focused_window);
-  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
-  if (input_method)
-    input_method->OnFocus();
-  SetMsgHandled(FALSE);
+  message_handler_->OnSetFocus(old_focused_window);
 }
 
 LRESULT NativeWidgetWin::OnSetIcon(UINT size_type, HICON new_icon) {
-  // Use a ScopedRedrawLock to avoid weird non-client painting.
-  return DefWindowProcWithRedrawLock(WM_SETICON, size_type,
-                                     reinterpret_cast<LPARAM>(new_icon));
+  return message_handler_->OnSetIcon(size_type, new_icon);
 }
 
 LRESULT NativeWidgetWin::OnSetText(const wchar_t* text) {
-  // Use a ScopedRedrawLock to avoid weird non-client painting.
-  return DefWindowProcWithRedrawLock(WM_SETTEXT, NULL,
-                                     reinterpret_cast<LPARAM>(text));
+  return message_handler_->OnSetText(text);
 }
 
 void NativeWidgetWin::OnSettingChange(UINT flags, const wchar_t* section) {
   if (!GetParent() && (flags == SPI_SETWORKAREA) &&
       !GetWidget()->widget_delegate()->WillProcessWorkAreaChange()) {
     // Fire a dummy SetWindowPos() call, so we'll trip the code in
     // OnWindowPosChanging() below that notices work area changes.
     ::SetWindowPos(GetNativeView(), 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
         SWP_NOZORDER | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
     SetMsgHandled(TRUE);
@@ skipping 288 matching lines @@
 // NativeWidgetWin, HWNDMessageHandlerDelegate implementation:
 
 bool NativeWidgetWin::IsWidgetWindow() const {
   return !!GetWidget()->non_client_view();
 }
 
 bool NativeWidgetWin::IsUsingCustomFrame() const {
   return GetWidget()->ShouldUseNativeFrame();
 }
 
+bool NativeWidgetWin::CanResize() const {
+  return GetWidget()->widget_delegate()->CanResize();
+}
+
+bool NativeWidgetWin::CanMaximize() const {
+  return GetWidget()->widget_delegate()->CanMaximize();
+}
+
+bool NativeWidgetWin::CanActivate() const {
+  return delegate_->CanActivate();
+}
+
+int NativeWidgetWin::GetNonClientComponent(const gfx::Point& point) const {
+  return delegate_->GetNonClientComponent(point);
+}
+
+void NativeWidgetWin::GetWindowMask(const gfx::Size& size, gfx::Path* path) {
+  GetWidget()->non_client_view()->GetWindowMask(size, path);
+}
+
 InputMethod* NativeWidgetWin::GetInputMethod() {
   return GetWidget()->GetInputMethodDirect();
 }
 
 void NativeWidgetWin::HandleAppDeactivated() {
   // Another application was activated, we should reset any state that
   // disables inactive rendering now.
   delegate_->EnableInactiveRendering();
 }
 
@@ skipping 43 matching lines @@
 }
 
 void NativeWidgetWin::HandleEndWMSizeMove() {
   delegate_->OnNativeWidgetEndUserBoundsChange();
 }
 
 void NativeWidgetWin::HandleMove() {
   delegate_->OnNativeWidgetMove();
 }
 
+void NativeWidgetWin::HandleNativeFocus(HWND last_focused_window) {
+  delegate_->OnNativeFocus(last_focused_window);
+}
+
+void NativeWidgetWin::HandleNativeBlur(HWND focused_window) {
+  delegate_->OnNativeBlur(focused_window);
+}
+
 NativeWidgetWin* NativeWidgetWin::AsNativeWidgetWin() {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, private:
 
 // static
 void NativeWidgetWin::PostProcessActivateMessage(NativeWidgetWin* widget,
                                                  int activation_state) {
@@ skipping 449 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