Revert 152098 - Landing this again to get more information about the crashes. Doesn't crash locally…

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>
 
 #include "base/bind.h"
 #include "base/string_util.h"
+#include "base/system_monitor/system_monitor.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_source.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
 #include "ui/base/event.h"
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/l10n/l10n_util_win.h"
+#include "ui/base/native_theme/native_theme_win.h"
 #include "ui/base/theme_provider.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_paint.h"
 #include "ui/gfx/canvas_skia_paint.h"
 #include "ui/gfx/icon_util.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
@@ skipping 503 matching lines @@
   WindowImpl::Init(params.GetParent(), params.bounds);
 }
 
 NonClientFrameView* NativeWidgetWin::CreateNonClientFrameView() {
   return GetWidget()->ShouldUseNativeFrame() ?
       new NativeFrameView(GetWidget()) : NULL;
 }
 
 void NativeWidgetWin::UpdateFrameAfterFrameChange() {
   // We've either gained or lost a custom window region, so reset it now.
-  message_handler_->ResetWindowRegion(true);
+  ResetWindowRegion(true);
 }
 
 bool NativeWidgetWin::ShouldUseNativeFrame() const {
   return IsAeroGlassEnabled();
 }
 
 void NativeWidgetWin::FrameTypeChanged() {
   // Called when the frame type could possibly be changing (theme change or
   // DWM composition change).
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
@@ skipping 891 matching lines @@
 
 void NativeWidgetWin::OnHScroll(int scroll_type,
                                 short position,
                                 HWND scrollbar) {
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnImeMessages(UINT message,
                                        WPARAM w_param,
                                        LPARAM l_param) {
-  return message_handler_->OnImeMessages(message, w_param, l_param);
+  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
+  if (!input_method || input_method->IsMock()) {
+    SetMsgHandled(FALSE);
+    return 0;
+  }
+
+  InputMethodWin* ime_win = static_cast<InputMethodWin*>(input_method);
+  BOOL handled = FALSE;
+  LRESULT result = ime_win->OnImeMessages(message, w_param, l_param, &handled);
+
+  SetMsgHandled(handled);
+  return result;
 }
 
 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);
-  message_handler_->OnInitMenu(menu);
+  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);
 }
 
 void NativeWidgetWin::OnInitMenuPopup(HMENU menu,
                                       UINT position,
                                       BOOL is_system_menu) {
-  message_handler_->OnInitMenu(menu);
+  SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnInputLangChange(DWORD character_set,
                                         HKL input_language_id) {
-  message_handler_->OnInputLangChange(character_set, input_language_id);
+  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
+
+  if (input_method && !input_method->IsMock()) {
+    static_cast<InputMethodWin*>(input_method)->OnInputLangChange(
+        character_set, input_language_id);
+  }
 }
 
 LRESULT NativeWidgetWin::OnKeyEvent(UINT message,
                                     WPARAM w_param,
                                     LPARAM l_param) {
-  return message_handler_->OnKeyEvent(message, w_param, 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;
 }
 
 void NativeWidgetWin::OnKillFocus(HWND focused_window) {
-  message_handler_->OnKillFocus(focused_window);
+  delegate_->OnNativeBlur(focused_window);
+  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
+  if (input_method)
+    input_method->OnBlur();
+  SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnMouseActivate(UINT message,
                                          WPARAM w_param,
                                          LPARAM l_param) {
-  return message_handler_->OnMouseActivate(message, w_param, 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)
+    return MA_NOACTIVATE;
+  SetMsgHandled(FALSE);
+  return MA_ACTIVATE;
 }
 
 LRESULT NativeWidgetWin::OnMouseRange(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   if (message == WM_RBUTTONUP && is_right_mouse_pressed_on_caption_) {
     is_right_mouse_pressed_on_caption_ = false;
     ReleaseCapture();
     // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
     // expect screen coordinates.
@@ skipping 74 matching lines @@
     // side-effects (ex/ stifling non-client mouse releases).
     DefWindowProcWithRedrawLock(message, w_param, l_param);
     handled = true;
   }
 
   SetMsgHandled(handled);
   return 0;
 }
 
 void NativeWidgetWin::OnMove(const CPoint& point) {
-  message_handler_->OnMove(point);
+  delegate_->OnNativeWidgetMove();
+  SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnMoving(UINT param, const LPRECT new_bounds) {
-  message_handler_->OnMoving(param, new_bounds);
+  delegate_->OnNativeWidgetMove();
 }
 
 LRESULT NativeWidgetWin::OnNCActivate(BOOL active) {
   if (delegate_->CanActivate())
     delegate_->OnNativeWidgetActivationChanged(!!active);
 
   if (!GetWidget()->non_client_view()) {
     SetMsgHandled(FALSE);
     return 0;
   }
@@ skipping 114 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) {
-  return message_handler_->OnNCHitTest(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;
 }
 
 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 67 matching lines @@
 
   ReleaseDC(GetNativeView(), dc);
   // When using a custom frame, we want to avoid calling DefWindowProc() since
   // that may render artifacts.
   SetMsgHandled(!GetWidget()->ShouldUseNativeFrame());
 }
 
 LRESULT NativeWidgetWin::OnNCUAHDrawCaption(UINT msg,
                                             WPARAM w_param,
                                             LPARAM l_param) {
-  return message_handler_->OnNCUAHDrawCaption(msg, w_param, l_param);
+  // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
+  // an explanation about why we need to handle this message.
+  SetMsgHandled(!GetWidget()->ShouldUseNativeFrame());
+  return 0;
 }
 
 LRESULT NativeWidgetWin::OnNCUAHDrawFrame(UINT msg,
                                           WPARAM w_param,
                                           LPARAM l_param) {
-  return message_handler_->OnNCUAHDrawFrame(msg, w_param, l_param);
+  // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
+  // an explanation about why we need to handle this message.
+  SetMsgHandled(!GetWidget()->ShouldUseNativeFrame());
+  return 0;
 }
 
 LRESULT NativeWidgetWin::OnNotify(int w_param, NMHDR* l_param) {
   // We can be sent this message before the tooltip manager is created, if a
   // subclass overrides OnCreate and creates some kind of Windows control there
   // that sends WM_NOTIFY messages.
   if (tooltip_manager_.get()) {
     bool handled;
     LRESULT result = tooltip_manager_->OnNotify(w_param, l_param, &handled);
     SetMsgHandled(handled);
@@ skipping 17 matching lines @@
       delegate_->OnNativeWidgetPaint(canvas->AsCanvas());
     }
   } else {
     // TODO(msw): Find a better solution for this crbug.com/93530 workaround.
     // Some scenarios otherwise fail to validate minimized app/popup windows.
     ValidateRect(hwnd(), NULL);
   }
 }
 
 LRESULT NativeWidgetWin::OnPowerBroadcast(DWORD power_event, DWORD data) {
-  return message_handler_->OnPowerBroadcast(power_event, data);
+  base::SystemMonitor* monitor = base::SystemMonitor::Get();
+  if (monitor)
+    monitor->ProcessWmPowerBroadcastMessage(power_event);
+  SetMsgHandled(FALSE);
+  return 0;
 }
 
 LRESULT NativeWidgetWin::OnReflectedMessage(UINT msg,
                                             WPARAM w_param,
                                             LPARAM l_param) {
-  return message_handler_->OnReflectedMessage(msg, w_param, l_param);
+  SetMsgHandled(FALSE);
+  return 0;
 }
 
 LRESULT NativeWidgetWin::OnSetCursor(UINT message,
                                      WPARAM w_param,
                                      LPARAM l_param) {
-  return message_handler_->OnSetCursor(message, w_param, 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;
 }
 
 void NativeWidgetWin::OnSetFocus(HWND old_focused_window) {
-  message_handler_->OnSetFocus(old_focused_window);
+  delegate_->OnNativeFocus(old_focused_window);
+  InputMethod* input_method = GetWidget()->GetInputMethodDirect();
+  if (input_method)
+    input_method->OnFocus();
+  SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnSetIcon(UINT size_type, HICON new_icon) {
-  return message_handler_->OnSetIcon(size_type, new_icon);
+  // Use a ScopedRedrawLock to avoid weird non-client painting.
+  return DefWindowProcWithRedrawLock(WM_SETICON, size_type,
+                                     reinterpret_cast<LPARAM>(new_icon));
 }
 
 LRESULT NativeWidgetWin::OnSetText(const wchar_t* text) {
-  return message_handler_->OnSetText(text);
+  // Use a ScopedRedrawLock to avoid weird non-client painting.
+  return DefWindowProcWithRedrawLock(WM_SETTEXT, NULL,
+                                     reinterpret_cast<LPARAM>(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);
   } else {
     // TODO(beng): move to Widget.
     if (flags == SPI_SETWORKAREA)
       GetWidget()->widget_delegate()->OnWorkAreaChanged();
     SetMsgHandled(FALSE);
   }
 }
 
 void NativeWidgetWin::OnSize(UINT param, const CSize& size) {
-  message_handler_->OnSize(param, size);
+  RedrawWindow(GetNativeView(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
+  // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
+  // invoked OnSize we ensure the RootView has been laid out.
+  ResetWindowRegion(false);
 }
 
 void NativeWidgetWin::OnSysCommand(UINT notification_code, CPoint click) {
   if (!GetWidget()->non_client_view())
     return;
 
   // Windows uses the 4 lower order bits of |notification_code| for type-
   // specific information so we must exclude this when comparing.
   static const int sc_mask = 0xFFF0;
   // Ignore size/move/maximize in fullscreen mode.
@@ skipping 34 matching lines @@
   }
 
   // If the delegate can't handle it, the system implementation will be called.
   if (!delegate_->ExecuteCommand(notification_code)) {
     DefWindowProc(GetNativeView(), WM_SYSCOMMAND, notification_code,
                   MAKELPARAM(click.x, click.y));
   }
 }
 
 void NativeWidgetWin::OnThemeChanged() {
-  message_handler_->OnThemeChanged();
+  // Notify NativeThemeWin.
+  ui::NativeThemeWin::instance()->CloseHandles();
 }
 
 LRESULT NativeWidgetWin::OnTouchEvent(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   int num_points = LOWORD(w_param);
   scoped_array<TOUCHINPUT> input(new TOUCHINPUT[num_points]);
   if (GetTouchInputInfo(reinterpret_cast<HTOUCHINPUT>(l_param),
                         num_points, input.get(), sizeof(TOUCHINPUT))) {
     for (int i = 0; i < num_points; ++i) {
       if (input[i].dwFlags & TOUCHEVENTF_DOWN)
         touch_ids_.insert(input[i].dwID);
       if (input[i].dwFlags & TOUCHEVENTF_UP)
         touch_ids_.erase(input[i].dwID);
     }
   }
   CloseTouchInputHandle(reinterpret_cast<HTOUCHINPUT>(l_param));
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void NativeWidgetWin::OnVScroll(int scroll_type,
                                 short position,
                                 HWND scrollbar) {
-  message_handler_->OnVScroll(scroll_type, position, scrollbar);
+  SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnWindowPosChanging(WINDOWPOS* window_pos) {
   if (ignore_window_pos_changes_) {
     // If somebody's trying to toggle our visibility, change the nonclient area,
     // change our Z-order, or activate us, we should probably let it go through.
     if (!(window_pos->flags & ((IsVisible() ? SWP_HIDEWINDOW : SWP_SHOWWINDOW) |
         SWP_FRAMECHANGED)) &&
         (window_pos->flags & (SWP_NOZORDER | SWP_NOACTIVATE))) {
       // Just sizing/moving the window; ignore.
@@ skipping 185 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();
 }
 
 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() &&
@@ skipping 35 matching lines @@
 }
 
 void NativeWidgetWin::HandleBeginWMSizeMove() {
   delegate_->OnNativeWidgetBeginUserBoundsChange();
 }
 
 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 194 matching lines @@
   if (use_layered_buffer_)
     layered_window_contents_.reset(
         new gfx::Canvas(s, ui::SCALE_FACTOR_100P, false));
 }
 
 void NativeWidgetWin::UpdateDWMFrame() {
   MARGINS m = {10, 10, 10, 10};
   DwmExtendFrameIntoClientArea(GetNativeView(), &m);
 }
 
+void NativeWidgetWin::ResetWindowRegion(bool force) {
+  // A native frame uses the native window region, and we don't want to mess
+  // with it.
+  if (GetWidget()->ShouldUseNativeFrame() || !GetWidget()->non_client_view()) {
+    if (force)
+      SetWindowRgn(NULL, TRUE);
+    return;
+  }
+
+  // Changing the window region is going to force a paint. Only change the
+  // window region if the region really differs.
+  HRGN current_rgn = CreateRectRgn(0, 0, 0, 0);
+  int current_rgn_result = GetWindowRgn(GetNativeView(), current_rgn);
+
+  CRect window_rect;
+  GetWindowRect(&window_rect);
+  HRGN new_region;
+  if (IsMaximized()) {
+    HMONITOR monitor =
+        MonitorFromWindow(GetNativeView(), MONITOR_DEFAULTTONEAREST);
+    MONITORINFO mi;
+    mi.cbSize = sizeof mi;
+    GetMonitorInfo(monitor, &mi);
+    CRect work_rect = mi.rcWork;
+    work_rect.OffsetRect(-window_rect.left, -window_rect.top);
+    new_region = CreateRectRgnIndirect(&work_rect);
+  } else {
+    gfx::Path window_mask;
+    GetWidget()->non_client_view()->GetWindowMask(
+        gfx::Size(window_rect.Width(), window_rect.Height()), &window_mask);
+    new_region = window_mask.CreateNativeRegion();
+  }
+
+  if (current_rgn_result == ERROR || !EqualRgn(current_rgn, new_region)) {
+    // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
+    SetWindowRgn(new_region, TRUE);
+  } else {
+    DeleteObject(new_region);
+  }
+
+  DeleteObject(current_rgn);
+}
+
 LRESULT NativeWidgetWin::DefWindowProcWithRedrawLock(UINT message,
                                                      WPARAM w_param,
                                                      LPARAM l_param) {
   ScopedRedrawLock lock(this);
   // The Widget and HWND can be destroyed in the call to DefWindowProc, so use
   // the |destroyed_| flag to avoid unlocking (and crashing) after destruction.
   bool destroyed = false;
   destroyed_ = &destroyed;
   LRESULT result = DefWindowProc(GetNativeView(), message, w_param, l_param);
   if (destroyed)
@@ skipping 192 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