summaryrefslogtreecommitdiffstats
path: root/widget/windows/WinWindowOcclusionTracker.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
commit6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch)
treea68f146d7fa01f0134297619fbe7e33db084e0aa /widget/windows/WinWindowOcclusionTracker.h
parentInitial commit. (diff)
downloadthunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz
thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'widget/windows/WinWindowOcclusionTracker.h')
-rw-r--r--widget/windows/WinWindowOcclusionTracker.h333
1 files changed, 333 insertions, 0 deletions
diff --git a/widget/windows/WinWindowOcclusionTracker.h b/widget/windows/WinWindowOcclusionTracker.h
new file mode 100644
index 0000000000..b82a41b984
--- /dev/null
+++ b/widget/windows/WinWindowOcclusionTracker.h
@@ -0,0 +1,333 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef widget_windows_WinWindowOcclusionTracker_h
+#define widget_windows_WinWindowOcclusionTracker_h
+
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "nsIWeakReferenceUtils.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/WindowsVersion.h"
+#include "mozilla/ThreadSafeWeakPtr.h"
+#include "mozilla/widget/WindowOcclusionState.h"
+#include "mozilla/widget/WinEventObserver.h"
+#include "Units.h"
+#include "nsThreadUtils.h"
+
+class nsBaseWidget;
+struct IVirtualDesktopManager;
+class WinWindowOcclusionTrackerTest;
+class WinWindowOcclusionTrackerInteractiveTest;
+
+namespace base {
+class Thread;
+} // namespace base
+
+namespace mozilla {
+
+namespace widget {
+
+class OcclusionUpdateRunnable;
+class SerializedTaskDispatcher;
+class UpdateOcclusionStateRunnable;
+
+// This class handles window occlusion tracking by using HWND.
+// Implementation is borrowed from chromium's NativeWindowOcclusionTrackerWin.
+class WinWindowOcclusionTracker final : public DisplayStatusListener,
+ public SessionChangeListener {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WinWindowOcclusionTracker)
+
+ /// Can only be called from the main thread.
+ static WinWindowOcclusionTracker* Get();
+
+ /// Can only be called from the main thread.
+ static void Ensure();
+
+ /// Can only be called from the main thread.
+ static void ShutDown();
+
+ /// Can be called from any thread.
+ static MessageLoop* OcclusionCalculatorLoop();
+
+ /// Can be called from any thread.
+ static bool IsInWinWindowOcclusionThread();
+
+ /// Can only be called from the main thread.
+ void EnsureDisplayStatusObserver();
+
+ /// Can only be called from the main thread.
+ void EnsureSessionChangeObserver();
+
+ // Enables notifying to widget via NotifyOcclusionState() when the occlusion
+ // state has been computed.
+ void Enable(nsBaseWidget* aWindow, HWND aHwnd);
+
+ // Disables notifying to widget via NotifyOcclusionState() when the occlusion
+ // state has been computed.
+ void Disable(nsBaseWidget* aWindow, HWND aHwnd);
+
+ // Called when widget's visibility is changed
+ void OnWindowVisibilityChanged(nsBaseWidget* aWindow, bool aVisible);
+
+ SerializedTaskDispatcher* GetSerializedTaskDispatcher() {
+ return mSerializedTaskDispatcher;
+ }
+
+ void TriggerCalculation();
+
+ void DumpOccludingWindows(HWND aHWnd);
+
+ private:
+ friend class ::WinWindowOcclusionTrackerTest;
+ friend class ::WinWindowOcclusionTrackerInteractiveTest;
+
+ explicit WinWindowOcclusionTracker(UniquePtr<base::Thread> aThread);
+ virtual ~WinWindowOcclusionTracker();
+
+ // This class computes the occlusion state of the tracked windows.
+ // It runs on a separate thread, and notifies the main thread of
+ // the occlusion state of the tracked windows.
+ class WindowOcclusionCalculator {
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WindowOcclusionCalculator)
+ public:
+ // Creates WindowOcclusionCalculator instance.
+ static void CreateInstance();
+
+ // Clear WindowOcclusionCalculator instance.
+ static void ClearInstance();
+
+ // Returns existing WindowOcclusionCalculator instance.
+ static WindowOcclusionCalculator* GetInstance() { return sCalculator; }
+
+ void Initialize();
+ void Shutdown();
+
+ void EnableOcclusionTrackingForWindow(HWND hwnd);
+ void DisableOcclusionTrackingForWindow(HWND hwnd);
+
+ // If a window becomes visible, makes sure event hooks are registered.
+ void HandleVisibilityChanged(bool aVisible);
+
+ void HandleTriggerCalculation();
+
+ private:
+ WindowOcclusionCalculator();
+ ~WindowOcclusionCalculator();
+
+ // Registers event hooks, if not registered.
+ void MaybeRegisterEventHooks();
+
+ // This is the callback registered to get notified of various Windows
+ // events, like window moving/resizing.
+ static void CALLBACK EventHookCallback(HWINEVENTHOOK aWinEventHook,
+ DWORD aEvent, HWND aHwnd,
+ LONG aIdObject, LONG aIdChild,
+ DWORD aEventThread,
+ DWORD aMsEventTime);
+
+ // EnumWindows callback used to iterate over all hwnds to determine
+ // occlusion status of all tracked root windows. Also builds up
+ // |current_pids_with_visible_windows_| and registers event hooks for newly
+ // discovered processes with visible hwnds.
+ static BOOL CALLBACK
+ ComputeNativeWindowOcclusionStatusCallback(HWND hwnd, LPARAM lParam);
+
+ // EnumWindows callback used to update the list of process ids with
+ // visible hwnds, |pids_for_location_change_hook_|.
+ static BOOL CALLBACK UpdateVisibleWindowProcessIdsCallback(HWND aHwnd,
+ LPARAM aLParam);
+
+ // Determines which processes owning visible application windows to set the
+ // EVENT_OBJECT_LOCATIONCHANGE event hook for and stores the pids in
+ // |pids_for_location_change_hook_|.
+ void UpdateVisibleWindowProcessIds();
+
+ // Computes the native window occlusion status for all tracked root gecko
+ // windows in |root_window_hwnds_occlusion_state_| and notifies them if
+ // their occlusion status has changed.
+ void ComputeNativeWindowOcclusionStatus();
+
+ // Schedules an occlusion calculation , if one isn't already scheduled.
+ void ScheduleOcclusionCalculationIfNeeded();
+
+ // Registers a global event hook (not per process) for the events in the
+ // range from |event_min| to |event_max|, inclusive.
+ void RegisterGlobalEventHook(DWORD aEventMin, DWORD aEventMax);
+
+ // Registers the EVENT_OBJECT_LOCATIONCHANGE event hook for the process with
+ // passed id. The process has one or more visible, opaque windows.
+ void RegisterEventHookForProcess(DWORD aPid);
+
+ // Registers/Unregisters the event hooks necessary for occlusion tracking
+ // via calls to RegisterEventHook. These event hooks are disabled when all
+ // tracked windows are minimized.
+ void RegisterEventHooks();
+ void UnregisterEventHooks();
+
+ // EnumWindows callback for occlusion calculation. Returns true to
+ // continue enumeration, false otherwise. Currently, always returns
+ // true because this function also updates currentPidsWithVisibleWindows,
+ // and needs to see all HWNDs.
+ bool ProcessComputeNativeWindowOcclusionStatusCallback(
+ HWND aHwnd, std::unordered_set<DWORD>* aCurrentPidsWithVisibleWindows);
+
+ // Processes events sent to OcclusionEventHookCallback.
+ // It generally triggers scheduling of the occlusion calculation, but
+ // ignores certain events in order to not calculate occlusion more than
+ // necessary.
+ void ProcessEventHookCallback(HWINEVENTHOOK aWinEventHook, DWORD aEvent,
+ HWND aHwnd, LONG aIdObject, LONG aIdChild);
+
+ // EnumWindows callback for determining which processes to set the
+ // EVENT_OBJECT_LOCATIONCHANGE event hook for. We set that event hook for
+ // processes hosting fully visible, opaque windows.
+ void ProcessUpdateVisibleWindowProcessIdsCallback(HWND aHwnd);
+
+ // Returns true if the window is visible, fully opaque, and on the current
+ // virtual desktop, false otherwise.
+ bool WindowCanOccludeOtherWindowsOnCurrentVirtualDesktop(
+ HWND aHwnd, LayoutDeviceIntRect* aWindowRect);
+
+ // Returns true if aHwnd is definitely on the current virtual desktop,
+ // false if it's definitely not on the current virtual desktop, and Nothing
+ // if we we can't tell for sure.
+ Maybe<bool> IsWindowOnCurrentVirtualDesktop(HWND aHwnd);
+
+ static StaticRefPtr<WindowOcclusionCalculator> sCalculator;
+
+ // Map of root app window hwnds and their occlusion state. This contains
+ // both visible and hidden windows.
+ // It is accessed from WinWindowOcclusionTracker::UpdateOcclusionState()
+ // without using mutex. The access is safe by using
+ // SerializedTaskDispatcher.
+ std::unordered_map<HWND, OcclusionState> mRootWindowHwndsOcclusionState;
+
+ // Values returned by SetWinEventHook are stored so that hooks can be
+ // unregistered when necessary.
+ std::vector<HWINEVENTHOOK> mGlobalEventHooks;
+
+ // Map from process id to EVENT_OBJECT_LOCATIONCHANGE event hook.
+ std::unordered_map<DWORD, HWINEVENTHOOK> mProcessEventHooks;
+
+ // Pids of processes for which the EVENT_OBJECT_LOCATIONCHANGE event hook is
+ // set.
+ std::unordered_set<DWORD> mPidsForLocationChangeHook;
+
+ // Used as a timer to delay occlusion update.
+ RefPtr<CancelableRunnable> mOcclusionUpdateRunnable;
+
+ // Used to determine if a window is occluded. As we iterate through the
+ // hwnds in z-order, we subtract each opaque window's rect from
+ // mUnoccludedDesktopRegion. When we get to a root window, we subtract
+ // it from mUnoccludedDesktopRegion, and if mUnoccludedDesktopRegion
+ // doesn't change, the root window was already occluded.
+ LayoutDeviceIntRegion mUnoccludedDesktopRegion;
+
+ // Keeps track of how many root windows we need to compute the occlusion
+ // state of in a call to ComputeNativeWindowOcclusionStatus. Once we've
+ // determined the state of all root windows, we can stop subtracting
+ // windows from mUnoccludedDesktopRegion;.
+ int mNumRootWindowsWithUnknownOcclusionState;
+
+ // This is true if the task bar thumbnails or the alt tab thumbnails are
+ // showing.
+ bool mShowingThumbnails = false;
+
+ // Used to keep track of the window that's currently moving. That window
+ // is ignored for calculation occlusion so that tab dragging won't
+ // ignore windows occluded by the dragged window.
+ HWND mMovingWindow = 0;
+
+ // Only used on Win10+.
+ RefPtr<IVirtualDesktopManager> mVirtualDesktopManager;
+
+ // Used to serialize tasks related to mRootWindowHwndsOcclusionState.
+ RefPtr<SerializedTaskDispatcher> mSerializedTaskDispatcher;
+
+ // This is an alias to the singleton WinWindowOcclusionTracker mMonitor,
+ // and is used in ShutDown().
+ Monitor& mMonitor;
+
+ friend class OcclusionUpdateRunnable;
+ };
+
+ static BOOL CALLBACK DumpOccludingWindowsCallback(HWND aHWnd, LPARAM aLParam);
+
+ // Returns true if we are interested in |hwnd| for purposes of occlusion
+ // calculation. We are interested in |hwnd| if it is a window that is
+ // visible, opaque, bounded, and not a popup or floating window. If we are
+ // interested in |hwnd|, stores the window rectangle in |window_rect|.
+ static bool IsWindowVisibleAndFullyOpaque(HWND aHwnd,
+ LayoutDeviceIntRect* aWindowRect);
+
+ void Destroy();
+
+ static void CallUpdateOcclusionState(
+ std::unordered_map<HWND, OcclusionState>* aMap, bool aShowAllWindows);
+
+ // Updates root windows occclusion state. If aShowAllWindows is true,
+ // all non-hidden windows will be marked visible. This is used to force
+ // rendering of thumbnails.
+ void UpdateOcclusionState(std::unordered_map<HWND, OcclusionState>* aMap,
+ bool aShowAllWindows);
+
+ // This is called with session changed notifications. If the screen is locked
+ // by the current session, it marks app windows as occluded.
+ void OnSessionChange(WPARAM aStatusCode,
+ Maybe<bool> aIsCurrentSession) override;
+
+ // This is called when the display is put to sleep. If the display is sleeping
+ // it marks app windows as occluded.
+ void OnDisplayStateChanged(bool aDisplayOn) override;
+
+ // Marks all root windows as either occluded, or if hwnd IsIconic, hidden.
+ void MarkNonIconicWindowsOccluded();
+
+ static StaticRefPtr<WinWindowOcclusionTracker> sTracker;
+
+ // "WinWindowOcclusionCalc" thread.
+ UniquePtr<base::Thread> mThread;
+ Monitor mMonitor;
+
+ // Has ShutDown been called on us? We might have survived if our thread join
+ // timed out.
+ bool mHasAttemptedShutdown = false;
+
+ // Map of HWND to widget. Maintained on main thread, and used to send
+ // occlusion state notifications to Windows from
+ // mRootWindowHwndsOcclusionState.
+ std::unordered_map<HWND, nsWeakPtr> mHwndRootWindowMap;
+
+ // This is set by UpdateOcclusionState(). It is currently only used by tests.
+ int mNumVisibleRootWindows = 0;
+
+ // If the screen is locked, windows are considered occluded.
+ bool mScreenLocked = false;
+
+ // If the display is off, windows are considered occluded.
+ bool mDisplayOn = true;
+
+ RefPtr<DisplayStatusObserver> mDisplayStatusObserver;
+
+ RefPtr<SessionChangeObserver> mSessionChangeObserver;
+
+ // Used to serialize tasks related to mRootWindowHwndsOcclusionState.
+ RefPtr<SerializedTaskDispatcher> mSerializedTaskDispatcher;
+
+ friend class OcclusionUpdateRunnable;
+ friend class UpdateOcclusionStateRunnable;
+};
+
+} // namespace widget
+} // namespace mozilla
+
+#endif // widget_windows_WinWindowOcclusionTracker_h