Reduce the fullscreen window height by 1px on activation loss.

ui/views/widget/desktop_aura/desktop_window_tree_host_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/desktop_aura/desktop_window_tree_host_win.h"
 
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 678 matching lines @@
 }
 
 bool DesktopWindowTreeHostWin::ShouldHandleSystemCommands() const {
   return GetWidget()->widget_delegate()->ShouldHandleSystemCommands();
 }
 
 void DesktopWindowTreeHostWin::HandleAppDeactivated() {
   native_widget_delegate_->EnableInactiveRendering();
 }
 
-void DesktopWindowTreeHostWin::HandleActivationChanged(bool active) {
+void DesktopWindowTreeHostWin::HandleActivationChanged(
+    bool active,
+    HWND window_gaining_or_losing_activation) {
   // This can be invoked from HWNDMessageHandler::Init(), at which point we're
   // not in a good state and need to ignore it.
   // TODO(beng): Do we need this still now the host owns the dispatcher?
   if (!dispatcher())
     return;
 
   if (active)
     OnHostActivated();
   desktop_native_widget_aura_->HandleActivationChanged(active);
+
+  if (!::IsWindow(window_gaining_or_losing_activation))

[sky, 2016/02/19 21:17:00]

Is there a reason not to put all this logic in HWNDMessageHandler? You' making
it maintain some state anyway.

[ananta, 2016/02/19 21:24:18]

I did not want to add state to HWNDMessageHandler. However the code in
WM_WINDOWPOSCHANGING necessiated that change. I thought it is better to have
this logic in the delegate.

+    window_gaining_or_losing_activation = ::GetForegroundWindow();
+
+  // 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.
+  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(GetHWND(), MONITOR_DEFAULTTOPRIMARY),
+                      &monitor_info);
+      gfx::Rect shrunk_rect(monitor_info.rcMonitor);
+      shrunk_rect.set_height(shrunk_rect.height() - 1);
+      // The message handler needs to allow this bounds change to occur.
+      message_handler_->set_background_fullscreen_hack(true);
+      SetBounds(shrunk_rect);
+    }
+  } else if (message_handler_->background_fullscreen_hack()) {
+    // Restore the bounds of the window to fullscreen.
+    DCHECK(IsFullscreen());
+    message_handler_->set_background_fullscreen_hack(false);
+    MONITORINFO monitor_info = {sizeof(monitor_info)};
+    GetMonitorInfo(MonitorFromWindow(GetHWND(), MONITOR_DEFAULTTOPRIMARY),
+                    &monitor_info);
+    SetBounds(gfx::Rect(monitor_info.rcMonitor));
+  }
 }
 
 bool DesktopWindowTreeHostWin::HandleAppCommand(short command) {
   // 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() &&
       GetWidget()->widget_delegate()->ExecuteWindowsCommand(command);
 }
 
 void DesktopWindowTreeHostWin::HandleCancelMode() {
@@ skipping 63 matching lines @@
 void DesktopWindowTreeHostWin::HandleVisibilityChanging(bool visible) {
   native_widget_delegate_->OnNativeWidgetVisibilityChanging(visible);
 }
 
 void DesktopWindowTreeHostWin::HandleVisibilityChanged(bool visible) {
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
 void DesktopWindowTreeHostWin::HandleClientSizeChanged(
     const gfx::Size& new_size) {
-  if (dispatcher())
+  if (dispatcher() && !message_handler_->background_fullscreen_hack())
     OnHostResized(new_size);
 }
 
 void DesktopWindowTreeHostWin::HandleFrameChanged() {
   SetWindowTransparency();
   // Replace the frame and layout the contents.
   GetWidget()->non_client_view()->UpdateFrame();
 }
 
 void DesktopWindowTreeHostWin::HandleNativeFocus(HWND last_focused_window) {
@@ skipping 158 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostWin(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views