Make HWNDMessageHandler subclass WindowImpl.

ui/views/win/hwnd_message_handler.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/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "ui/gfx/canvas_skia_paint.h"
 #include "ui/gfx/icon_util.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/accessibility/native_view_accessibility_win.h"
 #include "ui/views/ime/input_method_win.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/child_window_message_processor.h"
 #include "ui/views/widget/monitor_win.h"
-#include "ui/views/widget/native_widget_win.h"
 #include "ui/views/widget/widget_hwnd_utils.h"
 #include "ui/views/win/fullscreen_handler.h"
 #include "ui/views/win/hwnd_message_handler_delegate.h"
 #include "ui/views/win/scoped_fullscreen_visibility.h"
 
 #if !defined(USE_AURA)
 #include "base/command_line.h"
 #include "ui/base/ui_base_switches.h"
 #endif
 
@@ skipping 312 matching lines @@
   bool force_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedRedrawLock);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // HWNDMessageHandler, public:
 
 HWNDMessageHandler::HWNDMessageHandler(HWNDMessageHandlerDelegate* delegate)
     : delegate_(delegate),
-      ALLOW_THIS_IN_INITIALIZER_LIST(fullscreen_handler_(new FullscreenHandler(
-          delegate->AsNativeWidgetWin()->GetWidget()))),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+        fullscreen_handler_(new FullscreenHandler)),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       remove_standard_frame_(false),
       restore_focus_when_enabled_(false),
       restored_enabled_(false),
       previous_cursor_(NULL),
       active_mouse_tracking_flags_(0),
       is_right_mouse_pressed_on_caption_(false),
       lock_updates_count_(0),
       destroyed_(NULL),
       ignore_window_pos_changes_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ignore_pos_changes_factory_(this)),
       last_monitor_(NULL),
       use_layered_buffer_(false),
       layered_alpha_(255),
       ALLOW_THIS_IN_INITIALIZER_LIST(paint_layered_window_factory_(this)),
       can_update_layered_window_(true) {
 }
 
 HWNDMessageHandler::~HWNDMessageHandler() {
   if (destroyed_ != NULL)
     *destroyed_ = true;
 }
 
-void HWNDMessageHandler::Init(const gfx::Rect& bounds) {
+void HWNDMessageHandler::Init(HWND parent, const gfx::Rect& bounds) {
   GetMonitorAndRects(bounds.ToRECT(), &last_monitor_, &last_monitor_rect_,
                      &last_work_area_);
+  // Create the window.
+  WindowImpl::Init(parent, bounds);
+  fullscreen_handler_->set_hwnd(hwnd());
+
+  // We need to add ourselves as a message loop observer so that we can repaint
+  // aggressively if the contents of our window become invalid. Unfortunately
+  // WM_PAINT messages are starved and we get flickery redrawing when resizing
+  // if we do not do this.
+  MessageLoopForUI::current()->AddObserver(this);
 }
 
 void HWNDMessageHandler::InitModalType(ui::ModalType modal_type) {
   if (modal_type == ui::MODAL_TYPE_NONE)
     return;
   // We implement modality by crawling up the hierarchy of windows starting
   // at the owner, disabling all of them so that they don't receive input
   // messages.
   HWND start = ::GetWindow(hwnd(), GW_OWNER);
   while (start) {
@@ skipping 512 matching lines @@
 void HWNDMessageHandler::OnCommand(UINT notification_code,
                                    int command,
                                    HWND window) {
   // If the notification code is > 1 it means it is control specific and we
   // should ignore it.
   if (notification_code > 1 || delegate_->HandleAppCommand(command))
     SetMsgHandled(FALSE);
 }
 
 LRESULT HWNDMessageHandler::OnCreate(CREATESTRUCT* create_struct) {
-  use_layered_buffer_ = !!(delegate_->AsNativeWidgetWin()->
-      window_ex_style() & WS_EX_LAYERED);
+  use_layered_buffer_ = !!(window_ex_style() & WS_EX_LAYERED);
 
   // Attempt to detect screen readers by sending an event with our custom id.
   NotifyWinEvent(EVENT_SYSTEM_ALERT, hwnd(), kCustomObjectID, CHILDID_SELF);
 
   // This message initializes the window so that focus border are shown for
   // windows.
   SendMessage(hwnd(),
               WM_CHANGEUISTATE,
               MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS),
               0);
@@ skipping 39 matching lines @@
                                                     LPARAM l_param) {
   if (!delegate_->IsWidgetWindow()) {
     SetMsgHandled(FALSE);
     return 0;
   }
   delegate_->HandleGlassModeChange();
   return 0;
 }
 
 void HWNDMessageHandler::OnEndSession(BOOL ending, UINT logoff) {
+  delegate_->HandleEndSession();
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnEnterSizeMove() {
   delegate_->HandleBeginWMSizeMove();
   SetMsgHandled(FALSE);
 }
 
 LRESULT HWNDMessageHandler::OnEraseBkgnd(HDC dc) {
   // Needed to prevent resize flicker.
   return 1;
 }
 
 void HWNDMessageHandler::OnExitMenuLoop(BOOL is_track_popup_menu) {
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnExitSizeMove() {
   delegate_->HandleEndWMSizeMove();
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
   gfx::Size min_window_size;
   gfx::Size max_window_size;
   delegate_->GetMinMaxSize(&min_window_size, &max_window_size);
 
   // Add the native frame border size to the minimum and maximum size if the
   // view reports its size as the client size.
-  if (delegate_->AsNativeWidgetWin()->WidgetSizeIsClientSize()) {
+  if (delegate_->WidgetSizeIsClientSize()) {
     CRect client_rect, window_rect;
     GetClientRect(hwnd(), &client_rect);
     GetWindowRect(hwnd(), &window_rect);
     window_rect -= client_rect;
     min_window_size.Enlarge(window_rect.Width(), window_rect.Height());
     if (!max_window_size.IsEmpty())
       max_window_size.Enlarge(window_rect.Width(), window_rect.Height());
   }
   minmax_info->ptMinTrackSize.x = min_window_size.width();
   minmax_info->ptMinTrackSize.y = min_window_size.height();
@@ skipping 67 matching lines @@
   ScopedRedrawLock lock(this);
   EnableMenuItemByCommand(menu, SC_RESTORE, is_minimized || is_maximized);
   EnableMenuItemByCommand(menu, SC_MOVE, is_restored);
   EnableMenuItemByCommand(menu, SC_SIZE, delegate_->CanResize() && is_restored);
   EnableMenuItemByCommand(menu, SC_MAXIMIZE, delegate_->CanMaximize() &&
                           !is_fullscreen && !is_maximized);
   EnableMenuItemByCommand(menu, SC_MINIMIZE, delegate_->CanMaximize() &&
                           !is_minimized);
 }
 
-void HWNDMessageHandler::OnInitMenuPopup() {
+void HWNDMessageHandler::OnInitMenuPopup(HMENU menu,
+                                         UINT position,
+                                         BOOL is_system_menu) {
+  delegate_->HandleInitMenuPopup();
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnInputLangChange(DWORD character_set,
                                            HKL input_language_id) {
   InputMethod* input_method = delegate_->GetInputMethod();
   if (input_method && !input_method->IsMock()) {
     static_cast<InputMethodWin*>(input_method)->OnInputLangChange(
         character_set, input_language_id);
   }
@@ skipping 17 matching lines @@
 
   InputMethod* input_method = delegate_->GetInputMethod();
   if (input_method)
     input_method->OnBlur();
   SetMsgHandled(FALSE);
 }
 
 LRESULT HWNDMessageHandler::OnMouseActivate(UINT message,
                                             WPARAM w_param,
                                             LPARAM l_param) {
+  delegate_->HandleMouseActivate(LOWORD(l_param));
   // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
   //             line.
   if (delegate_->IsWidgetWindow())
     return delegate_->CanActivate() ? MA_ACTIVATE : MA_NOACTIVATEANDEAT;
   if (GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_NOACTIVATE)
     return MA_NOACTIVATE;
   SetMsgHandled(FALSE);
   return MA_ACTIVATE;
 }
 
@@ skipping 610 matching lines @@
         reinterpret_cast<LPARAM>(window_pos));
     window_pos->cy = old_cy;
     SetMsgHandled(TRUE);
     return;
   }
 
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnWindowPosChanged(WINDOWPOS* window_pos) {
+
   if (DidClientAreaSizeChange(window_pos))
     ClientAreaSizeChanged();
-  if (remove_standard_frame_ && window_pos->flags & SWP_FRAMECHANGED &&
-      ui::win::IsAeroGlassEnabled()) {
-    MARGINS m = {10, 10, 10, 10};
-    DwmExtendFrameIntoClientArea(hwnd(), &m);
+  if (window_pos->flags & SWP_FRAMECHANGED) {
+    delegate_->HandleFrameChanged();
+    if (remove_standard_frame_ && ui::win::IsAeroGlassEnabled()) {
+      delegate_->HandleFrameChanged();
+      MARGINS m = {10, 10, 10, 10};
+      DwmExtendFrameIntoClientArea(hwnd(), &m);
+    }
   }
   if (window_pos->flags & SWP_SHOWWINDOW)
     delegate_->HandleVisibilityChanged(true);
   else if (window_pos->flags & SWP_HIDEWINDOW)
     delegate_->HandleVisibilityChanged(false);
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::ResetWindowRegion(bool force) {
   // A native frame uses the native window region, and we don't want to mess
@@ skipping 30 matching lines @@
   if (current_rgn_result == ERROR || !EqualRgn(current_rgn, new_region)) {
     // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
     SetWindowRgn(hwnd(), new_region, TRUE);
   } else {
     DeleteObject(new_region);
   }
 
   DeleteObject(current_rgn);
 }
 
-HWND HWNDMessageHandler::hwnd() {
-  return delegate_->AsNativeWidgetWin()->hwnd();
-}
-
-HWND HWNDMessageHandler::hwnd() const {
-  return delegate_->AsNativeWidgetWin()->hwnd();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // HWNDMessageHandler, InputMethodDelegate implementation:
 
 void HWNDMessageHandler::DispatchKeyEventPostIME(const ui::KeyEvent& key) {
   SetMsgHandled(delegate_->HandleKeyEvent(key));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HWNDMessageHandler, ui::WindowImpl overrides:
 
 HICON HWNDMessageHandler::GetDefaultWindowIcon() const {
   return ViewsDelegate::views_delegate ?
       ViewsDelegate::views_delegate->GetDefaultWindowIcon() : NULL;
 }
 
 LRESULT HWNDMessageHandler::OnWndProc(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   HWND window = hwnd();
   LRESULT result = 0;
 
+  if (delegate_->HandleMSG(message, w_param, l_param, &result))
+    return result;
+
   // 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 NativeWidgetWin.
   if (ProcessChildWindowMessage(message, w_param, l_param, &result))
     return result;
 
   // Otherwise we handle everything else.
-  if (!delegate_->AsNativeWidgetWin()->ProcessWindowMessage(
-      window, message, w_param, l_param, result)) {
+  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);
+    delegate_->HandleDestroyed();
   }
-  if (message == WM_NCDESTROY)
-    delegate_->HandleDestroyed();
 
   // Only top level widget should store/restore focus.
   if (message == WM_ACTIVATE && delegate_->CanSaveFocus())
     PostProcessActivateMessage(LOWORD(w_param));
   if (message == WM_ENABLE && restore_focus_when_enabled_) {
     // This path should be executed only for top level as
     // restore_focus_when_enabled_ is set in PostProcessActivateMessage.
     DCHECK(delegate_->CanSaveFocus());
     restore_focus_when_enabled_ = false;
     delegate_->RestoreFocusOnEnable();
   }
   return result;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// HWNDMessageHandler, MessageLoop::Observer implementation:
+
+base::EventStatus HWNDMessageHandler::WillProcessEvent(
+    const base::NativeEvent& event) {
+  return base::EVENT_CONTINUE;
+}
+
+void HWNDMessageHandler::DidProcessEvent(const base::NativeEvent& event) {
+  RedrawInvalidRect();
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // HWNDMessageHandler, private:
 
 void HWNDMessageHandler::SetInitialFocus() {
   if (!(GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_TRANSPARENT) &&
       !(GetWindowLong(hwnd(), GWL_EXSTYLE) & WS_EX_NOACTIVATE)) {
     // The window does not get keyboard messages unless we focus it.
     SetFocus(hwnd());
   }
@@ skipping 61 matching lines @@
     tme.dwHoverTime = 0;
     TrackMouseEvent(&tme);
   } else if (mouse_tracking_flags != active_mouse_tracking_flags_) {
     TrackMouseEvents(active_mouse_tracking_flags_ | TME_CANCEL);
     TrackMouseEvents(mouse_tracking_flags);
   }
 }
 
 void HWNDMessageHandler::ClientAreaSizeChanged() {
   RECT r = {0, 0, 0, 0};
-  if (delegate_->AsNativeWidgetWin()->WidgetSizeIsClientSize()) {
+  if (delegate_->WidgetSizeIsClientSize()) {
     // TODO(beng): investigate whether this could be done
     // from other branch of if-else.
     if (!IsMinimized())
       GetClientRect(hwnd(), &r);
   } else {
     GetWindowRect(hwnd(), &r);
   }
   gfx::Size s(std::max(0, static_cast<int>(r.right - r.left)),
               std::max(0, static_cast<int>(r.bottom - r.top)));
   delegate_->HandleClientSizeChanged(s);
@@ skipping 114 matching lines @@
   POINT position = {wr.left, wr.top};
   HDC dib_dc = skia::BeginPlatformPaint(layered_window_contents_->sk_canvas());
   POINT zero = {0, 0};
   BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA};
   UpdateLayeredWindow(hwnd(), NULL, &position, &size, dib_dc, &zero,
                       RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA);
   invalid_rect_.SetRect(0, 0, 0, 0);
   skia::EndPlatformPaint(layered_window_contents_->sk_canvas());
 }
 
-void HWNDMessageHandler::SetMsgHandled(BOOL handled) {
-  delegate_->AsNativeWidgetWin()->SetMsgHandled(handled);
-}
-
 }  // namespace views