Make HWNDMessageHandler subclass WindowImpl.

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 129 matching lines @@
     if (*it == view)
       *it = NULL;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, NativeWidget implementation:
 
 void NativeWidgetWin::InitNativeWidget(const Widget::InitParams& params) {
   SetInitParams(params);
-
-  message_handler_->Init(params.bounds);
-
-  // Create the window.
-  WindowImpl::Init(params.GetParent(), params.bounds);
+  message_handler_->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);
 }
 
 bool NativeWidgetWin::ShouldUseNativeFrame() const {
   return ui::win::IsAeroGlassEnabled();
 }
 
 void NativeWidgetWin::FrameTypeChanged() {
   message_handler_->FrameTypeChanged();
 }
 
 Widget* NativeWidgetWin::GetWidget() {
   return delegate_->AsWidget();
 }
 
 const Widget* NativeWidgetWin::GetWidget() const {
   return delegate_->AsWidget();
 }
 
 gfx::NativeView NativeWidgetWin::GetNativeView() const {
-  return WindowImpl::hwnd();
+  return message_handler_->hwnd();
 }
 
 gfx::NativeWindow NativeWidgetWin::GetNativeWindow() const {
-  return WindowImpl::hwnd();
+  return message_handler_->hwnd();
 }
 
 Widget* NativeWidgetWin::GetTopLevelWidget() {
   NativeWidgetPrivate* native_widget = GetTopLevelNativeWidget(GetNativeView());
   return native_widget ? native_widget->GetWidget() : NULL;
 }
 
 const ui::Compositor* NativeWidgetWin::GetCompositor() const {
   return NULL;
 }
@@ skipping 17 matching lines @@
 void NativeWidgetWin::SetNativeWindowProperty(const char* name, void* value) {
   // Remove the existing property (if any).
   for (ViewProps::iterator i = props_.begin(); i != props_.end(); ++i) {
     if ((*i)->Key() == name) {
       props_.erase(i);
       break;
     }
   }
 
   if (value)
-    props_.push_back(new ViewProp(hwnd(), name, value));
+    props_.push_back(new ViewProp(GetNativeView(), name, value));
 }
 
 void* NativeWidgetWin::GetNativeWindowProperty(const char* name) const {
-  return ViewProp::GetValue(hwnd(), name);
+  return ViewProp::GetValue(GetNativeView(), name);
 }
 
 TooltipManager* NativeWidgetWin::GetTooltipManager() const {
   return tooltip_manager_.get();
 }
 
 bool NativeWidgetWin::IsScreenReaderActive() const {
   return screen_reader_active_;
 }
 
@@ skipping 181 matching lines @@
 }
 
 void NativeWidgetWin::SetOpacity(unsigned char opacity) {
   message_handler_->SetOpacity(static_cast<BYTE>(opacity));
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
 void NativeWidgetWin::SetUseDragFrame(bool use_drag_frame) {
   if (use_drag_frame) {
     // Make the frame slightly transparent during the drag operation.
-    drag_frame_saved_window_style_ = GetWindowLong(GWL_STYLE);
-    drag_frame_saved_window_ex_style_ = GetWindowLong(GWL_EXSTYLE);
-    SetWindowLong(GWL_EXSTYLE,
+    drag_frame_saved_window_style_ = GetWindowLong(GetNativeView(), GWL_STYLE);
+    drag_frame_saved_window_ex_style_ =
+        GetWindowLong(GetNativeView(), GWL_EXSTYLE);
+    SetWindowLong(GetNativeView(), GWL_EXSTYLE,
                   drag_frame_saved_window_ex_style_ | WS_EX_LAYERED);
     // Remove the captions tyle so the window doesn't have window controls for a
     // more "transparent" look.
-    SetWindowLong(GWL_STYLE, drag_frame_saved_window_style_ & ~WS_CAPTION);
+    SetWindowLong(GetNativeView(), GWL_STYLE,
+                  drag_frame_saved_window_style_ & ~WS_CAPTION);
     SetLayeredWindowAttributes(GetNativeWindow(), RGB(0xFF, 0xFF, 0xFF),
                                kDragFrameWindowAlpha, LWA_ALPHA);
   } else {
-    SetWindowLong(GWL_STYLE, drag_frame_saved_window_style_);
-    SetWindowLong(GWL_EXSTYLE, drag_frame_saved_window_ex_style_);
+    SetWindowLong(GetNativeView(), GWL_STYLE, drag_frame_saved_window_style_);
+    SetWindowLong(GetNativeView(), GWL_EXSTYLE,
+                  drag_frame_saved_window_ex_style_);
   }
 }
 
 void NativeWidgetWin::FlashFrame(bool flash) {
   message_handler_->FlashFrame(flash);
 }
 
 bool NativeWidgetWin::IsAccessibleWidget() const {
   return screen_reader_active_;
 }
@@ skipping 36 matching lines @@
 
 void NativeWidgetWin::EndMoveLoop() {
   message_handler_->EndMoveLoop();
 }
 
 void NativeWidgetWin::SetVisibilityChangedAnimationsEnabled(bool value) {
   message_handler_->SetVisibilityChangedAnimationsEnabled(value);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetWin, MessageLoop::Observer implementation:
-
-base::EventStatus NativeWidgetWin::WillProcessEvent(
-    const base::NativeEvent& event) {
-  return base::EVENT_CONTINUE;
-}
-
-void NativeWidgetWin::DidProcessEvent(const base::NativeEvent& event) {
-  message_handler_->RedrawInvalidRect();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetWin, WindowImpl overrides:
-
-HICON NativeWidgetWin::GetDefaultWindowIcon() const {
-  return message_handler_->GetDefaultWindowIcon();
-}
-
-LRESULT NativeWidgetWin::OnWndProc(UINT message,
-                                   WPARAM w_param,
-                                   LPARAM l_param) {
-  return message_handler_->OnWndProc(message, w_param, l_param);
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
-// Message handlers ------------------------------------------------------------
-
-void NativeWidgetWin::OnActivate(UINT action, BOOL minimized, HWND window) {
-  message_handler_->OnActivate(action, minimized, window);
-}
-
-void NativeWidgetWin::OnActivateApp(BOOL active, DWORD thread_id) {
-  message_handler_->OnActivateApp(active, thread_id);
-}
-
-LRESULT NativeWidgetWin::OnAppCommand(HWND window,
-                                      short app_command,
-                                      WORD device,
-                                      int keystate) {
-  return message_handler_->OnAppCommand(window, app_command, device, keystate);
-}
-
-void NativeWidgetWin::OnCancelMode() {
-  message_handler_->OnCancelMode();
-}
-
-void NativeWidgetWin::OnCaptureChanged(HWND hwnd) {
-  message_handler_->OnCaptureChanged(hwnd);
-}
-
-void NativeWidgetWin::OnClose() {
-  message_handler_->OnClose();
-}
-
-void NativeWidgetWin::OnCommand(UINT notification_code,
-                                int command_id,
-                                HWND window) {
-  message_handler_->OnCommand(notification_code, command_id, window);
-}
-
-LRESULT NativeWidgetWin::OnCreate(CREATESTRUCT* create_struct) {
-  return message_handler_->OnCreate(create_struct);
-}
-
-void NativeWidgetWin::OnDestroy() {
-  message_handler_->OnDestroy();
-}
-
-void NativeWidgetWin::OnDisplayChange(UINT bits_per_pixel, CSize screen_size) {
-  message_handler_->OnDisplayChange(bits_per_pixel, screen_size);
-}
-
-LRESULT NativeWidgetWin::OnDwmCompositionChanged(UINT msg,
-                                                 WPARAM w_param,
-                                                 LPARAM l_param) {
-  return message_handler_->OnDwmCompositionChanged(msg, w_param, l_param);
-}
-
-void NativeWidgetWin::OnEndSession(BOOL ending, UINT logoff) {
-  message_handler_->OnEndSession(ending, logoff);
-}
-
-void NativeWidgetWin::OnEnterSizeMove() {
-  message_handler_->OnEnterSizeMove();
-}
-
-LRESULT NativeWidgetWin::OnEraseBkgnd(HDC dc) {
-  return message_handler_->OnEraseBkgnd(dc);
-}
-
-void NativeWidgetWin::OnExitMenuLoop(BOOL is_track_popup_menu) {
-  message_handler_->OnExitMenuLoop(is_track_popup_menu);
-}
-
-void NativeWidgetWin::OnExitSizeMove() {
-  message_handler_->OnExitSizeMove();
-}
-
-LRESULT NativeWidgetWin::OnGetObject(UINT message,
-                                     WPARAM w_param,
-                                     LPARAM l_param) {
-  return message_handler_->OnGetObject(message, w_param, l_param);
-}
-
-void NativeWidgetWin::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
-  message_handler_->OnGetMinMaxInfo(minmax_info);
-}
-
-void NativeWidgetWin::OnHScroll(int scroll_type,
-                                short position,
-                                HWND scrollbar) {
-  message_handler_->OnHScroll(scroll_type, position, scrollbar);
-}
-
-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) {
-  message_handler_->OnInitMenu(menu);
-}
-
-void NativeWidgetWin::OnInitMenuPopup(HMENU menu,
-                                      UINT position,
-                                      BOOL is_system_menu) {
-  message_handler_->OnInitMenuPopup();
-}
-
-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) {
-  return message_handler_->OnKeyEvent(message, w_param, l_param);
-}
-
-void NativeWidgetWin::OnKillFocus(HWND focused_window) {
-  message_handler_->OnKillFocus(focused_window);
-}
-
-LRESULT NativeWidgetWin::OnMouseActivate(UINT message,
-                                         WPARAM w_param,
-                                         LPARAM l_param) {
-  return message_handler_->OnMouseActivate(message, w_param, l_param);
-}
-
-LRESULT NativeWidgetWin::OnMouseRange(UINT message,
-                                      WPARAM w_param,
-                                      LPARAM l_param) {
-  return message_handler_->OnMouseRange(message, w_param, l_param);
-}
-
-void NativeWidgetWin::OnMove(const CPoint& point) {
-  message_handler_->OnMove(point);
-}
-
-void NativeWidgetWin::OnMoving(UINT param, const LPRECT new_bounds) {
-  message_handler_->OnMoving(param, new_bounds);
-}
-
-LRESULT NativeWidgetWin::OnNCActivate(BOOL active) {
-  return message_handler_->OnNCActivate(active);
-}
-
-LRESULT NativeWidgetWin::OnNCCalcSize(BOOL mode, LPARAM l_param) {
-  return message_handler_->OnNCCalcSize(mode, l_param);
-}
-
-LRESULT NativeWidgetWin::OnNCHitTest(const CPoint& point) {
-  return message_handler_->OnNCHitTest(point);
-}
-
-void NativeWidgetWin::OnNCPaint(HRGN rgn) {
-  message_handler_->OnNCPaint(rgn);
-}
-
-LRESULT NativeWidgetWin::OnNCUAHDrawCaption(UINT msg,
-                                            WPARAM w_param,
-                                            LPARAM l_param) {
-  return message_handler_->OnNCUAHDrawCaption(msg, w_param, l_param);
-}
-
-LRESULT NativeWidgetWin::OnNCUAHDrawFrame(UINT msg,
-                                          WPARAM w_param,
-                                          LPARAM l_param) {
-  return message_handler_->OnNCUAHDrawFrame(msg, w_param, l_param);
-}
-
-LRESULT NativeWidgetWin::OnNotify(int w_param, NMHDR* l_param) {
-  return message_handler_->OnNotify(w_param, l_param);
-}
-
-void NativeWidgetWin::OnPaint(HDC dc) {
-  message_handler_->OnPaint(dc);
-}
-
-LRESULT NativeWidgetWin::OnPowerBroadcast(DWORD power_event, DWORD data) {
-  return message_handler_->OnPowerBroadcast(power_event, data);
-}
-
-LRESULT NativeWidgetWin::OnReflectedMessage(UINT msg,
-                                            WPARAM w_param,
-                                            LPARAM l_param) {
-  return message_handler_->OnReflectedMessage(msg, w_param, l_param);
-}
-
-LRESULT NativeWidgetWin::OnSetCursor(UINT message,
-                                     WPARAM w_param,
-                                     LPARAM l_param) {
-  return message_handler_->OnSetCursor(message, w_param, l_param);
-}
-
-void NativeWidgetWin::OnSetFocus(HWND old_focused_window) {
-  message_handler_->OnSetFocus(old_focused_window);
-}
-
-LRESULT NativeWidgetWin::OnSetIcon(UINT size_type, HICON new_icon) {
-  return message_handler_->OnSetIcon(size_type, new_icon);
-}
-
-LRESULT NativeWidgetWin::OnSetText(const wchar_t* text) {
-  return message_handler_->OnSetText(text);
-}
-
-void NativeWidgetWin::OnSettingChange(UINT flags, const wchar_t* section) {
-  message_handler_->OnSettingChange(flags, section);
-}
-
-void NativeWidgetWin::OnSize(UINT param, const CSize& size) {
-  message_handler_->OnSize(param, size);
-}
-
-void NativeWidgetWin::OnSysCommand(UINT notification_code, CPoint click) {
-  message_handler_->OnSysCommand(notification_code, click);
-}
-
-void NativeWidgetWin::OnThemeChanged() {
-  message_handler_->OnThemeChanged();
-}
-
-LRESULT NativeWidgetWin::OnTouchEvent(UINT message,
-                                      WPARAM w_param,
-                                      LPARAM l_param) {
-  return message_handler_->OnTouchEvent(message, w_param, l_param);
-}
-
-void NativeWidgetWin::OnVScroll(int scroll_type,
-                                short position,
-                                HWND scrollbar) {
-  message_handler_->OnVScroll(scroll_type, position, scrollbar);
-}
-
-void NativeWidgetWin::OnWindowPosChanging(WINDOWPOS* window_pos) {
-  message_handler_->OnWindowPosChanging(window_pos);
-}
-
-void NativeWidgetWin::OnWindowPosChanged(WINDOWPOS* window_pos) {
-  message_handler_->OnWindowPosChanged(window_pos);
-}
-
 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:
 
 void NativeWidgetWin::OnScreenReaderDetected() {
   screen_reader_active_ = true;
 }
 
+HWNDMessageHandler* NativeWidgetWin::GetMessageHandler() {
+  return message_handler_.get();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, HWNDMessageHandlerDelegate implementation:
 
 bool NativeWidgetWin::IsWidgetWindow() const {
   // We don't NULL check GetWidget()->non_client_view() here because this
   // function can be called before the widget is fully constructed.
   return has_non_client_view_;
 }
 
 bool NativeWidgetWin::IsUsingCustomFrame() const {
@@ skipping 17 matching lines @@
 }
 
 bool NativeWidgetWin::CanMaximize() const {
   return GetWidget()->widget_delegate()->CanMaximize();
 }
 
 bool NativeWidgetWin::CanActivate() const {
   return delegate_->CanActivate();
 }
 
+bool NativeWidgetWin::WidgetSizeIsClientSize() const {
+  const Widget* widget = GetWidget()->GetTopLevelWidget();
+  return IsMaximized() || (widget && widget->ShouldUseNativeFrame());
+}
+
 bool NativeWidgetWin::CanSaveFocus() const {
   return GetWidget()->is_top_level();
 }
 
 void NativeWidgetWin::SaveFocusOnDeactivate() {
   GetWidget()->GetFocusManager()->StoreFocusedView();
 }
 
 void NativeWidgetWin::RestoreFocusOnActivate() {
   // Mysteriously, this only appears to be needed support restoration of focus
@@ skipping 71 matching lines @@
 void NativeWidgetWin::HandleAppDeactivated() {
   // Another application was activated, we should reset any state that
   // disables inactive rendering now.
   delegate_->EnableInactiveRendering();
 }
 
 void NativeWidgetWin::HandleActivationChanged(bool active) {
   delegate_->OnNativeWidgetActivationChanged(active);
 }
 
+void NativeWidgetWin::HandleMouseActivate(int hittest_code) {
+}
+
 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::HandleAccelerator(const ui::Accelerator& accelerator) {
   GetWidget()->GetFocusManager()->ProcessAccelerator(accelerator);
 }
 
 void NativeWidgetWin::HandleCreate() {
   // TODO(beng): much of this could/should maybe move to HWNDMessageHandler.
 
   SetNativeWindowProperty(kNativeWidgetKey, this);
-  CHECK_EQ(this, GetNativeWidgetForNativeView(hwnd()));
+  CHECK_EQ(this, GetNativeWidgetForNativeView(GetNativeView()));
 
-  props_.push_back(ui::SetWindowSupportsRerouteMouseWheel(hwnd()));
+  props_.push_back(ui::SetWindowSupportsRerouteMouseWheel(GetNativeView()));
 
   drop_target_ = new DropTargetWin(
       static_cast<internal::RootView*>(GetWidget()->GetRootView()));
 
-  // 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);
-
   // Windows special DWM window frame requires a special tooltip manager so
   // that window controls in Chrome windows don't flicker when you move your
   // mouse over them. See comment in aero_tooltip_manager.h.
   Widget* widget = GetWidget()->GetTopLevelWidget();
   if (widget && widget->ShouldUseNativeFrame()) {
     tooltip_manager_.reset(new AeroTooltipManager(GetWidget()));
   } else {
     tooltip_manager_.reset(new TooltipManagerWin(GetWidget()));
   }
   if (!tooltip_manager_->Init()) {
     // There was a problem creating the TooltipManager. Common error is 127.
     // See 82193 for details.
     LOG_GETLASTERROR(WARNING) << "tooltip creation failed, disabling tooltips";
     tooltip_manager_.reset();
   }
 
   delegate_->OnNativeWidgetCreated();
 }
 
 void NativeWidgetWin::HandleDestroying() {
   delegate_->OnNativeWidgetDestroying();
   if (drop_target_.get()) {
-    RevokeDragDrop(hwnd());
+    RevokeDragDrop(GetNativeView());
     drop_target_ = NULL;
   }
 }
 
 void NativeWidgetWin::HandleDestroyed() {
-  MessageLoopForUI::current()->RemoveObserver(this);
-  OnFinalMessage(hwnd());
+  OnFinalMessage(GetNativeView());
 }
 
 bool NativeWidgetWin::HandleInitialFocus() {
   return GetWidget()->SetInitialFocus();
 }
 
 void NativeWidgetWin::HandleDisplayChange() {
   GetWidget()->widget_delegate()->OnDisplayChanged();
 }
 
@@ skipping 74 matching lines @@
   return false;
 }
 
 void NativeWidgetWin::HandleTooltipMouseMove(UINT message,
                                              WPARAM w_param,
                                              LPARAM l_param) {
   if (tooltip_manager_.get())
     tooltip_manager_->OnMouse(message, w_param, l_param);
 }
 
-NativeWidgetWin* NativeWidgetWin::AsNativeWidgetWin() {
-  return this;
+void NativeWidgetWin::HandleEndSession() {
+}
+
+void NativeWidgetWin::HandleInitMenuPopup() {
+}
+
+void NativeWidgetWin::HandleFrameChanged() {
+}
+
+bool NativeWidgetWin::HandleMSG(UINT message,
+                                WPARAM w_param,
+                                LPARAM l_param,
+                                LRESULT* result) {
+  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, private:
 
 void NativeWidgetWin::SetInitParams(const Widget::InitParams& params) {
   // Set non-style attributes.
   ownership_ = params.ownership;
 
   DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
@@ skipping 66 matching lines @@
       style |= WS_POPUP;
       ex_style |= WS_EX_TOOLWINDOW;
       break;
     case Widget::InitParams::TYPE_MENU:
       style |= WS_POPUP;
       break;
     default:
       NOTREACHED();
   }
 
-  set_initial_class_style(class_style);
-  set_window_style(window_style() | style);
-  set_window_ex_style(window_ex_style() | ex_style);
+  message_handler_->set_initial_class_style(class_style);
+  message_handler_->set_window_style(
+      message_handler_->window_style() | style);
+  message_handler_->set_window_ex_style(
+      message_handler_->window_ex_style() | ex_style);
 
   has_non_client_view_ = Widget::RequiresNonClientView(params.type);
   message_handler_->set_remove_standard_frame(params.remove_standard_frame);
 }
 
-bool NativeWidgetWin::WidgetSizeIsClientSize() const {
-  const Widget* widget = GetWidget()->GetTopLevelWidget();
-  return IsZoomed() || (widget && widget->ShouldUseNativeFrame());
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 void Widget::NotifyLocaleChanged() {
   NOTIMPLEMENTED();
 }
 
 namespace {
 BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
@@ skipping 150 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