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