Reduce the size of the fullscreen window on activation loss only if the window being activated is …

ui/views/win/hwnd_message_handler.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/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <oleacc.h>
 #include <shellapi.h>
 #include <tchar.h>
@@ skipping 282 matching lines @@
   // Records the HWND visibility at the time of creation.
   bool was_visible_;
   // A flag indicating that the unlock operation was canceled.
   bool cancel_unlock_;
   // If true, perform the redraw lock regardless of Aero state.
   bool force_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedRedrawLock);
 };
 
+
+// static HWNDMessageHandler member initialization.
+HWNDMessageHandler::FullscreenWindowMonitorMap*

[sky, 2016/05/13 23:32:36]

Use LazyInstance, it's less error prone than what you have here.

[ananta, 2016/05/16 19:56:43]

Done.

+    HWNDMessageHandler::fullscreen_monitor_map_ = nullptr;
+int32_t HWNDMessageHandler::instance_count_ = 0;
+
 ////////////////////////////////////////////////////////////////////////////////
 // HWNDMessageHandler, public:
 
 long HWNDMessageHandler::last_touch_message_time_ = 0;
 
 HWNDMessageHandler::HWNDMessageHandler(HWNDMessageHandlerDelegate* delegate)
     : msg_handled_(FALSE),
       delegate_(delegate),
       fullscreen_handler_(new FullscreenHandler),
       waiting_for_close_now_(false),
@@ skipping 18 matching lines @@
       left_button_down_on_caption_(false),
       background_fullscreen_hack_(false),
       autohide_factory_(this),
       weak_factory_(this) {}
 
 HWNDMessageHandler::~HWNDMessageHandler() {
   delegate_ = NULL;
   // Prevent calls back into this class via WNDPROC now that we've been
   // destroyed.
   ClearUserData();
+  instance_count_--;
+  if (!instance_count_) {
+    delete fullscreen_monitor_map_;
+  }
 }
 
 void HWNDMessageHandler::Init(HWND parent, const gfx::Rect& bounds) {
   TRACE_EVENT0("views", "HWNDMessageHandler::Init");
   GetMonitorAndRects(bounds.ToRECT(), &last_monitor_, &last_monitor_rect_,
                      &last_work_area_);
 
   // Create the window.
   WindowImpl::Init(parent, bounds);
   // TODO(ananta)
@@ skipping 25 matching lines @@
 
   // Direct Manipulation is enabled on Windows 10+. The CreateInstance function
   // returns NULL if Direct Manipulation is not available.
   direct_manipulation_helper_ =
       gfx::win::DirectManipulationHelper::CreateInstance();
   if (direct_manipulation_helper_)
     direct_manipulation_helper_->Initialize(hwnd());
 
   // Disable pen flicks (http://crbug.com/506977)
   base::win::DisableFlicks(hwnd());
+
+  instance_count_++;
+  if (!fullscreen_monitor_map_)
+    fullscreen_monitor_map_ = new FullscreenWindowMonitorMap;
 }
 
 void HWNDMessageHandler::InitModalType(ui::ModalType modal_type) {
   if (modal_type == ui::MODAL_TYPE_NONE)
     return;
   // We implement modality by crawling up the hierarchy of windows starting
   // at the owner, disabling all of them so that they don't receive input
   // messages.
   HWND start = ::GetWindow(hwnd(), GW_OWNER);
   while (start) {
@@ skipping 410 matching lines @@
   }
 }
 
 void HWNDMessageHandler::SetFullscreen(bool fullscreen) {
   background_fullscreen_hack_ = false;
   fullscreen_handler()->SetFullscreen(fullscreen);
   // If we are out of fullscreen and there was a pending DWM transition for the
   // window, then go ahead and do it now.
   if (!fullscreen && dwm_transition_desired_)
     PerformDwmTransition();
+
+  // Add the fullscreen window to the fullscreen window map which is used to
+  // handle window activations.
+  HMONITOR monitor = MonitorFromWindow(hwnd(), MONITOR_DEFAULTTOPRIMARY);
+  DCHECK(fullscreen_monitor_map_);
+  if (fullscreen) {
+    (*fullscreen_monitor_map_)[monitor] = hwnd();
+  } else {
+    fullscreen_monitor_map_->erase(fullscreen_monitor_map_->find(monitor));
+  }
 }
 
 void HWNDMessageHandler::SizeConstraintsChanged() {
   LONG style = GetWindowLong(hwnd(), GWL_STYLE);
   // Ignore if this is not a standard window.
   if (style & (WS_POPUP | WS_CHILD))
     return;
 
   LONG exstyle = GetWindowLong(hwnd(), GWL_EXSTYLE);
   // Windows cannot have WS_THICKFRAME set if WS_EX_COMPOSITED is set.
@@ skipping 188 matching lines @@
   // If the window losing activation is a fullscreen window, we reduce the size
   // of the window by 1px. i.e. Not fullscreen. This is to work around an
   // apparent bug in the Windows taskbar where in it tracks fullscreen state on
   // a per thread basis. This causes it not be a topmost window when any
   // maximized window on a thread which has a fullscreen window is active. This
   // affects the way these windows interact with the taskbar, they obscure it
   // when maximized, autohide does not work correctly, etc.
   // By reducing the size of the fullscreen window by 1px, we ensure that the
   // taskbar no longer treats the window and in turn the thread as a fullscreen
   // thread. This in turn ensures that maximized windows on the same thread
-  /// don't obscure the taskbar, etc.
+  // don't obscure the taskbar, etc.
+  // Please note that this taskbar behavior only occurs if the window becoming
+  // active is on the same monitor as the fullscreen window.
   if (!active) {
     if (IsFullscreen() && ::IsWindow(window_gaining_or_losing_activation)) {
-      // Reduce the bounds of the window by 1px to ensure that Windows does
-      // not treat this like a fullscreen window.
-      MONITORINFO monitor_info = {sizeof(monitor_info)};
-      GetMonitorInfo(MonitorFromWindow(hwnd(), MONITOR_DEFAULTTOPRIMARY),
-                      &monitor_info);
-      gfx::Rect shrunk_rect(monitor_info.rcMonitor);
-      shrunk_rect.set_height(shrunk_rect.height() - 1);
-      background_fullscreen_hack_ = true;
-      SetBoundsInternal(shrunk_rect, false);
+      HMONITOR active_window_monitor = MonitorFromWindow(
+          window_gaining_or_losing_activation, MONITOR_DEFAULTTOPRIMARY);
+      HMONITOR fullscreen_window_monitor = MonitorFromWindow(
+          hwnd(), MONITOR_DEFAULTTOPRIMARY);
+
+      if (active_window_monitor == fullscreen_window_monitor)
+        OnBackgroundFullscreen(0, 0, 0);
     }
   } else if (background_fullscreen_hack_) {
     // Restore the bounds of the window to fullscreen.
     DCHECK(IsFullscreen());
     MONITORINFO monitor_info = {sizeof(monitor_info)};
     GetMonitorInfo(MonitorFromWindow(hwnd(), MONITOR_DEFAULTTOPRIMARY),
                    &monitor_info);
     SetBoundsInternal(gfx::Rect(monitor_info.rcMonitor), false);
     background_fullscreen_hack_ = false;
+  } else {
+    // If the window becoming active has a fullscreen window on the same
+    // monitor then we need to reduce the size of the fullscreen window by
+    // 1 px. Please refer to the comments above for the reasoning behind
+    // this.
+    CheckAndHandleBackgroundFullscreenOnMonitor(
+        window_gaining_or_losing_activation);
   }
 }
 
 void HWNDMessageHandler::RestoreEnabledIfNecessary() {
   if (delegate_->IsModal() && !restored_enabled_) {
     restored_enabled_ = true;
     // If we were run modally, we need to undo the disabled-ness we inflicted on
     // the owner's parent hierarchy.
     HWND start = ::GetWindow(hwnd(), GW_OWNER);
     while (start) {
@@ skipping 275 matching lines @@
       base::Bind(&HWNDMessageHandler::OnSessionChange,
                  base::Unretained(this))));
 
   // TODO(beng): move more of NWW::OnCreate here.
   return 0;
 }
 
 void HWNDMessageHandler::OnDestroy() {
   windows_session_change_observer_.reset(nullptr);
   delegate_->HandleDestroying();
+  // If the window going away is a fullscreen window then remove its references
+  // from the full screen window map.
+  FullscreenWindowMonitorMap::iterator index;
+  DCHECK(fullscreen_monitor_map_);
+  for (index = fullscreen_monitor_map_->begin();
+    index != fullscreen_monitor_map_->end();
+    index++) {
+    if (index->second == hwnd()) {
+      fullscreen_monitor_map_->erase(index);
+      break;
+    }
+  }
 }
 
 void HWNDMessageHandler::OnDisplayChange(UINT bits_per_pixel,
                                          const gfx::Size& screen_size) {
   delegate_->HandleDisplayChange();
   // Force a WM_NCCALCSIZE to occur to ensure that we handle auto hide
   // taskbars correctly.
   SendFrameChanged();
 }
 
@@ skipping 40 matching lines @@
 void HWNDMessageHandler::OnExitSizeMove() {
   delegate_->HandleEndWMSizeMove();
   SetMsgHandled(FALSE);
   // Please refer to the notes in the OnSize function for information about
   // the scrolling hack.
   // We hide the Windows scrollbar in the OnEnterSizeMove function. We need
   // to add the scroll styles back to ensure that scrolling works in legacy
   // trackpoint drivers.
   if (in_size_loop_ && needs_scroll_styles_)
     AddScrollStylesToWindow(hwnd());
+  // If the window was moved to a monitor which has a fullscreen window active,
+  // we need to reduce the size of the fullscreen window by 1px.
+  CheckAndHandleBackgroundFullscreenOnMonitor(hwnd());
 }
 
 void HWNDMessageHandler::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
   gfx::Size min_window_size;
   gfx::Size max_window_size;
   delegate_->GetMinMaxSize(&min_window_size, &max_window_size);
   min_window_size = delegate_->DIPToScreenSize(min_window_size);
   max_window_size = delegate_->DIPToScreenSize(max_window_size);
 
 
@@ skipping 927 matching lines @@
     if (direct_manipulation_helper_)
       direct_manipulation_helper_->Deactivate(hwnd());
   }
   if (sent_window_size_changing_) {
     sent_window_size_changing_ = false;
     delegate_->HandleWindowSizeChanged();
   }
   SetMsgHandled(FALSE);
 }
 
+LRESULT HWNDMessageHandler::OnBackgroundFullscreen(UINT message,
+                                                   WPARAM w_param,
+                                                   LPARAM l_param) {
+  // Reduce the bounds of the window by 1px to ensure that Windows does
+  // not treat this like a fullscreen window.
+  MONITORINFO monitor_info = { sizeof(monitor_info) };
+  GetMonitorInfo(MonitorFromWindow(hwnd(), MONITOR_DEFAULTTOPRIMARY),
+      &monitor_info);
+  gfx::Rect shrunk_rect(monitor_info.rcMonitor);
+  shrunk_rect.set_height(shrunk_rect.height() - 1);
+  background_fullscreen_hack_ = true;
+  SetBoundsInternal(shrunk_rect, false);
+  return 0;
+}
+
 void HWNDMessageHandler::OnSessionChange(WPARAM status_code) {
   // Direct3D presents are ignored while the screen is locked, so force the
   // window to be redrawn on unlock.
   if (status_code == WTS_SESSION_UNLOCK)
     ForceRedrawWindow(10);
 }
 
 void HWNDMessageHandler::HandleTouchEvents(const TouchEvents& touch_events) {
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
   for (size_t i = 0; i < touch_events.size() && ref; ++i)
@@ skipping 319 matching lines @@
   if (old_size == bounds_in_pixels.size() && force_size_changed &&
       !background_fullscreen_hack_) {
     delegate_->HandleClientSizeChanged(GetClientAreaBounds().size());
     ResetWindowRegion(false, true);
   }
 
   if (direct_manipulation_helper_)
     direct_manipulation_helper_->SetBounds(bounds_in_pixels);
 }
 
+void HWNDMessageHandler::CheckAndHandleBackgroundFullscreenOnMonitor(
+    HWND window) {
+  HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTOPRIMARY);
+
+  DCHECK(fullscreen_monitor_map_);
+  FullscreenWindowMonitorMap::iterator index = fullscreen_monitor_map_->find(
+      monitor);
+  if (index != fullscreen_monitor_map_->end() && window != index->second) {
+    PostMessage(index->second,

[sky, 2016/05/13 23:32:36]

Why bother with the PostMessage? Why not call the HWNDMessageHandler directly?

[ananta, 2016/05/16 19:56:43]

The fullscreen window could be a different instance of HWNDMessageHandler. We
need to get to that context and hence PostMessage.

[ananta, 2016/05/16 21:35:42]

yeah. done.

+                WM_CUSTOM_MESSAGE_HANDLE_BACKGROUND_FULLSCREEN,
+                0,
+                0);
+  }
+}
 
 }  // namespace views