Move more from Window onto Widget.

views/widget/native_widget_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/widget/native_widget_win.h"
 
 #include <dwmapi.h>
 
 #include "base/string_util.h"
 #include "base/system_monitor/system_monitor.h"
@@ skipping 165 matching lines @@
 }
 
 // Tells the window its frame (non-client area) has changed.
 void SendFrameChanged(HWND window) {
   SetWindowPos(window, NULL, 0, 0, 0, 0,
       SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOCOPYBITS |
       SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREPOSITION |
       SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER);
 }
 
+// Enables or disables the menu item for the specified command and menu.
+void EnableMenuItem(HMENU menu, UINT command, bool enabled) {
+  UINT flags = MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
+  EnableMenuItem(menu, command, flags);
+}
+
+BOOL CALLBACK EnumChildWindowsForRedraw(HWND hwnd, LPARAM lparam) {
+  DWORD process_id;
+  GetWindowThreadProcessId(hwnd, &process_id);
+  int flags = RDW_INVALIDATE | RDW_NOCHILDREN | RDW_FRAME;
+  if (process_id == GetCurrentProcessId())
+    flags |= RDW_UPDATENOW;
+  RedrawWindow(hwnd, NULL, NULL, flags);
+  return TRUE;
+}
+
 // Links the HWND to its NativeWidget.
 const char* const kNativeWidgetKey = "__VIEWS_NATIVE_WIDGET__";
 
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 const int kCustomObjectID = 1;
 
 // If the hung renderer warning doesn't fit on screen, the amount of padding to
 // be left between the edge of the window and the edge of the nearest monitor,
 // after the window is nudged back on screen. Pixels.
 const int kMonitorEdgePadding = 10;
 
 const int kDragFrameWindowAlpha = 200;
 
 }  // namespace
 
 // static
 bool NativeWidgetWin::screen_reader_active_ = false;
 
+// A scoping class that prevents a window from being able to redraw in response
+// to invalidations that may occur within it for the lifetime of the object.
+//
+// Why would we want such a thing? Well, it turns out Windows has some
+// "unorthodox" behavior when it comes to painting its non-client areas.
+// Occasionally, Windows will paint portions of the default non-client area
+// right over the top of the custom frame. This is not simply fixed by handling
+// WM_NCPAINT/WM_PAINT, with some investigation it turns out that this
+// rendering is being done *inside* the default implementation of some message
+// handlers and functions:
+//  . WM_SETTEXT
+//  . WM_SETICON
+//  . WM_NCLBUTTONDOWN
+//  . EnableMenuItem, called from our WM_INITMENU handler
+// The solution is to handle these messages and call DefWindowProc ourselves,
+// but prevent the window from being able to update itself for the duration of
+// the call. We do this with this class, which automatically calls its
+// associated Window's lock and unlock functions as it is created and destroyed.
+// See documentation in those methods for the technique used.
+//
+// IMPORTANT: Do not use this scoping object for large scopes or periods of
+//            time! IT WILL PREVENT THE WINDOW FROM BEING REDRAWN! (duh).
+//
+// I would love to hear Raymond Chen's explanation for all this. And maybe a
+// list of other messages that this applies to ;-)
+class NativeWidgetWin::ScopedRedrawLock {
+ public:
+  explicit ScopedRedrawLock(NativeWidgetWin* widget) : widget_(widget) {
+    widget_->LockUpdates();
+  }
+
+  ~ScopedRedrawLock() {
+    widget_->UnlockUpdates();
+  }
+
+ private:
+  // The widget having its style changed.
+  NativeWidgetWin* widget_;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, public:
 
 NativeWidgetWin::NativeWidgetWin(internal::NativeWidgetDelegate* delegate)
     : is_window_(false),
       delegate_(delegate),
       close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       use_layered_buffer_(false),
       layered_alpha_(255),
       ALLOW_THIS_IN_INITIALIZER_LIST(paint_layered_window_factory_(this)),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       can_update_layered_window_(true),
       focus_on_creation_(true),
       restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
       previous_cursor_(NULL),
       is_input_method_win_(false),
       fullscreen_(false),
-      force_hidden_count_(0) {
+      force_hidden_count_(0),
+      lock_updates_(false),
+      saved_window_style_(0) {
 }
 
 NativeWidgetWin::~NativeWidgetWin() {
   // We need to delete the input method before calling DestroyRootView(),
   // because it'll set focus_manager_ to NULL.
   input_method_.reset();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete delegate_;
 }
 
 // static
 bool NativeWidgetWin::IsAeroGlassEnabled() {
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
   // If composition is not enabled, we behave like on XP.
   BOOL enabled = FALSE;
   return SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled;
 }
 
+void NativeWidgetWin::Show(int show_state) {
+  ShowWindow(show_state);
+  // When launched from certain programs like bash and Windows Live Messenger,
+  // show_state is set to SW_HIDE, so we need to correct that condition. We
+  // don't just change show_state to SW_SHOWNORMAL because MSDN says we must
+  // always first call ShowWindow with the specified value from STARTUPINFO,
+  // otherwise all future ShowWindow calls will be ignored (!!#@@#!). Instead,
+  // we call ShowWindow again in this case.
+  if (show_state == SW_HIDE) {
+    show_state = SW_SHOWNORMAL;
+    ShowWindow(show_state);
+  }
+
+  // We need to explicitly activate the window if we've been shown with a state
+  // that should activate, because if we're opened from a desktop shortcut while
+  // an existing window is already running it doesn't seem to be enough to use
+  // one of these flags to activate the window.
+  if (show_state == SW_SHOWNORMAL || show_state == SW_SHOWMAXIMIZED)
+    Activate();
+
+  SetInitialFocus();
+}
+
 View* NativeWidgetWin::GetAccessibilityViewEventAt(int id) {
   // Convert from MSAA child id.
   id = -(id + 1);
   DCHECK(id >= 0 && id < kMaxAccessibilityViewEvents);
   return accessibility_view_events_[id];
 }
 
 int NativeWidgetWin::AddAccessibilityViewEvent(View* view) {
   accessibility_view_events_index_ =
       (accessibility_view_events_index_ + 1) % kMaxAccessibilityViewEvents;
@@ skipping 288 matching lines @@
 }
 
 gfx::Rect NativeWidgetWin::GetClientAreaScreenBounds() const {
   RECT r;
   GetClientRect(&r);
   POINT point = { r.left, r.top };
   ClientToScreen(hwnd(), &point);
   return gfx::Rect(point.x, point.y, r.right - r.left, r.bottom - r.top);
 }
 
+gfx::Rect NativeWidgetWin::GetRestoredBounds() const {
+  // If we're in fullscreen mode, we've changed the normal bounds to the monitor
+  // rect, so return the saved bounds instead.
+  if (IsFullscreen())
+    return gfx::Rect(saved_window_info_.window_rect);
+
+  gfx::Rect bounds;
+  GetWindowBoundsAndMaximizedState(&bounds, NULL);
+  return bounds;
+}
+
 void NativeWidgetWin::SetBounds(const gfx::Rect& bounds) {
   LONG style = GetWindowLong(GWL_STYLE);
   if (style & WS_MAXIMIZE)
     SetWindowLong(GWL_STYLE, style & ~WS_MAXIMIZE);
   SetWindowPos(NULL, bounds.x(), bounds.y(), bounds.width(), bounds.height(),
                SWP_NOACTIVATE | SWP_NOZORDER);
 }
 
 void NativeWidgetWin::SetSize(const gfx::Size& size) {
   SetWindowPos(NULL, 0, 0, size.width(), size.height(),
@@ skipping 57 matching lines @@
   is_input_method_win_ = false;
 
   // We may already have been destroyed if the selection resulted in a tab
   // switch which will have reactivated the browser window and closed us, so
   // we need to check to see if we're still a window before trying to destroy
   // ourself.
   if (IsWindow())
     DestroyWindow(hwnd());
 }
 
+void NativeWidgetWin::EnableClose(bool enable) {
+  // Disable the native frame's close button regardless of whether or not the
+  // native frame is in use, since this also affects the system menu.
+  EnableMenuItem(GetSystemMenu(GetNativeView(), false), SC_CLOSE, enable);
+  SendFrameChanged(GetNativeView());
+}
+
 void NativeWidgetWin::Show() {
   if (!IsWindow())
     return;
 
   ShowWindow(SW_SHOWNOACTIVATE);
   SetInitialFocus();
 }
 
 void NativeWidgetWin::Hide() {
   if (IsWindow()) {
     // NOTE: Be careful not to activate any windows here (for example, calling
     // ShowWindow(SW_HIDE) will automatically activate another window).  This
     // code can be called while a window is being deactivated, and activating
     // another window will screw up the activation that is already in progress.
     SetWindowPos(NULL, 0, 0, 0, 0,
                  SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOMOVE |
                  SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER);
   }
 }
 
+void NativeWidgetWin::ShowNativeWidget(ShowState state) {
+  DWORD native_show_state;
+  switch (state) {
+    case SHOW_INACTIVE:
+      native_show_state = SW_SHOWNOACTIVATE;
+      break;
+    case SHOW_MAXIMIZED:
+      native_show_state = SW_SHOWMAXIMIZED;
+      break;
+    default:
+      native_show_state = GetShowState();
+      break;
+  }
+  Show(native_show_state);
+}
+
 bool NativeWidgetWin::IsVisible() const {
   return !!::IsWindowVisible(hwnd());
 }
 
 void NativeWidgetWin::Activate() {
   if (IsMinimized())
     ::ShowWindow(GetNativeView(), SW_RESTORE);
   ::SetWindowPos(GetNativeView(), HWND_TOP, 0, 0, 0, 0,
                  SWP_NOSIZE | SWP_NOMOVE);
   SetForegroundWindow(GetNativeView());
@@ skipping 214 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
 // Message handlers ------------------------------------------------------------
 
 void NativeWidgetWin::OnActivate(UINT action, BOOL minimized, HWND window) {
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnActivateApp(BOOL active, DWORD thread_id) {
-  SetMsgHandled(FALSE);
+  if (GetWidget()->non_client_view() && !active &&
+      thread_id != GetCurrentThreadId()) {
+    // Another application was activated, we should reset any state that
+    // disables inactive rendering now.
+    delegate_->EnableInactiveRendering();
+    // Update the native frame too, since it could be rendering the non-client
+    // area.
+    CallDefaultNCActivateHandler(FALSE);
+  }
 }
 
 LRESULT NativeWidgetWin::OnAppCommand(HWND window,
                                       short app_command,
                                       WORD device,
                                       int keystate) {
   // 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()->ExecuteWindowsCommand(app_command);
 }
@@ skipping 72 matching lines @@
   if (delegate_->HasFocusManager() &&
       NativeTextfieldViews::IsTextfieldViewsEnabled()) {
     input_method_.reset(new InputMethodWin(this));
     input_method_->Init(GetWidget());
     is_input_method_win_ = true;
   }
   return 0;
 }
 
 void NativeWidgetWin::OnDestroy() {
+  delegate_->OnNativeWidgetDestroying();
   if (drop_target_.get()) {
     RevokeDragDrop(hwnd());
     drop_target_ = NULL;
   }
 
   props_.reset();
 }
 
 void NativeWidgetWin::OnDisplayChange(UINT bits_per_pixel, CSize screen_size) {
   GetWidget()->widget_delegate()->OnDisplayChanged();
 }
 
 LRESULT NativeWidgetWin::OnDwmCompositionChanged(UINT msg,
                                                  WPARAM w_param,
                                                  LPARAM l_param) {
-  SetMsgHandled(FALSE);
+  if (!GetWidget()->non_client_view()) {
+    SetMsgHandled(FALSE);
+    return 0;
+  }
+
+  // For some reason, we need to hide the window while we're changing the frame
+  // type only when we're changing it in response to WM_DWMCOMPOSITIONCHANGED.
+  // If we don't, the client area will be filled with black. I'm suspecting
+  // something skia-ey.
+  // Frame type toggling caused by the user (e.g. switching theme) doesn't seem
+  // to have this requirement.
+  FrameTypeChanged();
   return 0;
 }
 
 void NativeWidgetWin::OnEndSession(BOOL ending, UINT logoff) {
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnEnterSizeMove() {
+  delegate_->OnNativeWidgetBeginUserBoundsChange();
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnEraseBkgnd(HDC dc) {
   // This is needed for magical win32 flicker ju-ju.
   return 1;
 }
 
 void NativeWidgetWin::OnExitMenuLoop(BOOL is_track_popup_menu) {
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnExitSizeMove() {
+  delegate_->OnNativeWidgetEndUserBoundsChange();
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnGetObject(UINT uMsg,
                                      WPARAM w_param,
                                      LPARAM l_param) {
   LRESULT reference_result = static_cast<LRESULT>(0L);
 
   // Accessibility readers will send an OBJID_CLIENT message
   if (OBJID_CLIENT == l_param) {
@@ skipping 13 matching lines @@
     OnScreenReaderDetected();
 
     // Return with failure.
     return static_cast<LRESULT>(0L);
   }
 
   return reference_result;
 }
 
 void NativeWidgetWin::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();
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnHScroll(int scroll_type,
                                 short position,
                                 HWND scrollbar) {
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnImeMessages(UINT message,
@@ skipping 31 matching lines @@
     default:
       NOTREACHED() << "Unknown IME message:" << message;
       break;
   }
 
   SetMsgHandled(handled);
   return result;
 }
 
 void NativeWidgetWin::OnInitMenu(HMENU menu) {
-  SetMsgHandled(FALSE);
+  // We only need to manually enable the system menu if we're not using a native
+  // frame.
+  if (GetWidget()->ShouldUseNativeFrame()) {
+    SetMsgHandled(FALSE);
+    return;
+  }
+
+  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);
+  EnableMenuItem(menu, SC_SIZE,
+                 GetWidget()->widget_delegate()->CanResize() && is_restored);
+  EnableMenuItem(menu, SC_MAXIMIZE,
+                 GetWidget()->widget_delegate()->CanMaximize() &&
+                     !is_fullscreen && !is_maximized);
+  EnableMenuItem(menu, SC_MINIMIZE,
+                 GetWidget()->widget_delegate()->CanMaximize() &&
+                     !is_minimized);
 }
 
 void NativeWidgetWin::OnInitMenuPopup(HMENU menu,
                                       UINT position,
                                       BOOL is_system_menu) {
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnInputLangChange(DWORD character_set,
                                         HKL input_language_id) {
@@ skipping 18 matching lines @@
 void NativeWidgetWin::OnKillFocus(HWND focused_window) {
   delegate_->OnNativeBlur(focused_window);
   if (input_method_.get())
     input_method_->OnBlur();
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnMouseActivate(UINT message,
                                          WPARAM w_param,
                                          LPARAM l_param) {
+  // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
+  //             line.
+  if (GetWidget()->non_client_view())
+    return delegate_->CanActivate() ? MA_ACTIVATE : MA_NOACTIVATEANDEAT;
   if (GetWindowLong(GWL_EXSTYLE) & WS_EX_NOACTIVATE)
     return MA_NOACTIVATE;
   SetMsgHandled(FALSE);
   return MA_ACTIVATE;
 }
 
 LRESULT NativeWidgetWin::OnMouseRange(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   MSG msg = { hwnd(), message, w_param, l_param, 0,
@@ skipping 29 matching lines @@
   GetWidget()->widget_delegate()->OnWidgetMove();
   SetMsgHandled(FALSE);
 }
 
 void NativeWidgetWin::OnMoving(UINT param, const LPRECT new_bounds) {
   // TODO(beng): move to Widget.
   GetWidget()->widget_delegate()->OnWidgetMove();
 }
 
 LRESULT NativeWidgetWin::OnNCActivate(BOOL active) {
-  SetMsgHandled(FALSE);
-  return 0;
+  if (!GetWidget()->non_client_view()) {
+    SetMsgHandled(FALSE);
+    return 0;
+  }
+
+  if (!delegate_->CanActivate())
+    return TRUE;
+
+  delegate_->OnNativeWidgetActivationChanged(!!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())
+    GetWidget()->non_client_view()->SchedulePaint();
+
+  if (!GetWidget()->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 NativeWidgetWin::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
-LRESULT NativeWidgetWin::OnNCHitTest(const CPoint& pt) {
+LRESULT NativeWidgetWin::OnNCHitTest(const CPoint& point) {
+  if (!GetWidget()->non_client_view()) {
+    SetMsgHandled(FALSE);
+    return 0;
+  }
+
+  // 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 (GetWidget()->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.
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void NativeWidgetWin::OnNCPaint(HRGN rgn) {
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnNCUAHDrawCaption(UINT msg,
                                             WPARAM w_param,
                                             LPARAM l_param) {
-  SetMsgHandled(FALSE);
+  // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
+  // an explanation about why we need to handle this message.
+  SetMsgHandled(!GetWidget()->ShouldUseNativeFrame());
   return 0;
 }
 
 LRESULT NativeWidgetWin::OnNCUAHDrawFrame(UINT msg,
                                           WPARAM w_param,
                                           LPARAM l_param) {
-  SetMsgHandled(FALSE);
+  // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
+  // an explanation about why we need to handle this message.
+  SetMsgHandled(!GetWidget()->ShouldUseNativeFrame());
   return 0;
 }
 
 LRESULT NativeWidgetWin::OnNotify(int w_param, NMHDR* l_param) {
   // We can be sent this message before the tooltip manager is created, if a
   // subclass overrides OnCreate and creates some kind of Windows control there
   // that sends WM_NOTIFY messages.
   if (tooltip_manager_.get()) {
     bool handled;
     LRESULT result = tooltip_manager_->OnNotify(w_param, l_param, &handled);
@@ skipping 31 matching lines @@
 LRESULT NativeWidgetWin::OnReflectedMessage(UINT msg,
                                             WPARAM w_param,
                                             LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 LRESULT NativeWidgetWin::OnSetCursor(UINT message,
                                      WPARAM w_param,
                                      LPARAM l_param) {
-  SetMsgHandled(FALSE);
-  return 0;
+  // This shouldn't hurt even if we're using the native frame.
+  ScopedRedrawLock lock(this);
+  return DefWindowProc(GetNativeView(), message, w_param, l_param);
 }
 
 void NativeWidgetWin::OnSetFocus(HWND focused_window) {
   delegate_->OnNativeFocus(focused_window);
   if (input_method_.get())
     input_method_->OnFocus();
   SetMsgHandled(FALSE);
 }
 
 LRESULT NativeWidgetWin::OnSetIcon(UINT size_type, HICON new_icon) {
-  SetMsgHandled(FALSE);
-  return 0;
+  // This shouldn't hurt even if we're using the native frame.
+  ScopedRedrawLock lock(this);
+  return DefWindowProc(GetNativeView(), WM_SETICON, size_type,
+                       reinterpret_cast<LPARAM>(new_icon));
 }
 
 LRESULT NativeWidgetWin::OnSetText(const wchar_t* text) {
-  SetMsgHandled(FALSE);
-  return 0;
+  // This shouldn't hurt even if we're using the native frame.
+  ScopedRedrawLock lock(this);
+  return DefWindowProc(GetNativeView(), WM_SETTEXT, NULL,
+                       reinterpret_cast<LPARAM>(text));
 }
 
 void NativeWidgetWin::OnSettingChange(UINT flags, const wchar_t* section) {
   if (!GetParent() && (flags == SPI_SETWORKAREA) &&
       !GetWidget()->widget_delegate()->WillProcessWorkAreaChange()) {
     // Fire a dummy SetWindowPos() call, so we'll trip the code in
     // OnWindowPosChanging() below that notices work area changes.
     ::SetWindowPos(GetNativeView(), 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
         SWP_NOZORDER | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
     SetMsgHandled(TRUE);
   } else {
     // TODO(beng): move to Widget.
     if (flags == SPI_SETWORKAREA)
       GetWidget()->widget_delegate()->OnWorkAreaChanged();
     SetMsgHandled(FALSE);
   }
 }
 
 void NativeWidgetWin::OnSize(UINT param, const CSize& size) {
+  RedrawWindow(GetNativeView(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
   // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
   // invoked OnSize we ensure the RootView has been laid out.
   ResetWindowRegion(false);
 }
 
 void NativeWidgetWin::OnSysCommand(UINT notification_code, CPoint click) {
+  if (!GetWidget()->non_client_view())
+    return;
+
+  // 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 (!GetWidget()->ShouldUseNativeFrame()) {
+    if ((notification_code & sc_mask) == SC_MINIMIZE ||
+        (notification_code & sc_mask) == SC_MAXIMIZE ||
+        (notification_code & sc_mask) == SC_RESTORE) {
+      GetWidget()->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.
+        UnlockUpdates();
+      }
+    }
+  }
+
+  // Handle SC_KEYMENU, which means that the user has pressed the ALT
+  // key and released it, so we should focus the menu bar.
+  if ((notification_code & sc_mask) == SC_KEYMENU && click.x == 0) {
+    // Retrieve the status of shift and control keys to prevent consuming
+    // shift+alt keys, which are used by Windows to change input languages.
+    Accelerator accelerator(ui::KeyboardCodeForWindowsKeyCode(VK_MENU),
+                            !!(GetKeyState(VK_SHIFT) & 0x8000),
+                            !!(GetKeyState(VK_CONTROL) & 0x8000),
+                            false);
+    GetWidget()->GetFocusManager()->ProcessAccelerator(accelerator);
+    return;
+  }
+
+  // If the delegate can't handle it, the system implementation will be called.
+  if (!delegate_->ExecuteCommand(notification_code)) {
+    DefWindowProc(GetNativeView(), WM_SYSCOMMAND, notification_code,
+                  MAKELPARAM(click.x, click.y));
+  }
 }
 
 void NativeWidgetWin::OnThemeChanged() {
   // Notify NativeThemeWin.
   gfx::NativeThemeWin::instance()->CloseHandles();
 }
 
 void NativeWidgetWin::OnVScroll(int scroll_type,
                                 short position,
                                 HWND scrollbar) {
@@ skipping 18 matching lines @@
 
 void NativeWidgetWin::OnFinalMessage(HWND window) {
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
+int NativeWidgetWin::GetShowState() const {
+  return SW_SHOWNORMAL;
+}
+
+gfx::Insets NativeWidgetWin::GetClientAreaInsets() const {
+  // Returning an empty Insets object causes the default handling in
+  // NativeWidgetWin::OnNCCalcSize() to be invoked.
+  if (GetWidget()->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);
+}
+
 void NativeWidgetWin::TrackMouseEvents(DWORD mouse_tracking_flags) {
   // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE
   // when the user moves the mouse outside this HWND's bounds.
   if (active_mouse_tracking_flags_ == 0 || mouse_tracking_flags & TME_CANCEL) {
     if (mouse_tracking_flags & TME_CANCEL) {
       // We're about to cancel active mouse tracking, so empty out the stored
       // state.
       active_mouse_tracking_flags_ = 0;
     } else {
       active_mouse_tracking_flags_ = mouse_tracking_flags;
@@ skipping 160 matching lines @@
   POINT position = {wr.left, wr.top};
   HDC dib_dc = skia::BeginPlatformPaint(layered_window_contents_.get());
   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_.get());
 }
 
+void NativeWidgetWin::LockUpdates() {
+  lock_updates_ = true;
+  saved_window_style_ = GetWindowLong(GWL_STYLE);
+  SetWindowLong(GWL_STYLE, saved_window_style_ & ~WS_VISIBLE);
+}
+
+void NativeWidgetWin::UnlockUpdates() {
+  SetWindowLong(GWL_STYLE, saved_window_style_);
+  lock_updates_ = false;
+}
+
 void NativeWidgetWin::ClientAreaSizeChanged() {
   RECT r;
   Window* window = GetWidget()->GetContainingWindow();
   if (IsZoomed() || (window && window->ShouldUseNativeFrame()))
     GetClientRect(&r);
   else
     GetWindowRect(&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_->OnSizeChanged(s);
+  delegate_->OnNativeWidgetSizeChanged(s);
   if (use_layered_buffer_) {
     layered_window_contents_.reset(
         new gfx::CanvasSkia(s.width(), s.height(), false));
   }
 }
 
 void NativeWidgetWin::ResetWindowRegion(bool force) {
   // A native frame uses the native window region, and we don't want to mess
   // with it.
   if (GetWidget()->ShouldUseNativeFrame() || !GetWidget()->non_client_view()) {
@@ skipping 29 matching lines @@
   if (current_rgn_result == ERROR || !EqualRgn(current_rgn, new_region)) {
     // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
     SetWindowRgn(new_region, TRUE);
   } else {
     DeleteObject(new_region);
   }
 
   DeleteObject(current_rgn);
 }
 
+LRESULT NativeWidgetWin::CallDefaultNCActivateHandler(BOOL active) {
+  // The DefWindowProc handling for WM_NCACTIVATE renders the classic-look
+  // window title bar directly, so we need to use a redraw lock here to prevent
+  // it from doing so.
+  ScopedRedrawLock lock(this);
+  return DefWindowProc(GetNativeView(), WM_NCACTIVATE, active, 0);
+}
+
 gfx::AcceleratedWidget NativeWidgetWin::GetAcceleratedWidget() {
 #if defined(VIEWS_COMPOSITOR)
   return hwnd();
 #else
   return gfx::kNullAcceleratedWidget;
 #endif
 }
 
 void NativeWidgetWin::DispatchKeyEventPostIME(const KeyEvent& key) {
   SetMsgHandled(delegate_->OnKeyEvent(key));
@@ skipping 138 matching lines @@
 
   // And now, notify them that they have a brand new parent.
   for (NativeWidgets::iterator it = widgets.begin();
        it != widgets.end(); ++it) {
     (*it)->GetWidget()->NotifyNativeViewHierarchyChanged(true,
                                                          new_parent);
   }
 }
 
 }  // namespace views