Make HWNDMessageHandler subclass WindowImpl.

chrome/browser/ui/views/frame/browser_frame_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 "chrome/browser/ui/views/frame/browser_frame_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 #include <set>
 
@@ skipping 177 matching lines @@
   return true;
 }
 
 void BrowserFrameWin::UpdateFrameAfterFrameChange() {
   // We need to update the glass region on or off before the base class adjusts
   // the window region.
   UpdateDWMFrame();
   NativeWidgetWin::UpdateFrameAfterFrameChange();
 }
 
-void BrowserFrameWin::OnEndSession(BOOL ending, UINT logoff) {
+void BrowserFrameWin::HandleEndSession() {
   browser::SessionEnding();
 }
 
-void BrowserFrameWin::OnInitMenuPopup(HMENU menu, UINT position,
-                                      BOOL is_system_menu) {
+void BrowserFrameWin::HandleInitMenuPopup() {
   system_menu_->UpdateStates();
 }
 
-void BrowserFrameWin::OnWindowPosChanged(WINDOWPOS* window_pos) {
-  NativeWidgetWin::OnWindowPosChanged(window_pos);
-  UpdateDWMFrame();
-
+void BrowserFrameWin::HandleVisibilityChanged(bool visible) {
   // Windows lies to us about the position of the minimize button before a
   // window is visible.  We use this position to place the OTR avatar in RTL
   // mode, so when the window is shown, we need to re-layout and schedule a
   // paint for the non-client frame view so that the icon top has the correct
   // position when the window becomes visible.  This fixes bugs where the icon
   // appears to overlay the minimize button.
   // Note that we will call Layout every time SetWindowPos is called with
   // SWP_SHOWWINDOW, however callers typically are careful about not specifying
   // this flag unless necessary to avoid flicker.
   // This may be invoked during creation on XP and before the non_client_view
   // has been created.
-  if (window_pos->flags & SWP_SHOWWINDOW && GetWidget()->non_client_view()) {
+  if (visible && GetWidget()->non_client_view()) {
+    UpdateDWMFrame();
     GetWidget()->non_client_view()->Layout();
     GetWidget()->non_client_view()->SchedulePaint();
   }
 }
 
+void BrowserFrameWin::HandleFrameChanged() {
+  UpdateDWMFrame();
+}
+
 void BrowserFrameWin::OnScreenReaderDetected() {
   BrowserAccessibilityState::GetInstance()->OnScreenReaderDetected();
   NativeWidgetWin::OnScreenReaderDetected();
 }
 
 bool BrowserFrameWin::ShouldUseNativeFrame() const {
   // App panel windows draw their own frame.
   if (browser_view_->IsPanel())
     return false;
 
@@ skipping 24 matching lines @@
 void BrowserFrameWin::ShowWithWindowState(ui::WindowShowState show_state) {
   AdjustFrameForImmersiveMode();
   views::NativeWidgetWin::ShowWithWindowState(show_state);
 }
 
 void BrowserFrameWin::Close() {
   CloseImmersiveFrame();
   views::NativeWidgetWin::Close();
 }
 
-void BrowserFrameWin::OnActivate(UINT action, BOOL minimized, HWND window) {
-  if (action != WA_INACTIVE)
+void BrowserFrameWin::HandleActivationChanged(bool active) {
+  if (active)
     CacheMinimizeButtonDelta();
-  views::NativeWidgetWin::OnActivate(action, minimized, window);
 }
 
 void BrowserFrameWin::FrameTypeChanged() {
   // In Windows 8 metro mode the frame type is set to FRAME_TYPE_FORCE_CUSTOM
   // by default. We reset it back to FRAME_TYPE_DEFAULT to ensure that we
   // don't end up defaulting to BrowserNonClientFrameView in all cases.
   if (base::win::IsMetroProcess())
     browser_frame_->set_frame_type(views::Widget::FRAME_TYPE_DEFAULT);
 
   views::NativeWidgetWin::FrameTypeChanged();
@@ skipping 53 matching lines @@
   if (minimize_button_offset > 0)
     return minimize_button_offset;
 
   // If we fail to get the minimize button offset via the WM_GETTITLEBARINFOEX
   // message then calculate and return this via the
   // cached_minimize_button_x_delta_ member value. Please see
   // CacheMinimizeButtonDelta() for more details.
   DCHECK(cached_minimize_button_x_delta_);
 
   RECT client_rect = {0};
-  GetClientRect(&client_rect);
+  GetClientRect(GetNativeView(), &client_rect);
 
   if (base::i18n::IsRTL())
     return cached_minimize_button_x_delta_;
   else
     return client_rect.right - cached_minimize_button_x_delta_;
 }
 
 void BrowserFrameWin::TabStripDisplayModeChanged() {
   UpdateDWMFrame();
 }
 
 void BrowserFrameWin::ButtonPressed(views::Button* sender,
                                     const ui::Event& event) {
   HMODULE metro = base::win::GetMetroModule();
   if (!metro)
     return;
   // Tell the metro_driver to flip our window. This causes the current
   // browser window to be hidden and the next window to be shown.
   static FlipFrameWindows flip_window_fn = reinterpret_cast<FlipFrameWindows>(
       ::GetProcAddress(metro, "FlipFrameWindows"));
   if (flip_window_fn)
     flip_window_fn();
 }
 
-LRESULT BrowserFrameWin::OnWndProc(UINT message,
-                                   WPARAM w_param,
-                                   LPARAM l_param) {
+bool BrowserFrameWin::HandleMSG(UINT message,
+                                WPARAM w_param,
+                                LPARAM l_param,
+                                LRESULT* result) {
   static const UINT metro_navigation_search_message =
       RegisterWindowMessage(chrome::kMetroNavigationAndSearchMessage);
 
   static const UINT metro_get_current_tab_info_message =
       RegisterWindowMessage(chrome::kMetroGetCurrentTabInfoMessage);
 
   if (message == metro_navigation_search_message) {
     HandleMetroNavSearchRequest(w_param, l_param);
   } else if (message == metro_get_current_tab_info_message) {
     GetMetroCurrentTabInfo(w_param);
   } else if (message == WM_PRINT && base::win::IsMetroProcess()) {
     // This message is sent by the AnimateWindow API which is used in metro
     // mode to flip between active chrome windows.
     RECT client_rect = {0};
     ::GetClientRect(GetNativeView(), &client_rect);
     HDC dest_dc = reinterpret_cast<HDC>(w_param);
     DCHECK(dest_dc);
     HDC src_dc = ::GetDC(GetNativeView());
     ::BitBlt(dest_dc, 0, 0, client_rect.right - client_rect.left,
              client_rect.bottom - client_rect.top, src_dc, 0, 0,
              SRCCOPY);
     ::ReleaseDC(GetNativeView(), src_dc);
-    return 0;
+    *result = 0;
+    return true;
   }
-  return views::NativeWidgetWin::OnWndProc(message, w_param, l_param);
+  return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserFrameWin, private:
 
 void BrowserFrameWin::UpdateDWMFrame() {
   // For "normal" windows on Aero, we always need to reset the glass area
   // correctly, even if we're not currently showing the native frame (e.g.
   // because a theme is showing), so we explicitly check for that case rather
   // than checking browser_frame_->ShouldUseNativeFrame() here.  Using that here
@@ skipping 160 matching lines @@
   current_tab_info->url = base::win::LocalAllocAndCopyString(
       UTF8ToWide(current_tab->GetURL().spec()));
 }
 
 void BrowserFrameWin::CacheMinimizeButtonDelta() {
   int minimize_offset = GetMinimizeButtonOffsetForWindow(GetNativeView());
   if (!minimize_offset)
     return;
 
   RECT rect = {0};
-  GetClientRect(&rect);
+  GetClientRect(GetNativeView(), &rect);
   // Calculate and cache the value of the minimize button delta, i.e. the
   // offset to be applied to the left or right edge of the client rect
   // depending on whether the language is RTL or not.
   // This cached value is only used if the WM_GETTITLEBARINFOEX message fails
   // to get the offset of the minimize button.
   if (base::i18n::IsRTL())
     cached_minimize_button_x_delta_ = minimize_offset;
   else
     cached_minimize_button_x_delta_ = rect.right - minimize_offset;
 }
@@ skipping 10 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeBrowserFrame, public:
 
 // static
 NativeBrowserFrame* NativeBrowserFrame::CreateNativeBrowserFrame(
     BrowserFrame* browser_frame,
     BrowserView* browser_view) {
   return new BrowserFrameWin(browser_frame, browser_view);
 }