LCOV - app.info - hal/sandbox/SandboxHal.cpp

LCOV - code coverage report
| Current view: | directory - hal/sandbox - SandboxHal.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 196 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 65 | 0 | 0.0 %

           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 "mozilla/dom/ContentChild.h"
           9                 : #include "mozilla/hal_sandbox/PHalChild.h"
          10                 : #include "mozilla/hal_sandbox/PHalParent.h"
          11                 : #include "mozilla/dom/TabParent.h"
          12                 : #include "mozilla/dom/TabChild.h"
          13                 : #include "mozilla/dom/battery/Types.h"
          14                 : #include "mozilla/dom/network/Types.h"
          15                 : #include "mozilla/Observer.h"
          16                 : #include "mozilla/unused.h"
          17                 : #include "WindowIdentifier.h"
          18                 :
          19                 : using namespace mozilla;
          20                 : using namespace mozilla::dom;
          21                 : using namespace mozilla::hal;
          22                 :
          23                 : namespace mozilla {
          24                 : namespace hal_sandbox {
          25                 :
          26                 : static PHalChild* sHal;
          27                 : static PHalChild*
          28               0 : Hal()
          29                 : {
          30               0 :   if (!sHal) {
          31               0 :     sHal = ContentChild::GetSingleton()->SendPHalConstructor();
          32                 :   }
          33               0 :   return sHal;
          34                 : }
          35                 :
          36                 : void
          37               0 : Vibrate(const nsTArray<uint32>& pattern, const WindowIdentifier &id)
          38                 : {
          39               0 :   HAL_LOG(("Vibrate: Sending to parent process."));
          40                 :
          41               0 :   AutoInfallibleTArray<uint32, 8> p(pattern);
          42                 :
          43               0 :   WindowIdentifier newID(id);
          44               0 :   newID.AppendProcessID();
          45               0 :   Hal()->SendVibrate(p, newID.AsArray(), GetTabChildFrom(newID.GetWindow()));
          46               0 : }
          47                 :
          48                 : void
          49               0 : CancelVibrate(const WindowIdentifier &id)
          50                 : {
          51               0 :   HAL_LOG(("CancelVibrate: Sending to parent process."));
          52                 :
          53               0 :   WindowIdentifier newID(id);
          54               0 :   newID.AppendProcessID();
          55               0 :   Hal()->SendCancelVibrate(newID.AsArray(), GetTabChildFrom(newID.GetWindow()));
          56               0 : }
          57                 :
          58                 : void
          59               0 : EnableBatteryNotifications()
          60                 : {
          61               0 :   Hal()->SendEnableBatteryNotifications();
          62               0 : }
          63                 :
          64                 : void
          65               0 : DisableBatteryNotifications()
          66                 : {
          67               0 :   Hal()->SendDisableBatteryNotifications();
          68               0 : }
          69                 :
          70                 : void
          71               0 : GetCurrentBatteryInformation(BatteryInformation* aBatteryInfo)
          72                 : {
          73               0 :   Hal()->SendGetCurrentBatteryInformation(aBatteryInfo);
          74               0 : }
          75                 :
          76                 : void
          77               0 : EnableNetworkNotifications()
          78                 : {
          79               0 :   Hal()->SendEnableNetworkNotifications();
          80               0 : }
          81                 :
          82                 : void
          83               0 : DisableNetworkNotifications()
          84                 : {
          85               0 :   Hal()->SendDisableNetworkNotifications();
          86               0 : }
          87                 :
          88                 : void
          89               0 : GetCurrentNetworkInformation(NetworkInformation* aNetworkInfo)
          90                 : {
          91               0 :   Hal()->SendGetCurrentNetworkInformation(aNetworkInfo);
          92               0 : }
          93                 :
          94                 : bool
          95               0 : GetScreenEnabled()
          96                 : {
          97               0 :   bool enabled = false;
          98               0 :   Hal()->SendGetScreenEnabled(&enabled);
          99               0 :   return enabled;
         100                 : }
         101                 :
         102                 : void
         103               0 : SetScreenEnabled(bool enabled)
         104                 : {
         105               0 :   Hal()->SendSetScreenEnabled(enabled);
         106               0 : }
         107                 :
         108                 : double
         109               0 : GetScreenBrightness()
         110                 : {
         111               0 :   double brightness = 0;
         112               0 :   Hal()->SendGetScreenBrightness(&brightness);
         113               0 :   return brightness;
         114                 : }
         115                 :
         116                 : void
         117               0 : SetScreenBrightness(double brightness)
         118                 : {
         119               0 :   Hal()->SendSetScreenBrightness(brightness);
         120               0 : }
         121                 :
         122                 : bool
         123               0 : SetLight(hal::LightType light, const hal::LightConfiguration& aConfig)
         124                 : {
         125                 :   bool status;
         126               0 :   Hal()->SendSetLight(light, aConfig, &status);
         127               0 :   return status;
         128                 : }
         129                 :
         130                 : bool
         131               0 : GetLight(hal::LightType light, hal::LightConfiguration* aConfig)
         132                 : {
         133                 :   bool status;
         134               0 :   Hal()->SendGetLight(light, aConfig, &status);
         135               0 :   return status;
         136                 : }
         137                 :
         138                 : void
         139               0 : AdjustSystemClock(int32_t aDeltaMilliseconds)
         140                 : {
         141               0 :   Hal()->SendAdjustSystemClock(aDeltaMilliseconds);
         142               0 : }
         143                 :
         144                 : void
         145               0 : SetTimezone(const nsCString& aTimezoneSpec)
         146                 : {
         147               0 :   Hal()->SendSetTimezone(nsCString(aTimezoneSpec));
         148               0 : }
         149                 :
         150                 : void
         151               0 : Reboot()
         152                 : {
         153               0 :   Hal()->SendReboot();
         154               0 : }
         155                 :
         156                 : void
         157               0 : PowerOff()
         158                 : {
         159               0 :   Hal()->SendPowerOff();
         160               0 : }
         161                 :
         162                 : void
         163               0 : EnableSensorNotifications(SensorType aSensor) {
         164               0 :   Hal()->SendEnableSensorNotifications(aSensor);
         165               0 : }
         166                 :
         167                 : void
         168               0 : DisableSensorNotifications(SensorType aSensor) {
         169               0 :   Hal()->SendDisableSensorNotifications(aSensor);
         170               0 : }
         171                 :
         172                 : void
         173               0 : EnableWakeLockNotifications()
         174                 : {
         175               0 :   Hal()->SendEnableWakeLockNotifications();
         176               0 : }
         177                 :
         178                 : void
         179               0 : DisableWakeLockNotifications()
         180                 : {
         181               0 :   Hal()->SendDisableWakeLockNotifications();
         182               0 : }
         183                 :
         184                 : void
         185               0 : ModifyWakeLock(const nsAString &aTopic, WakeLockControl aLockAdjust, WakeLockControl aHiddenAdjust)
         186                 : {
         187               0 :   Hal()->SendModifyWakeLock(nsString(aTopic), aLockAdjust, aHiddenAdjust);
         188               0 : }
         189                 :
         190                 : void
         191               0 : GetWakeLockInfo(const nsAString &aTopic, WakeLockInformation *aWakeLockInfo)
         192                 : {
         193               0 :   Hal()->SendGetWakeLockInfo(nsString(aTopic), aWakeLockInfo);
         194               0 : }
         195                 :
         196                 : class HalParent : public PHalParent
         197                 :                 , public BatteryObserver
         198                 :                 , public NetworkObserver
         199                 :                 , public ISensorObserver
         200                 :                 , public WakeLockObserver
         201               0 : {
         202                 : public:
         203                 :   NS_OVERRIDE virtual bool
         204               0 :   RecvVibrate(const InfallibleTArray<unsigned int>& pattern,
         205                 :               const InfallibleTArray<uint64> &id,
         206                 :               PBrowserParent *browserParent)
         207                 :   {
         208                 :     // Check whether browserParent is active.  We should have already
         209                 :     // checked that the corresponding window is active, but this check
         210                 :     // isn't redundant.  A window may be inactive in an active
         211                 :     // browser.  And a window is not notified synchronously when it's
         212                 :     // deactivated, so the window may think it's active when the tab
         213                 :     // is actually inactive.
         214               0 :     TabParent *tabParent = static_cast<TabParent*>(browserParent);
         215               0 :     if (!tabParent->Active()) {
         216               0 :       HAL_LOG(("RecvVibrate: Tab is not active. Cancelling."));
         217               0 :       return true;
         218                 :     }
         219                 :
         220                 :     // Forward to hal::, not hal_impl::, because we might be a
         221                 :     // subprocess of another sandboxed process.  The hal:: entry point
         222                 :     // will do the right thing.
         223                 :     nsCOMPtr<nsIDOMWindow> window =
         224               0 :       do_QueryInterface(tabParent->GetBrowserDOMWindow());
         225               0 :     WindowIdentifier newID(id, window);
         226               0 :     hal::Vibrate(pattern, newID);
         227               0 :     return true;
         228                 :   }
         229                 :
         230                 :   NS_OVERRIDE virtual bool
         231               0 :   RecvCancelVibrate(const InfallibleTArray<uint64> &id,
         232                 :                     PBrowserParent *browserParent)
         233                 :   {
         234               0 :     TabParent *tabParent = static_cast<TabParent*>(browserParent);
         235                 :     nsCOMPtr<nsIDOMWindow> window =
         236               0 :       do_QueryInterface(tabParent->GetBrowserDOMWindow());
         237               0 :     WindowIdentifier newID(id, window);
         238               0 :     hal::CancelVibrate(newID);
         239               0 :     return true;
         240                 :   }
         241                 :
         242                 :   NS_OVERRIDE virtual bool
         243               0 :   RecvEnableBatteryNotifications() {
         244               0 :     hal::RegisterBatteryObserver(this);
         245               0 :     return true;
         246                 :   }
         247                 :
         248                 :   NS_OVERRIDE virtual bool
         249               0 :   RecvDisableBatteryNotifications() {
         250               0 :     hal::UnregisterBatteryObserver(this);
         251               0 :     return true;
         252                 :   }
         253                 :
         254                 :   NS_OVERRIDE virtual bool
         255               0 :   RecvGetCurrentBatteryInformation(BatteryInformation* aBatteryInfo) {
         256               0 :     hal::GetCurrentBatteryInformation(aBatteryInfo);
         257               0 :     return true;
         258                 :   }
         259                 :
         260               0 :   void Notify(const BatteryInformation& aBatteryInfo) {
         261               0 :     unused << SendNotifyBatteryChange(aBatteryInfo);
         262               0 :   }
         263                 :
         264                 :   NS_OVERRIDE virtual bool
         265               0 :   RecvEnableNetworkNotifications() {
         266               0 :     hal::RegisterNetworkObserver(this);
         267               0 :     return true;
         268                 :   }
         269                 :
         270                 :   NS_OVERRIDE virtual bool
         271               0 :   RecvDisableNetworkNotifications() {
         272               0 :     hal::UnregisterNetworkObserver(this);
         273               0 :     return true;
         274                 :   }
         275                 :
         276                 :   NS_OVERRIDE virtual bool
         277               0 :   RecvGetCurrentNetworkInformation(NetworkInformation* aNetworkInfo) {
         278               0 :     hal::GetCurrentNetworkInformation(aNetworkInfo);
         279               0 :     return true;
         280                 :   }
         281                 :
         282               0 :   void Notify(const NetworkInformation& aNetworkInfo) {
         283               0 :     unused << SendNotifyNetworkChange(aNetworkInfo);
         284               0 :   }
         285                 :
         286                 :   NS_OVERRIDE virtual bool
         287               0 :   RecvGetScreenEnabled(bool *enabled)
         288                 :   {
         289               0 :     *enabled = hal::GetScreenEnabled();
         290               0 :     return true;
         291                 :   }
         292                 :
         293                 :   NS_OVERRIDE virtual bool
         294               0 :   RecvSetScreenEnabled(const bool &enabled)
         295                 :   {
         296               0 :     hal::SetScreenEnabled(enabled);
         297               0 :     return true;
         298                 :   }
         299                 :
         300                 :   NS_OVERRIDE virtual bool
         301               0 :   RecvGetScreenBrightness(double *brightness)
         302                 :   {
         303               0 :     *brightness = hal::GetScreenBrightness();
         304               0 :     return true;
         305                 :   }
         306                 :
         307                 :   NS_OVERRIDE virtual bool
         308               0 :   RecvSetScreenBrightness(const double &brightness)
         309                 :   {
         310               0 :     hal::SetScreenBrightness(brightness);
         311               0 :     return true;
         312                 :   }
         313                 :
         314                 :   NS_OVERRIDE virtual bool
         315               0 :   RecvSetLight(const LightType& aLight,  const hal::LightConfiguration& aConfig, bool *status)
         316                 :   {
         317               0 :     *status = hal::SetLight(aLight, aConfig);
         318               0 :     return true;
         319                 :   }
         320                 :
         321                 :   NS_OVERRIDE virtual bool
         322               0 :   RecvGetLight(const LightType& aLight, LightConfiguration* aConfig, bool* status)
         323                 :   {
         324               0 :     *status = hal::GetLight(aLight, aConfig);
         325               0 :     return true;
         326                 :   }
         327                 :
         328                 :   NS_OVERRIDE virtual bool
         329               0 :   RecvAdjustSystemClock(const int32_t &aDeltaMilliseconds)
         330                 :   {
         331               0 :     hal::AdjustSystemClock(aDeltaMilliseconds);
         332               0 :     return true;
         333                 :   }
         334                 :
         335                 :   NS_OVERRIDE virtual bool
         336               0 :   RecvSetTimezone(const nsCString& aTimezoneSpec)
         337                 :   {
         338               0 :     hal::SetTimezone(aTimezoneSpec);
         339               0 :     return true;
         340                 :   }
         341                 :
         342                 :   NS_OVERRIDE virtual bool
         343               0 :   RecvReboot()
         344                 :   {
         345               0 :     hal::Reboot();
         346               0 :     return true;
         347                 :   }
         348                 :
         349                 :   NS_OVERRIDE virtual bool
         350               0 :   RecvPowerOff()
         351                 :   {
         352               0 :     hal::PowerOff();
         353               0 :     return true;
         354                 :   }
         355                 :
         356                 :   NS_OVERRIDE virtual bool
         357               0 :   RecvEnableSensorNotifications(const SensorType &aSensor) {
         358               0 :     hal::RegisterSensorObserver(aSensor, this);
         359               0 :     return true;
         360                 :   }
         361                 :
         362                 :   NS_OVERRIDE virtual bool
         363               0 :   RecvDisableSensorNotifications(const SensorType &aSensor) {
         364               0 :     hal::UnregisterSensorObserver(aSensor, this);
         365               0 :     return true;
         366                 :   }
         367                 :
         368               0 :   void Notify(const SensorData& aSensorData) {
         369               0 :     unused << SendNotifySensorChange(aSensorData);
         370               0 :   }
         371                 :
         372                 :   NS_OVERRIDE virtual bool
         373               0 :   RecvModifyWakeLock(const nsString &aTopic,
         374                 :                      const WakeLockControl &aLockAdjust,
         375                 :                      const WakeLockControl &aHiddenAdjust)
         376                 :   {
         377               0 :     hal::ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust);
         378               0 :     return true;
         379                 :   }
         380                 :
         381                 :   NS_OVERRIDE virtual bool
         382               0 :   RecvEnableWakeLockNotifications()
         383                 :   {
         384               0 :     hal::RegisterWakeLockObserver(this);
         385               0 :     return true;
         386                 :   }
         387                 :
         388                 :   NS_OVERRIDE virtual bool
         389               0 :   RecvDisableWakeLockNotifications()
         390                 :   {
         391               0 :     hal::UnregisterWakeLockObserver(this);
         392               0 :     return true;
         393                 :   }
         394                 :
         395                 :   NS_OVERRIDE virtual bool
         396               0 :   RecvGetWakeLockInfo(const nsString &aTopic, WakeLockInformation *aWakeLockInfo)
         397                 :   {
         398               0 :     hal::GetWakeLockInfo(aTopic, aWakeLockInfo);
         399               0 :     return true;
         400                 :   }
         401                 :
         402               0 :   void Notify(const WakeLockInformation& aWakeLockInfo)
         403                 :   {
         404               0 :     unused << SendNotifyWakeLockChange(aWakeLockInfo);
         405               0 :   }
         406                 : };
         407                 :
         408               0 : class HalChild : public PHalChild {
         409                 : public:
         410                 :   NS_OVERRIDE virtual bool
         411               0 :   RecvNotifyBatteryChange(const BatteryInformation& aBatteryInfo) {
         412               0 :     hal::NotifyBatteryChange(aBatteryInfo);
         413               0 :     return true;
         414                 :   }
         415                 :
         416                 :   NS_OVERRIDE virtual bool
         417                 :   RecvNotifySensorChange(const hal::SensorData &aSensorData);
         418                 :
         419                 :   NS_OVERRIDE virtual bool
         420               0 :   RecvNotifyNetworkChange(const NetworkInformation& aNetworkInfo) {
         421               0 :     hal::NotifyNetworkChange(aNetworkInfo);
         422               0 :     return true;
         423                 :   }
         424                 :
         425                 :   NS_OVERRIDE virtual bool
         426               0 :   RecvNotifyWakeLockChange(const WakeLockInformation& aWakeLockInfo) {
         427               0 :     hal::NotifyWakeLockChange(aWakeLockInfo);
         428               0 :     return true;
         429                 :   }
         430                 : };
         431                 :
         432                 : bool
         433               0 : HalChild::RecvNotifySensorChange(const hal::SensorData &aSensorData) {
         434               0 :   hal::NotifySensorChange(aSensorData);
         435                 :
         436               0 :   return true;
         437                 : }
         438                 :
         439               0 : PHalChild* CreateHalChild() {
         440               0 :   return new HalChild();
         441                 : }
         442                 :
         443               0 : PHalParent* CreateHalParent() {
         444               0 :   return new HalParent();
         445                 : }
         446                 :
         447                 : } // namespace hal_sandbox
         448                 : } // namespace mozilla

Generated by: LCOV version 1.7