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 #include "HalImpl.h"
   9 #include "HalLog.h"
  10 #include "HalSandbox.h"
  11 #include "nsThreadUtils.h"
  12 #include "nsXULAppAPI.h"
  13 #include "mozilla/Observer.h"
  14 #include "nsIDocument.h"
  15 #include "nsIDOMDocument.h"
  16 #include "nsPIDOMWindow.h"
  17 #include "nsIDOMWindow.h"
  18 #include "mozilla/Services.h"
  19 #include "nsIWebNavigation.h"
  20 #include "nsITabChild.h"
  21 #include "nsIDocShell.h"
  22 #include "mozilla/StaticPtr.h"
  23 #include "mozilla/ClearOnShutdown.h"
  24 #include "WindowIdentifier.h"
  25 #include "mozilla/dom/ScreenOrientation.h"
  26 #include "mozilla/dom/ContentChild.h"
  27 #include "mozilla/dom/ContentParent.h"
  28
  29 #ifdef XP_WIN
  30 #include <process.h>
  31 #define getpid _getpid
  32 #endif
  33
  34 using namespace mozilla::services;
  35 using namespace mozilla::dom;
  36
  37 #define PROXY_IF_SANDBOXED(_call)                 \
  38   do {                                            \
  39     if (InSandbox()) {                            \
  40       if (!hal_sandbox::HalChildDestroyed()) {    \
  41         hal_sandbox::_call;                       \
  42       }                                           \
  43     } else {                                      \
  44       hal_impl::_call;                            \
  45     }                                             \
  46   } while (0)
  47
  48 #define RETURN_PROXY_IF_SANDBOXED(_call, defValue)\
  49   do {                                            \
  50     if (InSandbox()) {                            \
  51       if (hal_sandbox::HalChildDestroyed()) {     \
  52         return defValue;                          \
  53       }                                           \
  54       return hal_sandbox::_call;                  \
  55     } else {                                      \
  56       return hal_impl::_call;                     \
  57     }                                             \
  58   } while (0)
  59
  60 namespace mozilla {
  61 namespace hal {
  62
  63 PRLogModuleInfo *
  64 GetHalLog()
  65 {
  66   static PRLogModuleInfo *sHalLog;
  67   if (!sHalLog) {
  68     sHalLog = PR_NewLogModule("hal");
  69   }
  70   return sHalLog;
  71 }
  72
  73 namespace {
  74
  75 void
  76 AssertMainThread()
  77 {
  78   MOZ_ASSERT(NS_IsMainThread());
  79 }
  80
  81 bool
  82 InSandbox()
  83 {
  84   return GeckoProcessType_Content == XRE_GetProcessType();
  85 }
  86
  87 void
  88 AssertMainProcess()
  89 {
  90   MOZ_ASSERT(GeckoProcessType_Default == XRE_GetProcessType());
  91 }
  92
  93 bool
  94 WindowIsActive(nsIDOMWindow* aWindow)
  95 {
  96   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aWindow);
  97   NS_ENSURE_TRUE(window, false);
  98
  99   nsIDocument* document = window->GetDoc();
 100   NS_ENSURE_TRUE(document, false);
 101
 102   return !document->Hidden();
 103 }
 104
 105 StaticAutoPtr<WindowIdentifier::IDArrayType> gLastIDToVibrate;
 106
 107 void InitLastIDToVibrate()
 108 {
 109   gLastIDToVibrate = new WindowIdentifier::IDArrayType();
 110   ClearOnShutdown(&gLastIDToVibrate);
 111 }
 112
 113 } // anonymous namespace
 114
 115 void
 116 Vibrate(const nsTArray<uint32_t>& pattern, nsIDOMWindow* window)
 117 {
 118   Vibrate(pattern, WindowIdentifier(window));
 119 }
 120
 121 void
 122 Vibrate(const nsTArray<uint32_t>& pattern, const WindowIdentifier &id)
 123 {
 124   AssertMainThread();
 125
 126   // Only active windows may start vibrations.  If |id| hasn't gone
 127   // through the IPC layer -- that is, if our caller is the outside
 128   // world, not hal_proxy -- check whether the window is active.  If
 129   // |id| has gone through IPC, don't check the window's visibility;
 130   // only the window corresponding to the bottommost process has its
 131   // visibility state set correctly.
 132   if (!id.HasTraveledThroughIPC() && !WindowIsActive(id.GetWindow())) {
 133     HAL_LOG("Vibrate: Window is inactive, dropping vibrate.");
 134     return;
 135   }
 136
 137   if (!InSandbox()) {
 138     if (!gLastIDToVibrate) {
 139       InitLastIDToVibrate();
 140     }
 141     *gLastIDToVibrate = id.AsArray();
 142   }
 143
 144   // Don't forward our ID if we are not in the sandbox, because hal_impl
 145   // doesn't need it, and we don't want it to be tempted to read it.  The
 146   // empty identifier will assert if it's used.
 147   PROXY_IF_SANDBOXED(Vibrate(pattern, InSandbox() ? id : WindowIdentifier()));
 148 }
 149
 150 void
 151 CancelVibrate(nsIDOMWindow* window)
 152 {
 153   CancelVibrate(WindowIdentifier(window));
 154 }
 155
 156 void
 157 CancelVibrate(const WindowIdentifier &id)
 158 {
 159   AssertMainThread();
 160
 161   // Although only active windows may start vibrations, a window may
 162   // cancel its own vibration even if it's no longer active.
 163   //
 164   // After a window is marked as inactive, it sends a CancelVibrate
 165   // request.  We want this request to cancel a playing vibration
 166   // started by that window, so we certainly don't want to reject the
 167   // cancellation request because the window is now inactive.
 168   //
 169   // But it could be the case that, after this window became inactive,
 170   // some other window came along and started a vibration.  We don't
 171   // want this window's cancellation request to cancel that window's
 172   // actively-playing vibration!
 173   //
 174   // To solve this problem, we keep track of the id of the last window
 175   // to start a vibration, and only accepts cancellation requests from
 176   // the same window.  All other cancellation requests are ignored.
 177
 178   if (InSandbox() || (gLastIDToVibrate && *gLastIDToVibrate == id.AsArray())) {
 179     // Don't forward our ID if we are not in the sandbox, because hal_impl
 180     // doesn't need it, and we don't want it to be tempted to read it.  The
 181     // empty identifier will assert if it's used.
 182     PROXY_IF_SANDBOXED(CancelVibrate(InSandbox() ? id : WindowIdentifier()));
 183   }
 184 }
 185
 186 template <class InfoType>
 187 class ObserversManager
 188 {
 189 public:
 190   void AddObserver(Observer<InfoType>* aObserver) {
 191     if (!mObservers) {
 192       mObservers = new mozilla::ObserverList<InfoType>();
 193     }
 194
 195     mObservers->AddObserver(aObserver);
 196
 197     if (mObservers->Length() == 1) {
 198       EnableNotifications();
 199     }
 200   }
 201
 202   void RemoveObserver(Observer<InfoType>* aObserver) {
 203     bool removed = mObservers && mObservers->RemoveObserver(aObserver);
 204     if (!removed) {
 205       NS_WARNING("RemoveObserver() called for unregistered observer");
 206       return;
 207     }
 208
 209     if (mObservers->Length() == 0) {
 210       DisableNotifications();
 211
 212       OnNotificationsDisabled();
 213
 214       delete mObservers;
 215       mObservers = nullptr;
 216     }
 217   }
 218
 219   void BroadcastInformation(const InfoType& aInfo) {
 220     // It is possible for mObservers to be nullptr here on some platforms,
 221     // because a call to BroadcastInformation gets queued up asynchronously
 222     // while RemoveObserver is running (and before the notifications are
 223     // disabled). The queued call can then get run after mObservers has
 224     // been nulled out. See bug 757025.
 225     if (!mObservers) {
 226       return;
 227     }
 228     mObservers->Broadcast(aInfo);
 229   }
 230
 231 protected:
 232   virtual void EnableNotifications() = 0;
 233   virtual void DisableNotifications() = 0;
 234   virtual void OnNotificationsDisabled() {}
 235
 236 private:
 237   mozilla::ObserverList<InfoType>* mObservers;
 238 };
 239
 240 template <class InfoType>
 241 class CachingObserversManager : public ObserversManager<InfoType>
 242 {
 243 public:
 244   InfoType GetCurrentInformation() {
 245     if (mHasValidCache) {
 246       return mInfo;
 247     }
 248
 249     GetCurrentInformationInternal(&mInfo);
 250     mHasValidCache = true;
 251     return mInfo;
 252   }
 253
 254   void CacheInformation(const InfoType& aInfo) {
 255     mHasValidCache = true;
 256     mInfo = aInfo;
 257   }
 258
 259   void BroadcastCachedInformation() {
 260     this->BroadcastInformation(mInfo);
 261   }
 262
 263 protected:
 264   virtual void GetCurrentInformationInternal(InfoType*) = 0;
 265
 266   virtual void OnNotificationsDisabled() {
 267     mHasValidCache = false;
 268   }
 269
 270 private:
 271   InfoType                mInfo;
 272   bool                    mHasValidCache;
 273 };
 274
 275 class BatteryObserversManager : public CachingObserversManager<BatteryInformation>
 276 {
 277 protected:
 278   void EnableNotifications() {
 279     PROXY_IF_SANDBOXED(EnableBatteryNotifications());
 280   }
 281
 282   void DisableNotifications() {
 283     PROXY_IF_SANDBOXED(DisableBatteryNotifications());
 284   }
 285
 286   void GetCurrentInformationInternal(BatteryInformation* aInfo) {
 287     PROXY_IF_SANDBOXED(GetCurrentBatteryInformation(aInfo));
 288   }
 289 };
 290
 291 static BatteryObserversManager sBatteryObservers;
 292
 293 class NetworkObserversManager : public CachingObserversManager<NetworkInformation>
 294 {
 295 protected:
 296   void EnableNotifications() {
 297     PROXY_IF_SANDBOXED(EnableNetworkNotifications());
 298   }
 299
 300   void DisableNotifications() {
 301     PROXY_IF_SANDBOXED(DisableNetworkNotifications());
 302   }
 303
 304   void GetCurrentInformationInternal(NetworkInformation* aInfo) {
 305     PROXY_IF_SANDBOXED(GetCurrentNetworkInformation(aInfo));
 306   }
 307 };
 308
 309 static NetworkObserversManager sNetworkObservers;
 310
 311 class WakeLockObserversManager : public ObserversManager<WakeLockInformation>
 312 {
 313 protected:
 314   void EnableNotifications() {
 315     PROXY_IF_SANDBOXED(EnableWakeLockNotifications());
 316   }
 317
 318   void DisableNotifications() {
 319     PROXY_IF_SANDBOXED(DisableWakeLockNotifications());
 320   }
 321 };
 322
 323 static WakeLockObserversManager sWakeLockObservers;
 324
 325 class ScreenConfigurationObserversManager : public CachingObserversManager<ScreenConfiguration>
 326 {
 327 protected:
 328   void EnableNotifications() {
 329     PROXY_IF_SANDBOXED(EnableScreenConfigurationNotifications());
 330   }
 331
 332   void DisableNotifications() {
 333     PROXY_IF_SANDBOXED(DisableScreenConfigurationNotifications());
 334   }
 335
 336   void GetCurrentInformationInternal(ScreenConfiguration* aInfo) {
 337     PROXY_IF_SANDBOXED(GetCurrentScreenConfiguration(aInfo));
 338   }
 339 };
 340
 341 static ScreenConfigurationObserversManager sScreenConfigurationObservers;
 342
 343 void
 344 RegisterBatteryObserver(BatteryObserver* aObserver)
 345 {
 346   AssertMainThread();
 347   sBatteryObservers.AddObserver(aObserver);
 348 }
 349
 350 void
 351 UnregisterBatteryObserver(BatteryObserver* aObserver)
 352 {
 353   AssertMainThread();
 354   sBatteryObservers.RemoveObserver(aObserver);
 355 }
 356
 357 void
 358 GetCurrentBatteryInformation(BatteryInformation* aInfo)
 359 {
 360   AssertMainThread();
 361   *aInfo = sBatteryObservers.GetCurrentInformation();
 362 }
 363
 364 void
 365 NotifyBatteryChange(const BatteryInformation& aInfo)
 366 {
 367   AssertMainThread();
 368   sBatteryObservers.CacheInformation(aInfo);
 369   sBatteryObservers.BroadcastCachedInformation();
 370 }
 371
 372 bool GetScreenEnabled()
 373 {
 374   AssertMainThread();
 375   RETURN_PROXY_IF_SANDBOXED(GetScreenEnabled(), false);
 376 }
 377
 378 void SetScreenEnabled(bool aEnabled)
 379 {
 380   AssertMainThread();
 381   PROXY_IF_SANDBOXED(SetScreenEnabled(aEnabled));
 382 }
 383
 384 bool GetKeyLightEnabled()
 385 {
 386   AssertMainThread();
 387   RETURN_PROXY_IF_SANDBOXED(GetKeyLightEnabled(), false);
 388 }
 389
 390 void SetKeyLightEnabled(bool aEnabled)
 391 {
 392   AssertMainThread();
 393   PROXY_IF_SANDBOXED(SetKeyLightEnabled(aEnabled));
 394 }
 395
 396 bool GetCpuSleepAllowed()
 397 {
 398   // Generally for interfaces that are accessible by normal web content
 399   // we should cache the result and be notified on state changes, like
 400   // what the battery API does. But since this is only used by
 401   // privileged interface, the synchronous getter is OK here.
 402   AssertMainThread();
 403   RETURN_PROXY_IF_SANDBOXED(GetCpuSleepAllowed(), true);
 404 }
 405
 406 void SetCpuSleepAllowed(bool aAllowed)
 407 {
 408   AssertMainThread();
 409   PROXY_IF_SANDBOXED(SetCpuSleepAllowed(aAllowed));
 410 }
 411
 412 double GetScreenBrightness()
 413 {
 414   AssertMainThread();
 415   RETURN_PROXY_IF_SANDBOXED(GetScreenBrightness(), 0);
 416 }
 417
 418 void SetScreenBrightness(double aBrightness)
 419 {
 420   AssertMainThread();
 421   PROXY_IF_SANDBOXED(SetScreenBrightness(clamped(aBrightness, 0.0, 1.0)));
 422 }
 423
 424 class SystemClockChangeObserversManager : public ObserversManager<int64_t>
 425 {
 426 protected:
 427   void EnableNotifications() {
 428     PROXY_IF_SANDBOXED(EnableSystemClockChangeNotifications());
 429   }
 430
 431   void DisableNotifications() {
 432     PROXY_IF_SANDBOXED(DisableSystemClockChangeNotifications());
 433   }
 434 };
 435
 436 static SystemClockChangeObserversManager sSystemClockChangeObservers;
 437
 438 void
 439 RegisterSystemClockChangeObserver(SystemClockChangeObserver* aObserver)
 440 {
 441   AssertMainThread();
 442   sSystemClockChangeObservers.AddObserver(aObserver);
 443 }
 444
 445 void
 446 UnregisterSystemClockChangeObserver(SystemClockChangeObserver* aObserver)
 447 {
 448   AssertMainThread();
 449   sSystemClockChangeObservers.RemoveObserver(aObserver);
 450 }
 451
 452 void
 453 NotifySystemClockChange(const int64_t& aClockDeltaMS)
 454 {
 455   sSystemClockChangeObservers.BroadcastInformation(aClockDeltaMS);
 456 }
 457
 458 class SystemTimezoneChangeObserversManager : public ObserversManager<SystemTimezoneChangeInformation>
 459 {
 460 protected:
 461   void EnableNotifications() {
 462     PROXY_IF_SANDBOXED(EnableSystemTimezoneChangeNotifications());
 463   }
 464
 465   void DisableNotifications() {
 466     PROXY_IF_SANDBOXED(DisableSystemTimezoneChangeNotifications());
 467   }
 468 };
 469
 470 static SystemTimezoneChangeObserversManager sSystemTimezoneChangeObservers;
 471
 472 void
 473 RegisterSystemTimezoneChangeObserver(SystemTimezoneChangeObserver* aObserver)
 474 {
 475   AssertMainThread();
 476   sSystemTimezoneChangeObservers.AddObserver(aObserver);
 477 }
 478
 479 void
 480 UnregisterSystemTimezoneChangeObserver(SystemTimezoneChangeObserver* aObserver)
 481 {
 482   AssertMainThread();
 483   sSystemTimezoneChangeObservers.RemoveObserver(aObserver);
 484 }
 485
 486 void
 487 NotifySystemTimezoneChange(const SystemTimezoneChangeInformation& aSystemTimezoneChangeInfo)
 488 {
 489   sSystemTimezoneChangeObservers.BroadcastInformation(aSystemTimezoneChangeInfo);
 490 }
 491
 492 void
 493 AdjustSystemClock(int64_t aDeltaMilliseconds)
 494 {
 495   AssertMainThread();
 496   PROXY_IF_SANDBOXED(AdjustSystemClock(aDeltaMilliseconds));
 497 }
 498
 499 void
 500 SetTimezone(const nsCString& aTimezoneSpec)
 501 {
 502   AssertMainThread();
 503   PROXY_IF_SANDBOXED(SetTimezone(aTimezoneSpec));
 504 }
 505
 506 int32_t
 507 GetTimezoneOffset()
 508 {
 509   AssertMainThread();
 510   RETURN_PROXY_IF_SANDBOXED(GetTimezoneOffset(), 0);
 511 }
 512
 513 nsCString
 514 GetTimezone()
 515 {
 516   AssertMainThread();
 517   RETURN_PROXY_IF_SANDBOXED(GetTimezone(), nsCString(""));
 518 }
 519
 520 void
 521 EnableSensorNotifications(SensorType aSensor) {
 522   AssertMainThread();
 523   PROXY_IF_SANDBOXED(EnableSensorNotifications(aSensor));
 524 }
 525
 526 void
 527 DisableSensorNotifications(SensorType aSensor) {
 528   AssertMainThread();
 529   PROXY_IF_SANDBOXED(DisableSensorNotifications(aSensor));
 530 }
 531
 532 typedef mozilla::ObserverList<SensorData> SensorObserverList;
 533 static SensorObserverList* gSensorObservers = nullptr;
 534
 535 static SensorObserverList &
 536 GetSensorObservers(SensorType sensor_type) {
 537   MOZ_ASSERT(sensor_type < NUM_SENSOR_TYPE);
 538
 539   if(!gSensorObservers) {
 540     gSensorObservers = new SensorObserverList[NUM_SENSOR_TYPE];
 541   }
 542   return gSensorObservers[sensor_type];
 543 }
 544
 545 void
 546 RegisterSensorObserver(SensorType aSensor, ISensorObserver *aObserver) {
 547   SensorObserverList &observers = GetSensorObservers(aSensor);
 548
 549   AssertMainThread();
 550
 551   observers.AddObserver(aObserver);
 552   if(observers.Length() == 1) {
 553     EnableSensorNotifications(aSensor);
 554   }
 555 }
 556
 557 void
 558 UnregisterSensorObserver(SensorType aSensor, ISensorObserver *aObserver) {
 559   AssertMainThread();
 560
 561   if (!gSensorObservers) {
 562     return;
 563   }
 564
 565   SensorObserverList &observers = GetSensorObservers(aSensor);
 566   if (!observers.RemoveObserver(aObserver) || observers.Length() > 0) {
 567     return;
 568   }
 569   DisableSensorNotifications(aSensor);
 570
 571   // Destroy sSensorObservers only if all observer lists are empty.
 572   for (int i = 0; i < NUM_SENSOR_TYPE; i++) {
 573     if (gSensorObservers[i].Length() > 0) {
 574       return;
 575     }
 576   }
 577   delete [] gSensorObservers;
 578   gSensorObservers = nullptr;
 579 }
 580
 581 void
 582 NotifySensorChange(const SensorData &aSensorData) {
 583   SensorObserverList &observers = GetSensorObservers(aSensorData.sensor());
 584
 585   AssertMainThread();
 586
 587   observers.Broadcast(aSensorData);
 588 }
 589
 590 void
 591 RegisterNetworkObserver(NetworkObserver* aObserver)
 592 {
 593   AssertMainThread();
 594   sNetworkObservers.AddObserver(aObserver);
 595 }
 596
 597 void
 598 UnregisterNetworkObserver(NetworkObserver* aObserver)
 599 {
 600   AssertMainThread();
 601   sNetworkObservers.RemoveObserver(aObserver);
 602 }
 603
 604 void
 605 GetCurrentNetworkInformation(NetworkInformation* aInfo)
 606 {
 607   AssertMainThread();
 608   *aInfo = sNetworkObservers.GetCurrentInformation();
 609 }
 610
 611 void
 612 NotifyNetworkChange(const NetworkInformation& aInfo)
 613 {
 614   sNetworkObservers.CacheInformation(aInfo);
 615   sNetworkObservers.BroadcastCachedInformation();
 616 }
 617
 618 void Reboot()
 619 {
 620   AssertMainProcess();
 621   AssertMainThread();
 622   PROXY_IF_SANDBOXED(Reboot());
 623 }
 624
 625 void PowerOff()
 626 {
 627   AssertMainProcess();
 628   AssertMainThread();
 629   PROXY_IF_SANDBOXED(PowerOff());
 630 }
 631
 632 void StartForceQuitWatchdog(ShutdownMode aMode, int32_t aTimeoutSecs)
 633 {
 634   AssertMainProcess();
 635   AssertMainThread();
 636   PROXY_IF_SANDBOXED(StartForceQuitWatchdog(aMode, aTimeoutSecs));
 637 }
 638
 639 void StartMonitoringGamepadStatus()
 640 {
 641   PROXY_IF_SANDBOXED(StartMonitoringGamepadStatus());
 642 }
 643
 644 void StopMonitoringGamepadStatus()
 645 {
 646   PROXY_IF_SANDBOXED(StopMonitoringGamepadStatus());
 647 }
 648
 649 void
 650 RegisterWakeLockObserver(WakeLockObserver* aObserver)
 651 {
 652   AssertMainThread();
 653   sWakeLockObservers.AddObserver(aObserver);
 654 }
 655
 656 void
 657 UnregisterWakeLockObserver(WakeLockObserver* aObserver)
 658 {
 659   AssertMainThread();
 660   sWakeLockObservers.RemoveObserver(aObserver);
 661 }
 662
 663 void
 664 ModifyWakeLock(const nsAString& aTopic,
 665                WakeLockControl aLockAdjust,
 666                WakeLockControl aHiddenAdjust,
 667                uint64_t aProcessID /* = CONTENT_PROCESS_ID_UNKNOWN */)
 668 {
 669   AssertMainThread();
 670
 671   if (aProcessID == CONTENT_PROCESS_ID_UNKNOWN) {
 672     aProcessID = InSandbox() ? ContentChild::GetSingleton()->GetID() :
 673                                CONTENT_PROCESS_ID_MAIN;
 674   }
 675
 676   PROXY_IF_SANDBOXED(ModifyWakeLock(aTopic, aLockAdjust,
 677                                     aHiddenAdjust, aProcessID));
 678 }
 679
 680 void
 681 GetWakeLockInfo(const nsAString& aTopic, WakeLockInformation* aWakeLockInfo)
 682 {
 683   AssertMainThread();
 684   PROXY_IF_SANDBOXED(GetWakeLockInfo(aTopic, aWakeLockInfo));
 685 }
 686
 687 void
 688 NotifyWakeLockChange(const WakeLockInformation& aInfo)
 689 {
 690   AssertMainThread();
 691   sWakeLockObservers.BroadcastInformation(aInfo);
 692 }
 693
 694 void
 695 RegisterScreenConfigurationObserver(ScreenConfigurationObserver* aObserver)
 696 {
 697   AssertMainThread();
 698   sScreenConfigurationObservers.AddObserver(aObserver);
 699 }
 700
 701 void
 702 UnregisterScreenConfigurationObserver(ScreenConfigurationObserver* aObserver)
 703 {
 704   AssertMainThread();
 705   sScreenConfigurationObservers.RemoveObserver(aObserver);
 706 }
 707
 708 void
 709 GetCurrentScreenConfiguration(ScreenConfiguration* aScreenConfiguration)
 710 {
 711   AssertMainThread();
 712   *aScreenConfiguration = sScreenConfigurationObservers.GetCurrentInformation();
 713 }
 714
 715 void
 716 NotifyScreenConfigurationChange(const ScreenConfiguration& aScreenConfiguration)
 717 {
 718   sScreenConfigurationObservers.CacheInformation(aScreenConfiguration);
 719   sScreenConfigurationObservers.BroadcastCachedInformation();
 720 }
 721
 722 bool
 723 LockScreenOrientation(const dom::ScreenOrientation& aOrientation)
 724 {
 725   AssertMainThread();
 726   RETURN_PROXY_IF_SANDBOXED(LockScreenOrientation(aOrientation), false);
 727 }
 728
 729 void
 730 UnlockScreenOrientation()
 731 {
 732   AssertMainThread();
 733   PROXY_IF_SANDBOXED(UnlockScreenOrientation());
 734 }
 735
 736 void
 737 EnableSwitchNotifications(SwitchDevice aDevice) {
 738   AssertMainThread();
 739   PROXY_IF_SANDBOXED(EnableSwitchNotifications(aDevice));
 740 }
 741
 742 void
 743 DisableSwitchNotifications(SwitchDevice aDevice) {
 744   AssertMainThread();
 745   PROXY_IF_SANDBOXED(DisableSwitchNotifications(aDevice));
 746 }
 747
 748 SwitchState GetCurrentSwitchState(SwitchDevice aDevice)
 749 {
 750   AssertMainThread();
 751   RETURN_PROXY_IF_SANDBOXED(GetCurrentSwitchState(aDevice), SWITCH_STATE_UNKNOWN);
 752 }
 753
 754 void NotifySwitchStateFromInputDevice(SwitchDevice aDevice, SwitchState aState)
 755 {
 756   AssertMainThread();
 757   PROXY_IF_SANDBOXED(NotifySwitchStateFromInputDevice(aDevice, aState));
 758 }
 759
 760 typedef mozilla::ObserverList<SwitchEvent> SwitchObserverList;
 761
 762 static SwitchObserverList *sSwitchObserverLists = nullptr;
 763
 764 static SwitchObserverList&
 765 GetSwitchObserverList(SwitchDevice aDevice) {
 766   MOZ_ASSERT(0 <= aDevice && aDevice < NUM_SWITCH_DEVICE);
 767   if (sSwitchObserverLists == nullptr) {
 768     sSwitchObserverLists = new SwitchObserverList[NUM_SWITCH_DEVICE];
 769   }
 770   return sSwitchObserverLists[aDevice];
 771 }
 772
 773 static void
 774 ReleaseObserversIfNeeded() {
 775   for (int i = 0; i < NUM_SWITCH_DEVICE; i++) {
 776     if (sSwitchObserverLists[i].Length() != 0)
 777       return;
 778   }
 779
 780   //The length of every list is 0, no observer in the list.
 781   delete [] sSwitchObserverLists;
 782   sSwitchObserverLists = nullptr;
 783 }
 784
 785 void
 786 RegisterSwitchObserver(SwitchDevice aDevice, SwitchObserver *aObserver)
 787 {
 788   AssertMainThread();
 789   SwitchObserverList& observer = GetSwitchObserverList(aDevice);
 790   observer.AddObserver(aObserver);
 791   if (observer.Length() == 1) {
 792     EnableSwitchNotifications(aDevice);
 793   }
 794 }
 795
 796 void
 797 UnregisterSwitchObserver(SwitchDevice aDevice, SwitchObserver *aObserver)
 798 {
 799   AssertMainThread();
 800
 801   if (!sSwitchObserverLists) {
 802     return;
 803   }
 804
 805   SwitchObserverList& observer = GetSwitchObserverList(aDevice);
 806   if (!observer.RemoveObserver(aObserver) || observer.Length() > 0) {
 807     return;
 808   }
 809
 810   DisableSwitchNotifications(aDevice);
 811   ReleaseObserversIfNeeded();
 812 }
 813
 814 void
 815 NotifySwitchChange(const SwitchEvent& aEvent)
 816 {
 817   // When callback this notification, main thread may call unregister function
 818   // first. We should check if this pointer is valid.
 819   if (!sSwitchObserverLists)
 820     return;
 821
 822   SwitchObserverList& observer = GetSwitchObserverList(aEvent.device());
 823   observer.Broadcast(aEvent);
 824 }
 825
 826 static AlarmObserver* sAlarmObserver;
 827
 828 bool
 829 RegisterTheOneAlarmObserver(AlarmObserver* aObserver)
 830 {
 831   MOZ_ASSERT(!InSandbox());
 832   MOZ_ASSERT(!sAlarmObserver);
 833
 834   sAlarmObserver = aObserver;
 835   RETURN_PROXY_IF_SANDBOXED(EnableAlarm(), false);
 836 }
 837
 838 void
 839 UnregisterTheOneAlarmObserver()
 840 {
 841   if (sAlarmObserver) {
 842     sAlarmObserver = nullptr;
 843     PROXY_IF_SANDBOXED(DisableAlarm());
 844   }
 845 }
 846
 847 void
 848 NotifyAlarmFired()
 849 {
 850   if (sAlarmObserver) {
 851     sAlarmObserver->Notify(void_t());
 852   }
 853 }
 854
 855 bool
 856 SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
 857 {
 858   // It's pointless to program an alarm nothing is going to observe ...
 859   MOZ_ASSERT(sAlarmObserver);
 860   RETURN_PROXY_IF_SANDBOXED(SetAlarm(aSeconds, aNanoseconds), false);
 861 }
 862
 863 void
 864 SetProcessPriority(int aPid, ProcessPriority aPriority, uint32_t aLRU)
 865 {
 866   // n.b. The sandboxed implementation crashes; SetProcessPriority works only
 867   // from the main process.
 868   PROXY_IF_SANDBOXED(SetProcessPriority(aPid, aPriority, aLRU));
 869 }
 870
 871 void
 872 SetCurrentThreadPriority(hal::ThreadPriority aThreadPriority)
 873 {
 874   PROXY_IF_SANDBOXED(SetCurrentThreadPriority(aThreadPriority));
 875 }
 876
 877 // From HalTypes.h.
 878 const char*
 879 ProcessPriorityToString(ProcessPriority aPriority)
 880 {
 881   switch (aPriority) {
 882   case PROCESS_PRIORITY_MASTER:
 883     return "MASTER";
 884   case PROCESS_PRIORITY_PREALLOC:
 885     return "PREALLOC";
 886   case PROCESS_PRIORITY_FOREGROUND_HIGH:
 887     return "FOREGROUND_HIGH";
 888   case PROCESS_PRIORITY_FOREGROUND:
 889     return "FOREGROUND";
 890   case PROCESS_PRIORITY_FOREGROUND_KEYBOARD:
 891     return "FOREGROUND_KEYBOARD";
 892   case PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE:
 893     return "BACKGROUND_PERCEIVABLE";
 894   case PROCESS_PRIORITY_BACKGROUND_HOMESCREEN:
 895     return "BACKGROUND_HOMESCREEN";
 896   case PROCESS_PRIORITY_BACKGROUND:
 897     return "BACKGROUND";
 898   case PROCESS_PRIORITY_UNKNOWN:
 899     return "UNKNOWN";
 900   default:
 901     MOZ_ASSERT(false);
 902     return "???";
 903   }
 904 }
 905
 906 const char *
 907 ThreadPriorityToString(ThreadPriority aPriority)
 908 {
 909   switch (aPriority) {
 910     case THREAD_PRIORITY_COMPOSITOR:
 911       return "COMPOSITOR";
 912     default:
 913       MOZ_ASSERT(false);
 914       return "???";
 915   }
 916 }
 917
 918 static StaticAutoPtr<ObserverList<FMRadioOperationInformation> > sFMRadioObservers;
 919 static StaticAutoPtr<ObserverList<FMRadioRDSGroup> > sFMRadioRDSObservers;
 920
 921 static void
 922 InitializeFMRadioObserver()
 923 {
 924   if (!sFMRadioObservers) {
 925     sFMRadioObservers = new ObserverList<FMRadioOperationInformation>;
 926     sFMRadioRDSObservers = new ObserverList<FMRadioRDSGroup>;
 927     ClearOnShutdown(&sFMRadioRDSObservers);
 928     ClearOnShutdown(&sFMRadioObservers);
 929   }
 930 }
 931
 932 void
 933 RegisterFMRadioObserver(FMRadioObserver* aFMRadioObserver) {
 934   AssertMainThread();
 935   InitializeFMRadioObserver();
 936   sFMRadioObservers->AddObserver(aFMRadioObserver);
 937 }
 938
 939 void
 940 UnregisterFMRadioObserver(FMRadioObserver* aFMRadioObserver) {
 941   AssertMainThread();
 942   InitializeFMRadioObserver();
 943   sFMRadioObservers->RemoveObserver(aFMRadioObserver);
 944 }
 945
 946 void
 947 NotifyFMRadioStatus(const FMRadioOperationInformation& aFMRadioState) {
 948   InitializeFMRadioObserver();
 949   sFMRadioObservers->Broadcast(aFMRadioState);
 950 }
 951
 952 void
 953 RegisterFMRadioRDSObserver(FMRadioRDSObserver* aFMRadioRDSObserver) {
 954   AssertMainThread();
 955   InitializeFMRadioObserver();
 956   sFMRadioRDSObservers->AddObserver(aFMRadioRDSObserver);
 957 }
 958
 959 void
 960 UnregisterFMRadioRDSObserver(FMRadioRDSObserver* aFMRadioRDSObserver) {
 961   AssertMainThread();
 962   InitializeFMRadioObserver();
 963   sFMRadioRDSObservers->RemoveObserver(aFMRadioRDSObserver);
 964 }
 965
 966
 967 void
 968 NotifyFMRadioRDSGroup(const FMRadioRDSGroup& aRDSGroup) {
 969   InitializeFMRadioObserver();
 970   sFMRadioRDSObservers->Broadcast(aRDSGroup);
 971 }
 972
 973 void
 974 EnableFMRadio(const FMRadioSettings& aInfo) {
 975   AssertMainThread();
 976   PROXY_IF_SANDBOXED(EnableFMRadio(aInfo));
 977 }
 978
 979 void
 980 DisableFMRadio() {
 981   AssertMainThread();
 982   PROXY_IF_SANDBOXED(DisableFMRadio());
 983 }
 984
 985 void
 986 FMRadioSeek(const FMRadioSeekDirection& aDirection) {
 987   PROXY_IF_SANDBOXED(FMRadioSeek(aDirection));
 988 }
 989
 990 void
 991 GetFMRadioSettings(FMRadioSettings* aInfo) {
 992   AssertMainThread();
 993   PROXY_IF_SANDBOXED(GetFMRadioSettings(aInfo));
 994 }
 995
 996 void
 997 SetFMRadioFrequency(const uint32_t aFrequency) {
 998   PROXY_IF_SANDBOXED(SetFMRadioFrequency(aFrequency));
 999 }
1000
1001 uint32_t
1002 GetFMRadioFrequency() {
1003   AssertMainThread();
1004   RETURN_PROXY_IF_SANDBOXED(GetFMRadioFrequency(), 0);
1005 }
1006
1007 bool
1008 IsFMRadioOn() {
1009   AssertMainThread();
1010   RETURN_PROXY_IF_SANDBOXED(IsFMRadioOn(), false);
1011 }
1012
1013 uint32_t
1014 GetFMRadioSignalStrength() {
1015   AssertMainThread();
1016   RETURN_PROXY_IF_SANDBOXED(GetFMRadioSignalStrength(), 0);
1017 }
1018
1019 void
1020 CancelFMRadioSeek() {
1021   AssertMainThread();
1022   PROXY_IF_SANDBOXED(CancelFMRadioSeek());
1023 }
1024
1025 bool
1026 EnableRDS(uint32_t aMask) {
1027   AssertMainThread();
1028   RETURN_PROXY_IF_SANDBOXED(EnableRDS(aMask), false);
1029 }
1030
1031 void
1032 DisableRDS() {
1033   AssertMainThread();
1034   PROXY_IF_SANDBOXED(DisableRDS());
1035 }
1036
1037 FMRadioSettings
1038 GetFMBandSettings(FMRadioCountry aCountry) {
1039   FMRadioSettings settings;
1040
1041   switch (aCountry) {
1042     case FM_RADIO_COUNTRY_US:
1043     case FM_RADIO_COUNTRY_EU:
1044       settings.upperLimit() = 108000;
1045       settings.lowerLimit() = 87800;
1046       settings.spaceType() = 200;
1047       settings.preEmphasis() = 75;
1048       break;
1049     case FM_RADIO_COUNTRY_JP_STANDARD:
1050       settings.upperLimit() = 76000;
1051       settings.lowerLimit() = 90000;
1052       settings.spaceType() = 100;
1053       settings.preEmphasis() = 50;
1054       break;
1055     case FM_RADIO_COUNTRY_CY:
1056     case FM_RADIO_COUNTRY_DE:
1057     case FM_RADIO_COUNTRY_DK:
1058     case FM_RADIO_COUNTRY_ES:
1059     case FM_RADIO_COUNTRY_FI:
1060     case FM_RADIO_COUNTRY_FR:
1061     case FM_RADIO_COUNTRY_HU:
1062     case FM_RADIO_COUNTRY_IR:
1063     case FM_RADIO_COUNTRY_IT:
1064     case FM_RADIO_COUNTRY_KW:
1065     case FM_RADIO_COUNTRY_LT:
1066     case FM_RADIO_COUNTRY_ML:
1067     case FM_RADIO_COUNTRY_NO:
1068     case FM_RADIO_COUNTRY_OM:
1069     case FM_RADIO_COUNTRY_PG:
1070     case FM_RADIO_COUNTRY_NL:
1071     case FM_RADIO_COUNTRY_CZ:
1072     case FM_RADIO_COUNTRY_UK:
1073     case FM_RADIO_COUNTRY_RW:
1074     case FM_RADIO_COUNTRY_SN:
1075     case FM_RADIO_COUNTRY_SI:
1076     case FM_RADIO_COUNTRY_ZA:
1077     case FM_RADIO_COUNTRY_SE:
1078     case FM_RADIO_COUNTRY_CH:
1079     case FM_RADIO_COUNTRY_TW:
1080     case FM_RADIO_COUNTRY_UA:
1081       settings.upperLimit() = 108000;
1082       settings.lowerLimit() = 87500;
1083       settings.spaceType() = 100;
1084       settings.preEmphasis() = 50;
1085       break;
1086     case FM_RADIO_COUNTRY_VA:
1087     case FM_RADIO_COUNTRY_MA:
1088     case FM_RADIO_COUNTRY_TR:
1089       settings.upperLimit() = 10800;
1090       settings.lowerLimit() = 87500;
1091       settings.spaceType() = 100;
1092       settings.preEmphasis() = 75;
1093       break;
1094     case FM_RADIO_COUNTRY_AU:
1095     case FM_RADIO_COUNTRY_BD:
1096       settings.upperLimit() = 108000;
1097       settings.lowerLimit() = 87500;
1098       settings.spaceType() = 200;
1099       settings.preEmphasis() = 75;
1100       break;
1101     case FM_RADIO_COUNTRY_AW:
1102     case FM_RADIO_COUNTRY_BS:
1103     case FM_RADIO_COUNTRY_CO:
1104     case FM_RADIO_COUNTRY_KR:
1105       settings.upperLimit() = 108000;
1106       settings.lowerLimit() = 88000;
1107       settings.spaceType() = 200;
1108       settings.preEmphasis() = 75;
1109       break;
1110     case FM_RADIO_COUNTRY_EC:
1111       settings.upperLimit() = 108000;
1112       settings.lowerLimit() = 88000;
1113       settings.spaceType() = 200;
1114       settings.preEmphasis() = 0;
1115       break;
1116     case FM_RADIO_COUNTRY_GM:
1117       settings.upperLimit() = 108000;
1118       settings.lowerLimit() = 88000;
1119       settings.spaceType() = 0;
1120       settings.preEmphasis() = 75;
1121       break;
1122     case FM_RADIO_COUNTRY_QA:
1123       settings.upperLimit() = 108000;
1124       settings.lowerLimit() = 88000;
1125       settings.spaceType() = 200;
1126       settings.preEmphasis() = 50;
1127       break;
1128     case FM_RADIO_COUNTRY_SG:
1129       settings.upperLimit() = 108000;
1130       settings.lowerLimit() = 88000;
1131       settings.spaceType() = 200;
1132       settings.preEmphasis() = 50;
1133       break;
1134     case FM_RADIO_COUNTRY_IN:
1135       settings.upperLimit() = 100000;
1136       settings.lowerLimit() = 108000;
1137       settings.spaceType() = 100;
1138       settings.preEmphasis() = 50;
1139       break;
1140     case FM_RADIO_COUNTRY_NZ:
1141       settings.upperLimit() = 100000;
1142       settings.lowerLimit() = 88000;
1143       settings.spaceType() = 50;
1144       settings.preEmphasis() = 50;
1145       break;
1146     case FM_RADIO_COUNTRY_USER_DEFINED:
1147       break;
1148     default:
1149       MOZ_ASSERT(0);
1150       break;
1151     };
1152     return settings;
1153 }
1154
1155 void FactoryReset(mozilla::dom::FactoryResetReason& aReason)
1156 {
1157   AssertMainThread();
1158   PROXY_IF_SANDBOXED(FactoryReset(aReason));
1159 }
1160
1161 void
1162 StartDiskSpaceWatcher()
1163 {
1164   AssertMainProcess();
1165   AssertMainThread();
1166   PROXY_IF_SANDBOXED(StartDiskSpaceWatcher());
1167 }
1168
1169 void
1170 StopDiskSpaceWatcher()
1171 {
1172   AssertMainProcess();
1173   AssertMainThread();
1174   PROXY_IF_SANDBOXED(StopDiskSpaceWatcher());
1175 }
1176
1177 uint32_t
1178 GetTotalSystemMemory()
1179 {
1180   return hal_impl::GetTotalSystemMemory();
1181 }
1182
1183 uint32_t
1184 GetTotalSystemMemoryLevel()
1185 {
1186   return hal_impl::GetTotalSystemMemoryLevel();
1187 }
1188
1189 bool IsHeadphoneEventFromInputDev()
1190 {
1191   AssertMainThread();
1192   RETURN_PROXY_IF_SANDBOXED(IsHeadphoneEventFromInputDev(), false);
1193 }
1194
1195 } // namespace hal
1196 } // namespace mozilla