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