The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim: set sw=2 ts=8 et ft=cpp : */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 include protocol PContent;

 include protocol PBrowser;

 using mozilla::dom::ScreenOrientation from "mozilla/dom/ScreenOrientation.h";

 using mozilla::hal::FlashMode from "mozilla/HalTypes.h";

 using mozilla::hal::LightType from "mozilla/HalTypes.h";

 using mozilla::hal::LightMode from "mozilla/HalTypes.h";

 using mozilla::hal::SensorType from "mozilla/HalSensor.h";

 using mozilla::hal::SensorAccuracyType from "mozilla/HalSensor.h";

 using mozilla::hal::WakeLockControl from "mozilla/HalTypes.h";

 using mozilla::hal::SwitchState from "mozilla/HalTypes.h";

 using mozilla::hal::SwitchDevice from "mozilla/HalTypes.h";

 using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";

 using struct nsIntRect from "nsRect.h";

 using PRTime from "prtime.h";

 using mozilla::hal::FMRadioCountry from "mozilla/HalTypes.h";

 using mozilla::hal::FMRadioOperation from "mozilla/HalTypes.h";

 using mozilla::hal::FMRadioOperationStatus from "mozilla/HalTypes.h";

 namespace mozilla {

 namespace hal {

 struct BatteryInformation {

   double level;

   bool   charging;

   double remainingTime;

 };

 struct LightConfiguration {

   LightType light;

   LightMode mode;

   FlashMode flash;

   uint32_t flashOnMS;

   uint32_t flashOffMS;

   uint32_t color;

 };

 struct SensorData {

   SensorType sensor;

   PRTime timestamp;

   float[] values;

   SensorAccuracyType accuracy;

 };

 struct NetworkInformation {

   uint32_t type;

   bool   isWifi;

   uint32_t dhcpGateway;

 };

 struct SwitchEvent {

   SwitchDevice device;

   SwitchState status;

 };

 struct WakeLockInformation {

   nsString topic;

   uint32_t numLocks;

   uint32_t numHidden;

   uint64_t[] lockingProcesses;

 };

 struct ScreenConfiguration {

   nsIntRect rect;

   ScreenOrientation orientation;

   uint32_t colorDepth;

   uint32_t pixelDepth;

 };

 struct FMRadioOperationInformation {

   FMRadioOperation operation;

   FMRadioOperationStatus status;

   uint32_t frequency;

 };

 struct FMRadioSettings {

   FMRadioCountry country;

   uint32_t upperLimit;

   uint32_t lowerLimit;

   uint32_t spaceType;

   uint32_t preEmphasis;

 };

 struct SystemTimezoneChangeInformation {

   // These timezone offsets are relative to UTC in minutes and

   // have already taken daylight saving time (DST) into account.

   int32_t oldTimezoneOffsetMinutes;

   int32_t newTimezoneOffsetMinutes;

 };

 } // namespace hal

 namespace hal_sandbox {

 sync protocol PHal {

     manager PContent;

 child:

     NotifyBatteryChange(BatteryInformation aBatteryInfo);

     NotifyNetworkChange(NetworkInformation aNetworkInfo);

     NotifyWakeLockChange(WakeLockInformation aWakeLockInfo);

     NotifyScreenConfigurationChange(ScreenConfiguration aScreenOrientation);

     NotifySwitchChange(SwitchEvent aEvent);

     NotifySystemClockChange(int64_t aClockDeltaMS); 

     NotifySystemTimezoneChange(SystemTimezoneChangeInformation aSystemTimezoneChangeInfo); 

 parent:

     Vibrate(uint32_t[] pattern, uint64_t[] id, PBrowser browser);

     CancelVibrate(uint64_t[] id, PBrowser browser);

     EnableBatteryNotifications();

     DisableBatteryNotifications();

     sync GetCurrentBatteryInformation()

       returns (BatteryInformation aBatteryInfo);

     EnableNetworkNotifications();

     DisableNetworkNotifications();

     sync GetCurrentNetworkInformation()

       returns (NetworkInformation aNetworkInfo);

     sync GetScreenEnabled() returns (bool enabled);

     SetScreenEnabled(bool enabled);

     sync GetCpuSleepAllowed() returns (bool allowed);

     SetCpuSleepAllowed(bool allowed);

     sync GetScreenBrightness() returns (double brightness);

     SetScreenBrightness(double brightness);

     AdjustSystemClock(int64_t aDeltaMilliseconds);

     SetTimezone(nsCString aTimezoneSpec);

     sync GetTimezone()

       returns (nsCString aTimezoneSpec);

     sync GetTimezoneOffset()

       returns (int32_t aTimezoneOffset);

     EnableSystemClockChangeNotifications();

     DisableSystemClockChangeNotifications();

     EnableSystemTimezoneChangeNotifications();

     DisableSystemTimezoneChangeNotifications();

     sync SetLight(LightType light, LightConfiguration aConfig)

       returns (bool status);

     sync GetLight(LightType light)

       returns (LightConfiguration aConfig, bool status);

     ModifyWakeLock(nsString aTopic,

                    WakeLockControl aLockAdjust,

                    WakeLockControl aHiddenAdjust,

                    uint64_t aProcessID);

     EnableWakeLockNotifications();

     DisableWakeLockNotifications();

     sync GetWakeLockInfo(nsString aTopic)

       returns (WakeLockInformation aWakeLockInfo);

     EnableScreenConfigurationNotifications();

     DisableScreenConfigurationNotifications();

     sync GetCurrentScreenConfiguration()

       returns (ScreenConfiguration aScreenConfiguration);

     sync LockScreenOrientation(ScreenOrientation aOrientation)

       returns (bool allowed);

     UnlockScreenOrientation();

     EnableSwitchNotifications(SwitchDevice aDevice);

     DisableSwitchNotifications(SwitchDevice aDevice);

     sync GetCurrentSwitchState(SwitchDevice aDevice)

       returns (SwitchState aState);

     NotifySwitchStateFromInputDevice(SwitchDevice aDevice, SwitchState aState);

     FactoryReset();

 child:

     NotifySensorChange(SensorData aSensorData);

 parent:

     EnableSensorNotifications(SensorType aSensor);

     DisableSensorNotifications(SensorType aSensor);

     __delete__();

 };

 } // namespace hal

 } // namespace mozilla