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 343 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),
@@ skipping 541 matching lines @@
   // 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);
 
+  fullscreen_handler_->set_hwnd(hwnd());
+
   // 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 11 matching lines @@
   GetSystemMenu(hwnd(), false);
 
   if (base::win::GetVersion() >= base::win::VERSION_WIN7)
     RegisterTouchWindow(hwnd(), 0);
 
   // 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();
 
+  // 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);
+
   delegate_->HandleCreate();
 
   // TODO(beng): move more of NWW::OnCreate here.
   return 0;
 }
 
 void HWNDMessageHandler::OnDestroy() {
   delegate_->HandleDestroying();
 }
 
@@ skipping 36 matching lines @@
   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 820 matching lines @@
   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_->PreHandleMSG(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)) {
     result = DefWindowProc(window, message, w_param, l_param);
   }
-  if (message == WM_NCDESTROY)
+  delegate_->PostHandleMSG(message, w_param, l_param);
+  if (message == WM_NCDESTROY) {
+    MessageLoopForUI::current()->RemoveObserver(this);
     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, MessageLoopForUI::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 119 matching lines @@
                       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