hal/Hal.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=8 et ft=cpp : */
   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "Hal.h"
   8
   9 #include "HalImpl.h"
  10 #include "HalLog.h"
  11 #include "HalSandbox.h"
  12 #include "HalWakeLockInternal.h"
  13 #include "mozilla/dom/Document.h"
  14 #include "nsThreadUtils.h"
  15 #include "nsXULAppAPI.h"
  16 #include "nsPIDOMWindow.h"
  17 #include "nsJSUtils.h"
  18 #include "mozilla/ClearOnShutdown.h"
  19 #include "mozilla/Observer.h"
  20 #include "mozilla/dom/ContentChild.h"
  21 #include "WindowIdentifier.h"
  22
  23 #ifdef XP_WIN
  24 #  include <process.h>
  25 #  define getpid _getpid
  26 #endif
  27
  28 using namespace mozilla::services;
  29 using namespace mozilla::dom;
  30
  31 #define PROXY_IF_SANDBOXED(_call)              \
  32   do {                                         \
  33     if (InSandbox()) {                         \
  34       if (!hal_sandbox::HalChildDestroyed()) { \
  35         hal_sandbox::_call;                    \
  36       }                                        \
  37     } else {                                   \
  38       hal_impl::_call;                         \
  39     }                                          \
  40   } while (0)
  41
  42 #define RETURN_PROXY_IF_SANDBOXED(_call, defValue) \
  43   do {                                             \
  44     if (InSandbox()) {                             \
  45       if (hal_sandbox::HalChildDestroyed()) {      \
  46         return defValue;                           \
  47       }                                            \
  48       return hal_sandbox::_call;                   \
  49     } else {                                       \
  50       return hal_impl::_call;                      \
  51     }                                              \
  52   } while (0)
  53
  54 namespace mozilla::hal {
  55
  56 static bool sInitialized = false;
  57
  58 mozilla::LogModule* GetHalLog() {
  59   static mozilla::LazyLogModule sHalLog("hal");
  60   return sHalLog;
  61 }
  62
  63 namespace {
  64
  65 void AssertMainThread() { MOZ_ASSERT(NS_IsMainThread()); }
  66
  67 bool InSandbox() { return GeckoProcessType_Content == XRE_GetProcessType(); }
  68
  69 bool WindowIsActive(nsPIDOMWindowInner* aWindow) {
  70   dom::Document* document = aWindow->GetDoc();
  71   NS_ENSURE_TRUE(document, false);
  72   return !document->Hidden();
  73 }
  74
  75 StaticAutoPtr<WindowIdentifier::IDArrayType> gLastIDToVibrate;
  76
  77 static void RecordLastIDToVibrate(const WindowIdentifier& aId) {
  78   if (!InSandbox()) {
  79     *gLastIDToVibrate = aId.AsArray().Clone();
  80   }
  81 }
  82
  83 static bool MayCancelVibration(const WindowIdentifier& aId) {
  84   // Although only active windows may start vibrations, a window may
  85   // cancel its own vibration even if it's no longer active.
  86   //
  87   // After a window is marked as inactive, it sends a CancelVibrate
  88   // request.  We want this request to cancel a playing vibration
  89   // started by that window, so we certainly don't want to reject the
  90   // cancellation request because the window is now inactive.
  91   //
  92   // But it could be the case that, after this window became inactive,
  93   // some other window came along and started a vibration.  We don't
  94   // want this window's cancellation request to cancel that window's
  95   // actively-playing vibration!
  96   //
  97   // To solve this problem, we keep track of the id of the last window
  98   // to start a vibration, and only accepts cancellation requests from
  99   // the same window.  All other cancellation requests are ignored.
 100
 101   return InSandbox() || (*gLastIDToVibrate == aId.AsArray());
 102 }
 103
 104 }  // namespace
 105
 106 void Vibrate(const nsTArray<uint32_t>& pattern, nsPIDOMWindowInner* window) {
 107   Vibrate(pattern, WindowIdentifier(window));
 108 }
 109
 110 void Vibrate(const nsTArray<uint32_t>& pattern, WindowIdentifier&& id) {
 111   AssertMainThread();
 112
 113   // Only active windows may start vibrations.  If |id| hasn't gone
 114   // through the IPC layer -- that is, if our caller is the outside
 115   // world, not hal_proxy -- check whether the window is active.  If
 116   // |id| has gone through IPC, don't check the window's visibility;
 117   // only the window corresponding to the bottommost process has its
 118   // visibility state set correctly.
 119   if (!id.HasTraveledThroughIPC() && !WindowIsActive(id.GetWindow())) {
 120     HAL_LOG("Vibrate: Window is inactive, dropping vibrate.");
 121     return;
 122   }
 123
 124   RecordLastIDToVibrate(id);
 125
 126   // Don't forward our ID if we are not in the sandbox, because hal_impl
 127   // doesn't need it, and we don't want it to be tempted to read it.  The
 128   // empty identifier will assert if it's used.
 129   PROXY_IF_SANDBOXED(
 130       Vibrate(pattern, InSandbox() ? std::move(id) : WindowIdentifier()));
 131 }
 132
 133 void CancelVibrate(nsPIDOMWindowInner* window) {
 134   CancelVibrate(WindowIdentifier(window));
 135 }
 136
 137 void CancelVibrate(WindowIdentifier&& id) {
 138   AssertMainThread();
 139
 140   if (MayCancelVibration(id)) {
 141     // Don't forward our ID if we are not in the sandbox, because hal_impl
 142     // doesn't need it, and we don't want it to be tempted to read it.  The
 143     // empty identifier will assert if it's used.
 144     PROXY_IF_SANDBOXED(
 145         CancelVibrate(InSandbox() ? std::move(id) : WindowIdentifier()));
 146   }
 147 }
 148
 149 template <class InfoType>
 150 class ObserversManager {
 151  public:
 152   void AddObserver(Observer<InfoType>* aObserver) {
 153     mObservers.AddObserver(aObserver);
 154
 155     if (mObservers.Length() == 1) {
 156       EnableNotifications();
 157     }
 158   }
 159
 160   void RemoveObserver(Observer<InfoType>* aObserver) {
 161     bool removed = mObservers.RemoveObserver(aObserver);
 162     if (!removed) {
 163       return;
 164     }
 165
 166     if (mObservers.Length() == 0) {
 167       DisableNotifications();
 168       OnNotificationsDisabled();
 169     }
 170   }
 171
 172   void BroadcastInformation(const InfoType& aInfo) {
 173     mObservers.Broadcast(aInfo);
 174   }
 175
 176  protected:
 177   ~ObserversManager() { MOZ_ASSERT(mObservers.Length() == 0); }
 178
 179   virtual void EnableNotifications() = 0;
 180   virtual void DisableNotifications() = 0;
 181   virtual void OnNotificationsDisabled() {}
 182
 183  private:
 184   mozilla::ObserverList<InfoType> mObservers;
 185 };
 186
 187 template <class InfoType>
 188 class CachingObserversManager : public ObserversManager<InfoType> {
 189  public:
 190   InfoType GetCurrentInformation() {
 191     if (mHasValidCache) {
 192       return mInfo;
 193     }
 194
 195     GetCurrentInformationInternal(&mInfo);
 196     mHasValidCache = true;
 197     return mInfo;
 198   }
 199
 200   void CacheInformation(const InfoType& aInfo) {
 201     mHasValidCache = true;
 202     mInfo = aInfo;
 203   }
 204
 205   void BroadcastCachedInformation() { this->BroadcastInformation(mInfo); }
 206
 207  protected:
 208   virtual void GetCurrentInformationInternal(InfoType*) = 0;
 209
 210   void OnNotificationsDisabled() override { mHasValidCache = false; }
 211
 212  private:
 213   InfoType mInfo;
 214   bool mHasValidCache;
 215 };
 216
 217 class BatteryObserversManager final
 218     : public CachingObserversManager<BatteryInformation> {
 219  protected:
 220   void EnableNotifications() override {
 221     PROXY_IF_SANDBOXED(EnableBatteryNotifications());
 222   }
 223
 224   void DisableNotifications() override {
 225     PROXY_IF_SANDBOXED(DisableBatteryNotifications());
 226   }
 227
 228   void GetCurrentInformationInternal(BatteryInformation* aInfo) override {
 229     PROXY_IF_SANDBOXED(GetCurrentBatteryInformation(aInfo));
 230   }
 231 };
 232
 233 class NetworkObserversManager final
 234     : public CachingObserversManager<NetworkInformation> {
 235  protected:
 236   void EnableNotifications() override {
 237     PROXY_IF_SANDBOXED(EnableNetworkNotifications());
 238   }
 239
 240   void DisableNotifications() override {
 241     PROXY_IF_SANDBOXED(DisableNetworkNotifications());
 242   }
 243
 244   void GetCurrentInformationInternal(NetworkInformation* aInfo) override {
 245     PROXY_IF_SANDBOXED(GetCurrentNetworkInformation(aInfo));
 246   }
 247 };
 248
 249 class WakeLockObserversManager final
 250     : public ObserversManager<WakeLockInformation> {
 251  protected:
 252   void EnableNotifications() override {
 253     PROXY_IF_SANDBOXED(EnableWakeLockNotifications());
 254   }
 255
 256   void DisableNotifications() override {
 257     PROXY_IF_SANDBOXED(DisableWakeLockNotifications());
 258   }
 259 };
 260
 261 class ScreenConfigurationObserversManager final
 262     : public CachingObserversManager<ScreenConfiguration> {
 263  protected:
 264   void EnableNotifications() override {
 265     PROXY_IF_SANDBOXED(EnableScreenConfigurationNotifications());
 266   }
 267
 268   void DisableNotifications() override {
 269     PROXY_IF_SANDBOXED(DisableScreenConfigurationNotifications());
 270   }
 271
 272   void GetCurrentInformationInternal(ScreenConfiguration* aInfo) override {
 273     PROXY_IF_SANDBOXED(GetCurrentScreenConfiguration(aInfo));
 274   }
 275 };
 276
 277 typedef mozilla::ObserverList<SensorData> SensorObserverList;
 278 StaticAutoPtr<SensorObserverList> sSensorObservers[NUM_SENSOR_TYPE];
 279
 280 static SensorObserverList* GetSensorObservers(SensorType sensor_type) {
 281   AssertMainThread();
 282   MOZ_ASSERT(sensor_type < NUM_SENSOR_TYPE);
 283
 284   if (!sSensorObservers[sensor_type]) {
 285     sSensorObservers[sensor_type] = new SensorObserverList();
 286   }
 287
 288   return sSensorObservers[sensor_type];
 289 }
 290
 291 #define MOZ_IMPL_HAL_OBSERVER(name_)                             \
 292   StaticAutoPtr<name_##ObserversManager> s##name_##Observers;    \
 293                                                                  \
 294   static name_##ObserversManager* name_##Observers() {           \
 295     AssertMainThread();                                          \
 296                                                                  \
 297     if (!s##name_##Observers) {                                  \
 298       MOZ_ASSERT(sInitialized);                                  \
 299       s##name_##Observers = new name_##ObserversManager();       \
 300     }                                                            \
 301                                                                  \
 302     return s##name_##Observers;                                  \
 303   }                                                              \
 304                                                                  \
 305   void Register##name_##Observer(name_##Observer* aObserver) {   \
 306     AssertMainThread();                                          \
 307     name_##Observers()->AddObserver(aObserver);                  \
 308   }                                                              \
 309                                                                  \
 310   void Unregister##name_##Observer(name_##Observer* aObserver) { \
 311     AssertMainThread();                                          \
 312     name_##Observers()->RemoveObserver(aObserver);               \
 313   }
 314
 315 MOZ_IMPL_HAL_OBSERVER(Battery)
 316
 317 void GetCurrentBatteryInformation(BatteryInformation* aInfo) {
 318   *aInfo = BatteryObservers()->GetCurrentInformation();
 319 }
 320
 321 void NotifyBatteryChange(const BatteryInformation& aInfo) {
 322   BatteryObservers()->CacheInformation(aInfo);
 323   BatteryObservers()->BroadcastCachedInformation();
 324 }
 325
 326 void EnableSensorNotifications(SensorType aSensor) {
 327   AssertMainThread();
 328   PROXY_IF_SANDBOXED(EnableSensorNotifications(aSensor));
 329 }
 330
 331 void DisableSensorNotifications(SensorType aSensor) {
 332   AssertMainThread();
 333   PROXY_IF_SANDBOXED(DisableSensorNotifications(aSensor));
 334 }
 335
 336 void RegisterSensorObserver(SensorType aSensor, ISensorObserver* aObserver) {
 337   SensorObserverList* observers = GetSensorObservers(aSensor);
 338
 339   observers->AddObserver(aObserver);
 340   if (observers->Length() == 1) {
 341     EnableSensorNotifications(aSensor);
 342   }
 343 }
 344
 345 void UnregisterSensorObserver(SensorType aSensor, ISensorObserver* aObserver) {
 346   SensorObserverList* observers = GetSensorObservers(aSensor);
 347   if (!observers->RemoveObserver(aObserver) || observers->Length() > 0) {
 348     return;
 349   }
 350   DisableSensorNotifications(aSensor);
 351 }
 352
 353 void NotifySensorChange(const SensorData& aSensorData) {
 354   SensorObserverList* observers = GetSensorObservers(aSensorData.sensor());
 355
 356   observers->Broadcast(aSensorData);
 357 }
 358
 359 MOZ_IMPL_HAL_OBSERVER(Network)
 360
 361 void GetCurrentNetworkInformation(NetworkInformation* aInfo) {
 362   *aInfo = NetworkObservers()->GetCurrentInformation();
 363 }
 364
 365 void NotifyNetworkChange(const NetworkInformation& aInfo) {
 366   NetworkObservers()->CacheInformation(aInfo);
 367   NetworkObservers()->BroadcastCachedInformation();
 368 }
 369
 370 MOZ_IMPL_HAL_OBSERVER(WakeLock)
 371
 372 void ModifyWakeLock(const nsAString& aTopic, WakeLockControl aLockAdjust,
 373                     WakeLockControl aHiddenAdjust,
 374                     uint64_t aProcessID /* = CONTENT_PROCESS_ID_UNKNOWN */) {
 375   AssertMainThread();
 376
 377   if (aProcessID == CONTENT_PROCESS_ID_UNKNOWN) {
 378     aProcessID = InSandbox() ? ContentChild::GetSingleton()->GetID()
 379                              : CONTENT_PROCESS_ID_MAIN;
 380   }
 381
 382   PROXY_IF_SANDBOXED(
 383       ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust, aProcessID));
 384 }
 385
 386 void GetWakeLockInfo(const nsAString& aTopic,
 387                      WakeLockInformation* aWakeLockInfo) {
 388   AssertMainThread();
 389   PROXY_IF_SANDBOXED(GetWakeLockInfo(aTopic, aWakeLockInfo));
 390 }
 391
 392 void NotifyWakeLockChange(const WakeLockInformation& aInfo) {
 393   AssertMainThread();
 394   WakeLockObservers()->BroadcastInformation(aInfo);
 395 }
 396
 397 MOZ_IMPL_HAL_OBSERVER(ScreenConfiguration)
 398
 399 void GetCurrentScreenConfiguration(ScreenConfiguration* aScreenConfiguration) {
 400   *aScreenConfiguration =
 401       ScreenConfigurationObservers()->GetCurrentInformation();
 402 }
 403
 404 void NotifyScreenConfigurationChange(
 405     const ScreenConfiguration& aScreenConfiguration) {
 406   ScreenConfigurationObservers()->CacheInformation(aScreenConfiguration);
 407   ScreenConfigurationObservers()->BroadcastCachedInformation();
 408 }
 409
 410 bool LockScreenOrientation(const ScreenOrientation& aOrientation) {
 411   AssertMainThread();
 412   RETURN_PROXY_IF_SANDBOXED(LockScreenOrientation(aOrientation), false);
 413 }
 414
 415 void UnlockScreenOrientation() {
 416   AssertMainThread();
 417   PROXY_IF_SANDBOXED(UnlockScreenOrientation());
 418 }
 419
 420 void SetProcessPriority(int aPid, ProcessPriority aPriority) {
 421   // n.b. The sandboxed implementation crashes; SetProcessPriority works only
 422   // from the main process.
 423   PROXY_IF_SANDBOXED(SetProcessPriority(aPid, aPriority));
 424 }
 425
 426 // From HalTypes.h.
 427 const char* ProcessPriorityToString(ProcessPriority aPriority) {
 428   switch (aPriority) {
 429     case PROCESS_PRIORITY_PARENT_PROCESS:
 430       return "PARENT_PROCESS";
 431     case PROCESS_PRIORITY_PREALLOC:
 432       return "PREALLOC";
 433     case PROCESS_PRIORITY_FOREGROUND_HIGH:
 434       return "FOREGROUND_HIGH";
 435     case PROCESS_PRIORITY_FOREGROUND:
 436       return "FOREGROUND";
 437     case PROCESS_PRIORITY_FOREGROUND_KEYBOARD:
 438       return "FOREGROUND_KEYBOARD";
 439     case PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE:
 440       return "BACKGROUND_PERCEIVABLE";
 441     case PROCESS_PRIORITY_BACKGROUND:
 442       return "BACKGROUND";
 443     case PROCESS_PRIORITY_UNKNOWN:
 444       return "UNKNOWN";
 445     default:
 446       MOZ_ASSERT(false);
 447       return "???";
 448   }
 449 }
 450
 451 void Init() {
 452   MOZ_ASSERT(!sInitialized);
 453
 454   if (!InSandbox()) {
 455     gLastIDToVibrate = new WindowIdentifier::IDArrayType();
 456   }
 457
 458   WakeLockInit();
 459
 460   sInitialized = true;
 461 }
 462
 463 void Shutdown() {
 464   MOZ_ASSERT(sInitialized);
 465
 466   gLastIDToVibrate = nullptr;
 467
 468   sBatteryObservers = nullptr;
 469   sNetworkObservers = nullptr;
 470   sWakeLockObservers = nullptr;
 471   sScreenConfigurationObservers = nullptr;
 472
 473   for (auto& sensorObserver : sSensorObservers) {
 474     sensorObserver = nullptr;
 475   }
 476
 477   sInitialized = false;
 478 }
 479
 480 }  // namespace mozilla::hal