Consolidate ShouldUseNativeFrame/AlwaysUseNativeFrame/UseNativeFrame spaghetti.

views/window/window_win.cc

 // Copyright (c) 2011 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 "views/window/window_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/i18n/rtl.h"
@@ skipping 292 matching lines @@
   base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
   return gfx::Font(caption_font);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowWin, protected:
 
 gfx::Insets WindowWin::GetClientAreaInsets() const {
   // Returning an empty Insets object causes the default handling in
   // WidgetWin::OnNCCalcSize() to be invoked.
-  if (delegate_->IsUsingNativeFrame())
+  if (GetWindow()->ShouldUseNativeFrame())
     return gfx::Insets();
 
   if (IsMaximized()) {
     // Windows automatically adds a standard width border to all sides when a
     // window is maximized.
     int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME);
     return gfx::Insets(border_thickness, border_thickness, border_thickness,
                        border_thickness);
   }
   // This is weird, but highly essential. If we don't offset the bottom edge
   // of the client rect, the window client area and window area will match,
   // and when returning to glass rendering mode from non-glass, the client
   // area will not paint black as transparent. This is because (and I don't
   // know why) the client area goes from matching the window rect to being
   // something else. If the client area is not the window rect in both
   // modes, the blackness doesn't occur. Because of this, we need to tell
   // the RootView to lay out to fit the window rect, rather than the client
   // rect when using the opaque frame.
   // Note: this is only required for non-fullscreen windows. Note that
   // fullscreen windows are in restored state, not maximized.
-  return gfx::Insets(0, 0, IsFullscreen() ? 0 : 1, 0);
+  return gfx::Insets(0, 0, 0, 0);
 }
 
 int WindowWin::GetShowState() const {
   return SW_SHOWNORMAL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowWin, WidgetWin overrides:
 
 void WindowWin::InitNativeWidget(const Widget::InitParams& params) {
@@ skipping 62 matching lines @@
   is_in_size_move_ = true;
   WidgetWin::OnEnterSizeMove();
   delegate_->OnNativeWindowBeginUserBoundsChange();
 }
 
 void WindowWin::OnExitSizeMove() {
   is_in_size_move_ = false;
   WidgetWin::OnExitSizeMove();
   delegate_->OnNativeWindowEndUserBoundsChange();
 
-  if (!ShouldUseNativeFrame()) {
+  if (!GetWindow()->ShouldUseNativeFrame()) {
     // Sending SWP_FRAMECHANGED forces a non-client repaint, which fixes the
     // glitch in rendering the bottom pixel of the window caused by us
     // offsetting the client rect there (See comment in GetClientAreaInsets()).
     SetWindowPos(NULL, 0, 0, 0, 0,
                  SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER);
   }
 }
 
 void WindowWin::OnFinalMessage(HWND window) {
   delegate_->OnNativeWindowDestroyed();
   WidgetWin::OnFinalMessage(window);
 }
 
 void WindowWin::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
   gfx::Size min_window_size(delegate_->GetMinimumSize());
   minmax_info->ptMinTrackSize.x = min_window_size.width();
   minmax_info->ptMinTrackSize.y = min_window_size.height();
   WidgetWin::OnGetMinMaxInfo(minmax_info);
 }
 
 void WindowWin::OnInitMenu(HMENU menu) {
   // We only need to manually enable the system menu if we're not using a native
   // frame.
-  if (delegate_->IsUsingNativeFrame())
+  if (GetWindow()->ShouldUseNativeFrame())
     WidgetWin::OnInitMenu(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);
   EnableMenuItem(menu, SC_RESTORE, is_minimized || is_maximized);
   EnableMenuItem(menu, SC_MOVE, is_restored);
@@ skipping 25 matching lines @@
     if (w_param == HTCAPTION || w_param == HTSYSMENU) {
       UINT flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD;
       if (base::i18n::IsRTL())
         flags |= TPM_RIGHTALIGN;
       HMENU system_menu = GetSystemMenu(GetNativeView(), FALSE);
       int id = TrackPopupMenu(system_menu, flags, screen_point.x,
                               screen_point.y, 0, GetNativeView(), NULL);
       ExecuteSystemMenuCommand(id);
       return 0;
     }
-  } else if (message == WM_NCLBUTTONDOWN && !delegate_->IsUsingNativeFrame()) {
+  } else if (message == WM_NCLBUTTONDOWN &&
+             !GetWindow()->ShouldUseNativeFrame()) {
     switch (w_param) {
       case HTCLOSE:
       case HTMINBUTTON:
       case HTMAXBUTTON: {
         // When the mouse is pressed down in these specific non-client areas,
         // we need to tell the RootView to send the mouse pressed event (which
         // sets capture, allowing subsequent WM_LBUTTONUP (note, _not_
         // WM_NCLBUTTONUP) to fire so that the appropriate WM_SYSCOMMAND can be
         // sent by the applicable button's ButtonListener. We _have_ to do this
         // way rather than letting Windows just send the syscommand itself (as
@@ skipping 51 matching lines @@
 
   is_active_ = !!active;
   delegate_->OnNativeWindowActivationChanged(is_active_);
 
   // The frame may need to redraw as a result of the activation change.
   // We can get WM_NCACTIVATE before we're actually visible. If we're not
   // visible, no need to paint.
   if (IsVisible())
     GetWindow()->non_client_view()->SchedulePaint();
 
-  if (!ShouldUseNativeFrame()) {
+  if (!GetWindow()->ShouldUseNativeFrame()) {
     // TODO(beng, et al): Hack to redraw this window and child windows
     //     synchronously upon activation. Not all child windows are redrawing
     //     themselves leading to issues like http://crbug.com/74604
     //     We redraw out-of-process HWNDs asynchronously to avoid hanging the
     //     whole app if a child HWND belonging to a hung plugin is encountered.
     RedrawWindow(GetNativeView(), NULL, NULL,
                  RDW_NOCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW);
     EnumChildWindows(GetNativeView(), EnumChildWindowsForRedraw, NULL);
   }
 
   // If we're active again, we should be allowed to render as inactive, so
   // tell the non-client view.
   bool inactive_rendering_disabled = delegate_->IsInactiveRenderingDisabled();
   if (IsActive())
     delegate_->EnableInactiveRendering();
 
   return CallDefaultNCActivateHandler(inactive_rendering_disabled || active);
 }
 
 LRESULT WindowWin::OnNCCalcSize(BOOL mode, LPARAM l_param) {
+  //return 0;
   // We only override the default handling if we need to specify a custom
   // non-client edge width. Note that in most cases "no insets" means no
   // custom width, but in fullscreen mode we want a custom width of 0.
   gfx::Insets insets = GetClientAreaInsets();
   if (insets.empty() && !IsFullscreen())
     return WidgetWin::OnNCCalcSize(mode, l_param);
 
   RECT* client_rect = mode ?
       &reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param)->rgrc[0] :
       reinterpret_cast<RECT*>(l_param);
@@ skipping 21 matching lines @@
       if (!monitor) {
         // This is probably an extreme case that we won't hit, but if we don't
         // intersect any monitor, let us not adjust the client rect since our
         // window will not be visible anyway.
         return 0;
       }
     }
     if (EdgeHasTopmostAutoHideTaskbar(ABE_LEFT, monitor))
       client_rect->left += kAutoHideTaskbarThicknessPx;
     if (EdgeHasTopmostAutoHideTaskbar(ABE_TOP, monitor)) {
-      if (delegate_->IsUsingNativeFrame()) {
+      if (GetWindow()->ShouldUseNativeFrame()) {
         // Tricky bit.  Due to a bug in DwmDefWindowProc()'s handling of
         // WM_NCHITTEST, having any nonclient area atop the window causes the
         // caption buttons to draw onscreen but not respond to mouse
         // hover/clicks.
         // So for a taskbar at the screen top, we can't push the
         // client_rect->top down; instead, we move the bottom up by one pixel,
         // which is the smallest change we can make and still get a client area
         // less than the screen size. This is visibly ugly, but there seems to
         // be no better solution.
         --client_rect->bottom;
@@ skipping 20 matching lines @@
   // 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 WindowWin::OnNCHitTest(const CPoint& point) {
   // 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 (ShouldUseNativeFrame()) {
+  if (GetWindow()->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.
   return WidgetWin::OnNCHitTest(point);
 }
 
 void WindowWin::OnNCPaint(HRGN rgn) {
   // When using a custom frame, we want to avoid calling DefWindowProc() since
   // that may render artifacts.
   SetMsgHandled((!IsActive() || is_in_size_move_) &&
-                !delegate_->IsUsingNativeFrame());
+                !GetWindow()->ShouldUseNativeFrame());
 }
 
 LRESULT WindowWin::OnNCUAHDrawCaption(UINT msg, WPARAM w_param,
                                       LPARAM 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(!delegate_->IsUsingNativeFrame());
+  SetMsgHandled(!GetWindow()->ShouldUseNativeFrame());
   return 0;
 }
 
 LRESULT WindowWin::OnNCUAHDrawFrame(UINT msg, WPARAM w_param,
                                     LPARAM 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(!delegate_->IsUsingNativeFrame());
+  SetMsgHandled(!GetWindow()->ShouldUseNativeFrame());
   return 0;
 }
 
 LRESULT WindowWin::OnSetCursor(UINT msg,
                                WPARAM w_param,
                                LPARAM l_param) {
   // This shouldn't hurt even if we're using the native frame.
   ScopedRedrawLock lock(this);
   return DefWindowProc(GetNativeView(), msg, w_param, l_param);
 }
@@ skipping 36 matching lines @@
 void WindowWin::OnSysCommand(UINT notification_code, CPoint click) {
   // 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.
   if (IsFullscreen() &&
       (((notification_code & sc_mask) == SC_SIZE) ||
        ((notification_code & sc_mask) == SC_MOVE) ||
        ((notification_code & sc_mask) == SC_MAXIMIZE)))
     return;
-  if (!delegate_->IsUsingNativeFrame()) {
+  if (!GetWindow()->ShouldUseNativeFrame()) {
     if ((notification_code & sc_mask) == SC_MINIMIZE ||
         (notification_code & sc_mask) == SC_MAXIMIZE ||
         (notification_code & sc_mask) == SC_RESTORE) {
       GetWindow()->non_client_view()->ResetWindowControls();
     } else if ((notification_code & sc_mask) == SC_MOVE ||
                (notification_code & sc_mask) == SC_SIZE) {
       if (lock_updates_) {
         // We were locked, before entering a resize or move modal loop. Now that
         // we've begun to move the window, we need to unlock updates so that the
         // sizing/moving feedback can be continuous.
@@ skipping 422 matching lines @@
     SetWindowLong(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_);
   }
 }
 
 NonClientFrameView* WindowWin::CreateFrameViewForWindow() {
-  if (ShouldUseNativeFrame())
+  if (GetWindow()->ShouldUseNativeFrame())
     return new NativeFrameView(GetWindow());
   return new CustomFrameView(GetWindow());
 }
 
 void WindowWin::UpdateFrameAfterFrameChange() {
   // We've either gained or lost a custom window region, so reset it now.
   ResetWindowRegion(true);
 }
 
 gfx::NativeWindow WindowWin::GetNativeWindow() const {
   return GetNativeView();
 }
 
 bool WindowWin::ShouldUseNativeFrame() const {
   return WidgetWin::IsAeroGlassEnabled();
 }
 
 void WindowWin::FrameTypeChanged() {
   // Called when the frame type could possibly be changing (theme change or
   // DWM composition change).
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // We need to toggle the rendering policy of the DWM/glass frame as we
     // change from opaque to glass. "Non client rendering enabled" means that
     // the DWM's glass non-client rendering is enabled, which is why
     // DWMNCRP_ENABLED is used for the native frame case. _DISABLED means the
     // DWM doesn't render glass, and so is used in the custom frame case.
-    DWMNCRENDERINGPOLICY policy =
-        delegate_->IsUsingNativeFrame() ? DWMNCRP_ENABLED : DWMNCRP_DISABLED;
+    DWMNCRENDERINGPOLICY policy = GetWindow()->ShouldUseNativeFrame() ?
+        DWMNCRP_ENABLED : DWMNCRP_DISABLED;
     DwmSetWindowAttribute(GetNativeView(), DWMWA_NCRENDERING_POLICY,
                           &policy, sizeof(DWMNCRENDERINGPOLICY));
   }
 
   // Send a frame change notification, since the non-client metrics have
   // changed.
   SendFrameChanged(GetNativeView());
 
   // Update the non-client view with the correct frame view for the active frame
   // type.
@@ skipping 53 matching lines @@
 }
 
 void WindowWin::UnlockUpdates() {
   SetWindowLong(GWL_STYLE, saved_window_style_);
   lock_updates_ = false;
 }
 
 void WindowWin::ResetWindowRegion(bool force) {
   // A native frame uses the native window region, and we don't want to mess
   // with it.
-  if (delegate_->IsUsingNativeFrame()) {
+  if (GetWindow()->ShouldUseNativeFrame()) {
     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);
 
@@ skipping 42 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWindow, public:
 
 // static
 NativeWindow* NativeWindow::CreateNativeWindow(
     internal::NativeWindowDelegate* delegate) {
   return new WindowWin(delegate);
 }
 
 }  // namespace views