Move Fullscreen stuff onto FullscreenHandler type that hangs off NWW. This is the first step in mov…

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 31 matching lines @@
 #include "ui/views/ime/input_method_win.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/aero_tooltip_manager.h"
 #include "ui/views/widget/child_window_message_processor.h"
 #include "ui/views/widget/drop_target_win.h"
 #include "ui/views/widget/monitor_win.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/widget_hwnd_utils.h"
+#include "ui/views/win/fullscreen_handler.h"
 #include "ui/views/win/hwnd_message_handler.h"
+#include "ui/views/win/scoped_fullscreen_visibility.h"
 #include "ui/views/window/native_frame_view.h"
 
 #if !defined(USE_AURA)
 #include "base/command_line.h"
 #include "ui/base/ui_base_switches.h"
 #endif
 
 #pragma comment(lib, "dwmapi.lib")
 
 using ui::ViewProp;
@@ skipping 264 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       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),
       restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
       previous_cursor_(NULL),
-      fullscreen_(false),
-      metro_snap_(false),
-      force_hidden_count_(0),
       ignore_window_pos_changes_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ignore_pos_changes_factory_(this)),
       last_monitor_(NULL),
       restored_enabled_(false),
       has_non_client_view_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-        message_handler_(new HWNDMessageHandler(this))) {
+          message_handler_(new HWNDMessageHandler(this))),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          fullscreen_handler_(new FullscreenHandler(GetWidget()))) {
 }
 
 NativeWidgetWin::~NativeWidgetWin() {
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete delegate_;
   else
     CloseNow();
 }
 
 // static
@@ skipping 46 matching lines @@
 
 void NativeWidgetWin::ClearAccessibilityViewEvent(View* view) {
   for (std::vector<View*>::iterator it = accessibility_view_events_.begin();
       it != accessibility_view_events_.end();
       ++it) {
     if (*it == view)
       *it = NULL;
   }
 }
 
-void NativeWidgetWin::PushForceHidden() {
-  if (force_hidden_count_++ == 0)
-    Hide();
-}
-
-void NativeWidgetWin::PopForceHidden() {
-  if (--force_hidden_count_ <= 0) {
-    force_hidden_count_ = 0;
-    ShowWindow(SW_SHOW);
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, CompositorDelegate implementation:
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, NativeWidget implementation:
 
 void NativeWidgetWin::InitNativeWidget(const Widget::InitParams& params) {
   SetInitParams(params);
 
   GetMonitorAndRects(params.bounds.ToRECT(), &last_monitor_,
@@ skipping 273 matching lines @@
   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);
+    return fullscreen_handler_->GetRestoreBounds();
 
   gfx::Rect bounds;
   GetWindowPlacement(&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);
@@ skipping 150 matching lines @@
 
 bool NativeWidgetWin::IsMinimized() const {
   return message_handler_->IsMinimized();
 }
 
 void NativeWidgetWin::Restore() {
   ExecuteSystemMenuCommand(SC_RESTORE);
 }
 
 void NativeWidgetWin::SetFullscreen(bool fullscreen) {
-  if (fullscreen_ == fullscreen)
-    return;
-
-  SetFullscreenInternal(fullscreen, false);
+  fullscreen_handler_->SetFullscreen(fullscreen);
 }
 
 void NativeWidgetWin::SetMetroSnapFullscreen(bool metro_snap) {
-  if (metro_snap_ == metro_snap)
-    return;
-
-  SetFullscreenInternal(metro_snap, true);
-
-  metro_snap_ = metro_snap;
-}
-
-void NativeWidgetWin::SetFullscreenInternal(bool fullscreen,
-                                            bool for_metro) {
-
-  // Reduce jankiness during the following position changes by hiding the window
-  // until it's in the final position.
-  PushForceHidden();
-
-  // Save current window state if not already fullscreen.
-  if (!fullscreen_) {
-    // Save current window information.  We force the window into restored mode
-    // before going fullscreen because Windows doesn't seem to hide the
-    // taskbar if the window is in the maximized state.
-    saved_window_info_.maximized = IsMaximized();
-    if (saved_window_info_.maximized)
-      Restore();
-    saved_window_info_.style = GetWindowLong(GWL_STYLE);
-    saved_window_info_.ex_style = GetWindowLong(GWL_EXSTYLE);
-    GetWindowRect(&saved_window_info_.window_rect);
-  }
-
-  fullscreen_ = fullscreen;
-
-  if (fullscreen_) {
-    // Set new window style and size.
-    SetWindowLong(GWL_STYLE,
-                  saved_window_info_.style & ~(WS_CAPTION | WS_THICKFRAME));
-    SetWindowLong(GWL_EXSTYLE,
-                  saved_window_info_.ex_style & ~(WS_EX_DLGMODALFRAME |
-                  WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
-
-    // On expand, if we're given a window_rect, grow to it, otherwise do
-    // not resize.
-    if (!for_metro) {
-      MONITORINFO monitor_info;
-      monitor_info.cbSize = sizeof(monitor_info);
-      GetMonitorInfo(MonitorFromWindow(GetNativeView(),
-                                       MONITOR_DEFAULTTONEAREST),
-                     &monitor_info);
-      gfx::Rect window_rect(monitor_info.rcMonitor);
-      SetWindowPos(NULL, window_rect.x(), window_rect.y(),
-                   window_rect.width(), window_rect.height(),
-                   SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
-    }
-  } else {
-    // Reset original window style and size.  The multiple window size/moves
-    // here are ugly, but if SetWindowPos() doesn't redraw, the taskbar won't be
-    // repainted.  Better-looking methods welcome.
-    SetWindowLong(GWL_STYLE, saved_window_info_.style);
-    SetWindowLong(GWL_EXSTYLE, saved_window_info_.ex_style);
-
-    if (!for_metro) {
-      // On restore, resize to the previous saved rect size.
-      gfx::Rect new_rect(saved_window_info_.window_rect);
-      SetWindowPos(NULL, new_rect.x(), new_rect.y(), new_rect.width(),
-                   new_rect.height(),
-                   SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
-    }
-    if (saved_window_info_.maximized)
-      Maximize();
-  }
-
-  // Undo our anti-jankiness hacks.
-  PopForceHidden();
+  fullscreen_handler_->SetMetroSnap(metro_snap);
 }
 
 bool NativeWidgetWin::IsFullscreen() const {
-  return fullscreen_;
+  return fullscreen_handler_->fullscreen();
 }
 
 bool NativeWidgetWin::IsInMetroSnapMode() const {
-  return metro_snap_;
+  return fullscreen_handler_->metro_snap();
 }
 
 void NativeWidgetWin::SetOpacity(unsigned char opacity) {
   layered_alpha_ = 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.
@@ skipping 637 matching lines @@
     }
   } else if (!GetParent()) {
     CRect window_rect;
     HMONITOR monitor;
     gfx::Rect monitor_rect, work_area;
     if (GetWindowRect(&window_rect) &&
         GetMonitorAndRects(window_rect, &monitor, &monitor_rect, &work_area)) {
       bool work_area_changed = (monitor_rect == last_monitor_rect_) &&
                                (work_area != last_work_area_);
       if (monitor && (monitor == last_monitor_) &&
-          ((IsFullscreen() && !metro_snap_) || work_area_changed)) {
+          ((IsFullscreen() && !fullscreen_handler_->metro_snap()) ||
+            work_area_changed)) {
         // A rect for the monitor we're on changed.  Normally Windows notifies
         // us about this (and thus we're reaching here due to the SetWindowPos()
         // call in OnSettingChange() above), but with some software (e.g.
         // nVidia's nView desktop manager) the work area can change asynchronous
         // to any notification, and we're just sent a SetWindowPos() call with a
         // new (frequently incorrect) position/size.  In either case, the best
         // response is to throw away the existing position/size information in
         // |window_pos| and recalculate it based on the new work rect.
         gfx::Rect new_window_rect;
         if (IsFullscreen()) {
@@ skipping 23 matching lines @@
             FROM_HERE,
             base::Bind(&NativeWidgetWin::StopIgnoringPosChanges,
                        ignore_pos_changes_factory_.GetWeakPtr()));
       }
       last_monitor_ = monitor;
       last_monitor_rect_ = monitor_rect;
       last_work_area_ = work_area;
     }
   }
 
-  if (force_hidden_count_) {
+  if (ScopedFullscreenVisibility::IsHiddenForFullscreen(GetNativeView())) {
     // Prevent the window from being made visible if we've been asked to do so.
     // See comment in header as to why we might want this.
     window_pos->flags &= ~SWP_SHOWWINDOW;
   }
 
   // When WM_WINDOWPOSCHANGING message is handled by DefWindowProc, it will
   // enforce (cx, cy) not to be smaller than (6, 6) for any non-popup window.
   // We work around this by changing cy back to our intended value.
   if (!GetParent() && !(window_pos->flags & SWP_NOSIZE) && window_pos->cy < 6) {
     LONG old_cy = window_pos->cy;
@@ skipping 656 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