Don't check autohide taskbar for WS_EX_TOPMOST when we are querying the autohide state.

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 358 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());
+
+  // Register for fullscreen window notifications from the shell.
+  APPBARDATA appbar = {};
+  appbar.cbSize = sizeof(APPBARDATA);
+  appbar.hWnd = hwnd();
+  appbar.uCallbackMessage = WM_APPBAR_NOTIFICATION_MESSAGE;
+  ::SHAppBarMessage(ABM_NEW, &appbar);
 }
 
 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 22 matching lines @@
     // may delete ourselves on destroy and the ATL callback would still
     // dereference us when the callback returns).
     waiting_for_close_now_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&HWNDMessageHandler::CloseNow, weak_factory_.GetWeakPtr()));
   }
 }
 
 void HWNDMessageHandler::CloseNow() {
+  // Unregister fullscreen notifications from the shell.
+  APPBARDATA appbar = {};
+  appbar.cbSize = sizeof(APPBARDATA);
+  appbar.hWnd = hwnd();
+  ::SHAppBarMessage(ABM_REMOVE, &appbar);
+
   // 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.
   waiting_for_close_now_ = false;
   if (IsWindow(hwnd()))
     DestroyWindow(hwnd());
 }
 
 gfx::Rect HWNDMessageHandler::GetWindowBoundsInScreen() const {
@@ skipping 1949 matching lines @@
   // received after this message was posted.
   if (current_window_size_message_ != w_param)
     return 0;
 
   delegate_->HandleWindowSizeUnchanged();
   sent_window_size_changing_ = false;
 
   return 0;
 }
 
+LRESULT HWNDMessageHandler::OnAppBarMessage(UINT message,
+                                            WPARAM w_param,
+                                            LPARAM l_param) {
+  // Please refer to the ChromeViewsDelegate::GetAppbarAutohideEdges() function
+  // for some context on how we handle autohide taskbars.
+
+  // We receive this notification when a window changes from fullscreen to
+  // non fullscreen. Sadly we don't get the window handle. The problem we
+  // are trying to address is the case where our window switched away to
+  // maximized from fullscreen mode and the autohide taskbar is around.
+  // We want to leave a pixel space at the place where the taskbar shows up
+  // to ensure that the taskbar shows up when the mouse is moved there.
+  // The SendFrameChanged() call below achieves that.
+  if (w_param == ABN_FULLSCREENAPP && (l_param == 0) && IsMaximized())
+    SendFrameChanged();

[Peter Kasting, 2016/12/02 01:56:41]

Now that we removed the TOPMOST check, does this still have any effect?

It seems like it would have an effect if, while Chrome was fullscreened, an app
bar would be missing entirely, or in a different position, than when not
fullscreened, from the perspective of ABM_GETAUTOHIDEBAR/ABM_GETTASKBARPOS (i.e.
the checking code in MonitorHasAutohideTaskbarForEdge()).  In that case, we'd
want to make sure we check the autohide state after we come out of fullscreen
mode.  But is that the case with the TOPMOST removal?  It seems like
fullscreening should just change appbar z-order, not affect the results of those
two functions, which means this shouldn't actually matter.

(If it did matter, it seems like a better fix than asking the shell for
notifications here would be modifying views/aura itself to do this notification
once we're sufficiently out of fullscreen mode.)

[ananta, 2016/12/02 06:09:14]

I added this mostly for correctness sake, i.e querying the autohide state when
the taskbar says that a fullscreen window has gone away which is the case we
generally struggle with.

However you are right that with the TOPMOST check removal this is just
superficial. I will revert this part of the change.

+  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 349 matching lines @@
   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);
 }
 
 }  // namespace views