widget/ScreenManager.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "ScreenManager.h"
   8
   9 #include "mozilla/ClearOnShutdown.h"
  10 #include "mozilla/dom/ContentParent.h"
  11 #include "mozilla/dom/DOMTypes.h"
  12 #include "mozilla/Logging.h"
  13 #include "mozilla/StaticPtr.h"
  14 #ifdef MOZ_WAYLAND
  15 #  include "mozilla/WidgetUtilsGtk.h"
  16 #endif /* MOZ_WAYLAND */
  17
  18 static mozilla::LazyLogModule sScreenLog("WidgetScreen");
  19
  20 namespace mozilla::widget {
  21
  22 NS_IMPL_ISUPPORTS(ScreenManager, nsIScreenManager)
  23
  24 ScreenManager::ScreenManager() = default;
  25
  26 ScreenManager::~ScreenManager() = default;
  27
  28 static StaticRefPtr<ScreenManager> sSingleton;
  29
  30 ScreenManager& ScreenManager::GetSingleton() {
  31   if (!sSingleton) {
  32     sSingleton = new ScreenManager();
  33     ClearOnShutdown(&sSingleton);
  34   }
  35   return *sSingleton;
  36 }
  37
  38 already_AddRefed<ScreenManager> ScreenManager::GetAddRefedSingleton() {
  39   RefPtr<ScreenManager> sm = &GetSingleton();
  40   return sm.forget();
  41 }
  42
  43 void ScreenManager::SetHelper(UniquePtr<Helper> aHelper) {
  44   mHelper = std::move(aHelper);
  45 }
  46
  47 // static
  48 void ScreenManager::Refresh(nsTArray<RefPtr<Screen>>&& aScreens) {
  49   if (PastShutdownPhase(ShutdownPhase::XPCOMShutdown)) {
  50     // We don't refresh screen data if starting XPCOM shutdown path.
  51     // GetSingleton returns invalid data since it is freed.
  52     return;
  53   }
  54   MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refresh screens"));
  55   GetSingleton().RefreshInternal(std::move(aScreens));
  56 }
  57
  58 void ScreenManager::Refresh(nsTArray<mozilla::dom::ScreenDetails>&& aScreens) {
  59   MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refresh screens from IPC"));
  60
  61   AutoTArray<RefPtr<Screen>, 4> screens;
  62   for (auto& screen : aScreens) {
  63     screens.AppendElement(new Screen(screen));
  64   }
  65   RefreshInternal(std::move(screens));
  66 }
  67
  68 void ScreenManager::RefreshInternal(nsTArray<RefPtr<Screen>>&& aScreens) {
  69   mScreenList = std::move(aScreens);
  70
  71   CopyScreensToAllRemotesIfIsParent();
  72   if (nsCOMPtr<nsIObserverService> s = services::GetObserverService()) {
  73     s->NotifyObservers(nullptr, "screen-information-changed", nullptr);
  74   }
  75 }
  76
  77 template <class Range>
  78 void ScreenManager::CopyScreensToRemoteRange(Range aRemoteRange) {
  79   AutoTArray<dom::ScreenDetails, 4> screens;
  80   for (auto& screen : mScreenList) {
  81     screens.AppendElement(screen->ToScreenDetails());
  82   }
  83   for (auto cp : aRemoteRange) {
  84     MOZ_LOG(sScreenLog, LogLevel::Debug,
  85             ("Send screens to [Pid %d]", cp->Pid()));
  86     if (!cp->SendRefreshScreens(screens)) {
  87       MOZ_LOG(sScreenLog, LogLevel::Error,
  88               ("SendRefreshScreens to [Pid %d] failed", cp->Pid()));
  89     }
  90   }
  91 }
  92
  93 void ScreenManager::CopyScreensToRemote(dom::ContentParent* aContentParent) {
  94   MOZ_ASSERT(aContentParent);
  95   MOZ_ASSERT(XRE_IsParentProcess());
  96
  97   auto range = {aContentParent};
  98   CopyScreensToRemoteRange(range);
  99 }
 100
 101 void ScreenManager::CopyScreensToAllRemotesIfIsParent() {
 102   if (XRE_IsContentProcess()) {
 103     return;
 104   }
 105
 106   MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refreshing all ContentParents"));
 107
 108   CopyScreensToRemoteRange(
 109       dom::ContentParent::AllProcesses(dom::ContentParent::eLive));
 110 }
 111
 112 // Returns the screen that contains the rectangle. If the rect overlaps
 113 // multiple screens, it picks the screen with the greatest area of intersection.
 114 //
 115 // The coordinates are in desktop pixels.
 116 //
 117 NS_IMETHODIMP
 118 ScreenManager::ScreenForRect(int32_t aX, int32_t aY, int32_t aWidth,
 119                              int32_t aHeight, nsIScreen** aOutScreen) {
 120   DesktopIntRect rect(aX, aY, aWidth, aHeight);
 121   nsCOMPtr<nsIScreen> screen = ScreenForRect(rect);
 122   screen.forget(aOutScreen);
 123   return NS_OK;
 124 }
 125
 126 already_AddRefed<Screen> ScreenManager::ScreenForRect(
 127     const DesktopIntRect& aRect) {
 128 #if defined(MOZ_WAYLAND) && defined(MOZ_LOGGING)
 129   static bool inWayland = GdkIsWaylandDisplay();
 130   if (inWayland) {
 131     MOZ_LOG(sScreenLog, LogLevel::Warning,
 132             ("Getting screen in wayland, primary display will be returned."));
 133   }
 134 #endif
 135
 136   if (mScreenList.IsEmpty()) {
 137     MOZ_LOG(sScreenLog, LogLevel::Warning,
 138             ("No screen available. This can happen in xpcshell."));
 139     auto screen = MakeRefPtr<Screen>(
 140         LayoutDeviceIntRect(), LayoutDeviceIntRect(), 0, 0, 0,
 141         DesktopToLayoutDeviceScale(), CSSToLayoutDeviceScale(), 96 /* dpi */,
 142         Screen::IsPseudoDisplay::No, Screen::IsHDR::No,
 143         hal::ScreenOrientation::None, 0);
 144     return screen.forget();
 145   }
 146
 147   // Optimize for the common case. If the number of screens is only
 148   // one then just return the primary screen.
 149   if (mScreenList.Length() == 1) {
 150     return GetPrimaryScreen();
 151   }
 152
 153   // which screen should we return?
 154   Screen* which = mScreenList[0].get();
 155
 156   // walk the list of screens and find the one that has the most
 157   // surface area.
 158   uint32_t area = 0;
 159   for (auto& screen : mScreenList) {
 160     int32_t x, y, width, height;
 161     x = y = width = height = 0;
 162     screen->GetRectDisplayPix(&x, &y, &width, &height);
 163     // calculate the surface area
 164     DesktopIntRect screenRect(x, y, width, height);
 165     screenRect.IntersectRect(screenRect, aRect);
 166     uint32_t tempArea = screenRect.Area();
 167     if (tempArea > area) {
 168       which = screen.get();
 169       area = tempArea;
 170     }
 171   }
 172
 173   // If the rect intersects one or more screen,
 174   // return the screen that has the largest intersection.
 175   if (area > 0) {
 176     RefPtr<Screen> ret = which;
 177     return ret.forget();
 178   }
 179
 180   // If the rect does not intersect a screen, find
 181   // a screen that is nearest to the rect.
 182   uint32_t distance = UINT32_MAX;
 183   for (auto& screen : mScreenList) {
 184     int32_t x, y, width, height;
 185     x = y = width = height = 0;
 186     screen->GetRectDisplayPix(&x, &y, &width, &height);
 187
 188     uint32_t distanceX = 0;
 189     if (aRect.x > (x + width)) {
 190       distanceX = aRect.x - (x + width);
 191     } else if (aRect.XMost() < x) {
 192       distanceX = x - aRect.XMost();
 193     }
 194
 195     uint32_t distanceY = 0;
 196     if (aRect.y > (y + height)) {
 197       distanceY = aRect.y - (y + height);
 198     } else if (aRect.YMost() < y) {
 199       distanceY = y - aRect.YMost();
 200     }
 201
 202     uint32_t tempDistance = distanceX * distanceX + distanceY * distanceY;
 203     if (tempDistance < distance) {
 204       which = screen.get();
 205       distance = tempDistance;
 206       if (distance == 0) {
 207         break;
 208       }
 209     }
 210   }
 211
 212   RefPtr<Screen> ret = which;
 213   return ret.forget();
 214 }
 215
 216 // The screen with the menubar/taskbar. This shouldn't be needed very
 217 // often.
 218 //
 219 already_AddRefed<Screen> ScreenManager::GetPrimaryScreen() {
 220   if (mScreenList.IsEmpty()) {
 221     MOZ_LOG(sScreenLog, LogLevel::Warning,
 222             ("No screen available. This can happen in xpcshell."));
 223     return MakeAndAddRef<Screen>(LayoutDeviceIntRect(), LayoutDeviceIntRect(),
 224                                  0, 0, 0, DesktopToLayoutDeviceScale(),
 225                                  CSSToLayoutDeviceScale(), 96 /* dpi */,
 226                                  Screen::IsPseudoDisplay::No, Screen::IsHDR::No,
 227                                  hal::ScreenOrientation::None, 0);
 228   }
 229
 230   return do_AddRef(mScreenList[0]);
 231 }
 232
 233 NS_IMETHODIMP
 234 ScreenManager::GetPrimaryScreen(nsIScreen** aPrimaryScreen) {
 235   nsCOMPtr<nsIScreen> screen = GetPrimaryScreen();
 236   screen.forget(aPrimaryScreen);
 237   return NS_OK;
 238 }
 239
 240 NS_IMETHODIMP
 241 ScreenManager::GetTotalScreenPixels(int64_t* aTotalScreenPixels) {
 242   MOZ_ASSERT(aTotalScreenPixels);
 243
 244   if (mScreenList.IsEmpty()) {
 245     MOZ_LOG(sScreenLog, LogLevel::Warning,
 246             ("No screen available. This can happen in xpcshell."));
 247     *aTotalScreenPixels = 0;
 248     return NS_OK;
 249   }
 250
 251   int64_t pixels = 0;
 252   for (auto& screen : mScreenList) {
 253     int32_t x, y, width, height;
 254     x = y = width = height = 0;
 255     screen->GetRect(&x, &y, &width, &height);
 256     pixels += width * height;
 257   }
 258
 259   *aTotalScreenPixels = pixels;
 260   return NS_OK;
 261 }
 262
 263 }  // namespace mozilla::widget