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

ui/views/win/hwnd_message_handler.h

 // 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.
 
 #ifndef UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_
 #define UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_
 
 #include <windows.h>
 
 #include <stddef.h>
+#include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
@@ skipping 77 matching lines @@
     BOOL bHandled = TRUE; \
     hWnd; \
     uMsg; \
     wParam; \
     lParam; \
     lResult; \
     bHandled; \
     switch(dwMsgMapID) { \
       case 0:
 
+// This message is posted when our window is activated on the monitor
+// where there is a fullscreen window owned by us. The handler for
+// this message reduces the size of the fullscreen window by 1 px. This is
+// to workaround a bug in the taskbar where it treats all windows owned by
+// a thread on a monitor as fullscreen windows if one of the windows in there
+// is a full screen window. The bug does not occur across monitors.
+const int WM_CUSTOM_MESSAGE_HANDLE_BACKGROUND_FULLSCREEN = WM_USER + 1;
+
 // An object that handles messages for a HWND that implements the views
 // "Custom Frame" look. The purpose of this class is to isolate the windows-
 // specific message handling from the code that wraps it. It is intended to be
 // used by both a views::NativeWidget and an aura::WindowTreeHost
 // implementation.
 // TODO(beng): This object should eventually *become* the WindowImpl.
 class VIEWS_EXPORT HWNDMessageHandler :
     public gfx::WindowImpl,
     public ui::WindowEventTarget {
  public:
@@ skipping 243 matching lines @@
     CR_MESSAGE_HANDLER_EX(WM_HSCROLL, OnScrollMessage)
 
     // Touch Events.
     CR_MESSAGE_HANDLER_EX(WM_TOUCH, OnTouchEvent)
 
     // Uses the general handler macro since the specific handler macro
     // MSG_WM_NCACTIVATE would convert WPARAM type to BOOL type. The high
     // word of WPARAM could be set when the window is minimized or restored.
     CR_MESSAGE_HANDLER_EX(WM_NCACTIVATE, OnNCActivate)
 
+    CR_MESSAGE_HANDLER_EX(WM_CUSTOM_MESSAGE_HANDLE_BACKGROUND_FULLSCREEN,
+        OnBackgroundFullscreen)
+
     // This list is in _ALPHABETICAL_ order! OR I WILL HURT YOU.
     CR_MSG_WM_ACTIVATEAPP(OnActivateApp)
     CR_MSG_WM_APPCOMMAND(OnAppCommand)
     CR_MSG_WM_CANCELMODE(OnCancelMode)
     CR_MSG_WM_CAPTURECHANGED(OnCaptureChanged)
     CR_MSG_WM_CLOSE(OnClose)
     CR_MSG_WM_COMMAND(OnCommand)
     CR_MSG_WM_CREATE(OnCreate)
     CR_MSG_WM_DESTROY(OnDestroy)
     CR_MSG_WM_DISPLAYCHANGE(OnDisplayChange)
@@ skipping 71 matching lines @@
   void OnSetFocus(HWND last_focused_window);
   LRESULT OnSetIcon(UINT size_type, HICON new_icon);
   LRESULT OnSetText(const wchar_t* text);
   void OnSettingChange(UINT flags, const wchar_t* section);
   void OnSize(UINT param, const gfx::Size& size);
   void OnSysCommand(UINT notification_code, const gfx::Point& point);
   void OnThemeChanged();
   LRESULT OnTouchEvent(UINT message, WPARAM w_param, LPARAM l_param);
   void OnWindowPosChanging(WINDOWPOS* window_pos);
   void OnWindowPosChanged(WINDOWPOS* window_pos);
+  LRESULT OnBackgroundFullscreen(UINT message, WPARAM w_param, LPARAM l_param);
 
   // Receives Windows Session Change notifications.
   void OnSessionChange(WPARAM status_code);
 
   typedef std::vector<ui::TouchEvent> TouchEvents;
   // Helper to handle the list of touch events passed in. We need this because
   // touch events on windows don't fire if we enter a modal loop in the context
   // of a touch event.
   void HandleTouchEvents(const TouchEvents& touch_events);
 
@@ skipping 38 matching lines @@
   // Returns true if the message was handled.
   bool HandleMouseInputForCaption(unsigned int message,
                                   WPARAM w_param,
                                   LPARAM l_param);
 
   // Helper function for setting the bounds of the HWND. For more information
   // please refer to the SetBounds() function.
   void SetBoundsInternal(const gfx::Rect& bounds_in_pixels,
                          bool force_size_changed);
 
+  // Checks if there is a full screen window on the same monitor as the
+  // |window| which is becoming active. If yes then we reduce the size of the
+  // fullscreen window by 1 px to ensure that maximized windows on the same
+  // monitor don't draw over the taskbar.
+  void CheckAndHandleBackgroundFullscreenOnMonitor(HWND window);
+
   HWNDMessageHandlerDelegate* delegate_;
 
   std::unique_ptr<FullscreenHandler> fullscreen_handler_;
 
   // Set to true in Close() and false is CloseNow().
   bool waiting_for_close_now_;
 
   bool use_system_default_icon_;
 
   // Whether all ancestors have been enabled. This is only used if is_modal_ is
@@ skipping 123 matching lines @@
 
   // The WeakPtrFactories below must occur last in the class definition so they
   // get destroyed last.
 
   // The factory used to lookup appbar autohide edges.
   base::WeakPtrFactory<HWNDMessageHandler> autohide_factory_;
 
   // The factory used with BEGIN_SAFE_MSG_MAP_EX.
   base::WeakPtrFactory<HWNDMessageHandler> weak_factory_;
 
+  // This is a map of the HMONITOR to full screeen window handle.
+  typedef std::map<HMONITOR, HWND> FullscreenWindowMonitorMap;
+  static FullscreenWindowMonitorMap* fullscreen_monitor_map_;
+  // This holds the number of HWNDMessageHandler instances currently active.
+  static int32_t instance_count_;
+
   DISALLOW_COPY_AND_ASSIGN(HWNDMessageHandler);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_