LCOV - code coverage report
Current view: directory - objdir/ipc/ipdl/_ipdlheaders/mozilla/hal_sandbox - PHal.h (source / functions) Found Hit Coverage
Test: app.info Lines: 518 0 0.0 %
Date: 2012-06-02 Functions: 183 0 0.0 %

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : #ifndef PHal_h
       7                 : #define PHal_h
       8                 : 
       9                 : #include "mozilla/Attributes.h"
      10                 : #include "base/basictypes.h"
      11                 : #include "prtime.h"
      12                 : #include "nscore.h"
      13                 : #include "IPCMessageStart.h"
      14                 : #include "IPC/IPCMessageUtils.h"
      15                 : #include "nsAutoPtr.h"
      16                 : #include "nsStringGlue.h"
      17                 : #include "nsTArray.h"
      18                 : #include "nsIFile.h"
      19                 : #include "mozilla/ipc/ProtocolUtils.h"
      20                 : #include "nspr/prtime.h"
      21                 : #include "mozilla/HalSensor.h"
      22                 : #include "mozilla/HalTypes.h"
      23                 : 
      24                 : 
      25                 : //-----------------------------------------------------------------------------
      26                 : // Declaration of the IPDL type |struct BatteryInformation|
      27                 : //
      28                 : namespace mozilla {
      29                 : namespace hal {
      30                 : class BatteryInformation MOZ_FINAL
      31                 : {
      32                 : private:
      33                 : 
      34                 : public:
      35                 :     BatteryInformation();
      36                 : 
      37               0 :     BatteryInformation(
      38                 :             const double& _level,
      39                 :             const bool& _charging,
      40                 :             const double& _remainingTime)
      41                 :     {
      42               0 :         Init();
      43               0 :         Assign(_level, _charging, _remainingTime);
      44               0 :     }
      45                 : 
      46               0 :     BatteryInformation(const BatteryInformation& _o)
      47                 :     {
      48               0 :         Init();
      49               0 :         Assign((_o).level(), (_o).charging(), (_o).remainingTime());
      50               0 :     }
      51                 : 
      52                 :     ~BatteryInformation();
      53                 : 
      54                 :     void
      55               0 :     operator=(const BatteryInformation& _o)
      56                 :     {
      57               0 :         Assign((_o).level(), (_o).charging(), (_o).remainingTime());
      58               0 :     }
      59                 : 
      60                 :     bool
      61                 :     operator==(const BatteryInformation& _o) const;
      62                 : 
      63                 :     double&
      64               0 :     level()
      65                 :     {
      66               0 :         return level_;
      67                 :     }
      68                 :     const double&
      69               0 :     level() const
      70                 :     {
      71               0 :         return level_;
      72                 :     }
      73                 : 
      74                 :     bool&
      75               0 :     charging()
      76                 :     {
      77               0 :         return charging_;
      78                 :     }
      79                 :     const bool&
      80               0 :     charging() const
      81                 :     {
      82               0 :         return charging_;
      83                 :     }
      84                 : 
      85                 :     double&
      86               0 :     remainingTime()
      87                 :     {
      88               0 :         return remainingTime_;
      89                 :     }
      90                 :     const double&
      91               0 :     remainingTime() const
      92                 :     {
      93               0 :         return remainingTime_;
      94                 :     }
      95                 : 
      96                 : private:
      97                 :     void
      98                 :     Init();
      99                 : 
     100                 :     void
     101                 :     Assign(
     102                 :             const double& _level,
     103                 :             const bool& _charging,
     104                 :             const double& _remainingTime);
     105                 : 
     106                 :     double level_;
     107                 :     bool charging_;
     108                 :     double remainingTime_;
     109                 : };
     110                 : } // namespace hal
     111                 : } // namespace mozilla
     112                 : 
     113                 : 
     114                 : //-----------------------------------------------------------------------------
     115                 : // Declaration of the IPDL type |struct LightConfiguration|
     116                 : //
     117                 : namespace mozilla {
     118                 : namespace hal {
     119                 : class LightConfiguration MOZ_FINAL
     120                 : {
     121                 : private:
     122                 :     typedef mozilla::hal::LightType LightType;
     123                 :     typedef mozilla::hal::LightMode LightMode;
     124                 :     typedef mozilla::hal::FlashMode FlashMode;
     125                 : 
     126                 : public:
     127                 :     LightConfiguration();
     128                 : 
     129                 :     LightConfiguration(
     130                 :             const LightType& _light,
     131                 :             const LightMode& _mode,
     132                 :             const FlashMode& _flash,
     133                 :             const uint32_t& _flashOnMS,
     134                 :             const uint32_t& _flashOffMS,
     135                 :             const uint32_t& _color)
     136                 :     {
     137                 :         Init();
     138                 :         Assign(_light, _mode, _flash, _flashOnMS, _flashOffMS, _color);
     139                 :     }
     140                 : 
     141                 :     LightConfiguration(const LightConfiguration& _o)
     142                 :     {
     143                 :         Init();
     144                 :         Assign((_o).light(), (_o).mode(), (_o).flash(), (_o).flashOnMS(), (_o).flashOffMS(), (_o).color());
     145                 :     }
     146                 : 
     147                 :     ~LightConfiguration();
     148                 : 
     149                 :     void
     150                 :     operator=(const LightConfiguration& _o)
     151                 :     {
     152                 :         Assign((_o).light(), (_o).mode(), (_o).flash(), (_o).flashOnMS(), (_o).flashOffMS(), (_o).color());
     153                 :     }
     154                 : 
     155                 :     bool
     156                 :     operator==(const LightConfiguration& _o) const;
     157                 : 
     158                 :     LightType&
     159               0 :     light()
     160                 :     {
     161               0 :         return light_;
     162                 :     }
     163                 :     const LightType&
     164               0 :     light() const
     165                 :     {
     166               0 :         return light_;
     167                 :     }
     168                 : 
     169                 :     LightMode&
     170               0 :     mode()
     171                 :     {
     172               0 :         return mode_;
     173                 :     }
     174                 :     const LightMode&
     175               0 :     mode() const
     176                 :     {
     177               0 :         return mode_;
     178                 :     }
     179                 : 
     180                 :     FlashMode&
     181               0 :     flash()
     182                 :     {
     183               0 :         return flash_;
     184                 :     }
     185                 :     const FlashMode&
     186               0 :     flash() const
     187                 :     {
     188               0 :         return flash_;
     189                 :     }
     190                 : 
     191                 :     uint32_t&
     192               0 :     flashOnMS()
     193                 :     {
     194               0 :         return flashOnMS_;
     195                 :     }
     196                 :     const uint32_t&
     197               0 :     flashOnMS() const
     198                 :     {
     199               0 :         return flashOnMS_;
     200                 :     }
     201                 : 
     202                 :     uint32_t&
     203               0 :     flashOffMS()
     204                 :     {
     205               0 :         return flashOffMS_;
     206                 :     }
     207                 :     const uint32_t&
     208               0 :     flashOffMS() const
     209                 :     {
     210               0 :         return flashOffMS_;
     211                 :     }
     212                 : 
     213                 :     uint32_t&
     214               0 :     color()
     215                 :     {
     216               0 :         return color_;
     217                 :     }
     218                 :     const uint32_t&
     219               0 :     color() const
     220                 :     {
     221               0 :         return color_;
     222                 :     }
     223                 : 
     224                 : private:
     225                 :     void
     226                 :     Init();
     227                 : 
     228                 :     void
     229                 :     Assign(
     230                 :             const LightType& _light,
     231                 :             const LightMode& _mode,
     232                 :             const FlashMode& _flash,
     233                 :             const uint32_t& _flashOnMS,
     234                 :             const uint32_t& _flashOffMS,
     235                 :             const uint32_t& _color);
     236                 : 
     237                 :     LightType light_;
     238                 :     LightMode mode_;
     239                 :     FlashMode flash_;
     240                 :     uint32_t flashOnMS_;
     241                 :     uint32_t flashOffMS_;
     242                 :     uint32_t color_;
     243                 : };
     244                 : } // namespace hal
     245                 : } // namespace mozilla
     246                 : 
     247                 : 
     248                 : //-----------------------------------------------------------------------------
     249                 : // Declaration of the IPDL type |struct SensorData|
     250                 : //
     251                 : namespace mozilla {
     252                 : namespace hal {
     253                 : class SensorData MOZ_FINAL
     254                 : {
     255                 : private:
     256                 :     typedef mozilla::hal::SensorType SensorType;
     257                 : 
     258                 : public:
     259                 :     SensorData();
     260                 : 
     261                 :     SensorData(
     262                 :             const SensorType& _sensor,
     263                 :             const PRTime& _timestamp,
     264                 :             const InfallibleTArray<float>& _values)
     265                 :     {
     266                 :         Init();
     267                 :         Assign(_sensor, _timestamp, _values);
     268                 :     }
     269                 : 
     270                 :     SensorData(const SensorData& _o)
     271                 :     {
     272                 :         Init();
     273                 :         Assign((_o).sensor(), (_o).timestamp(), (_o).values());
     274                 :     }
     275                 : 
     276                 :     ~SensorData();
     277                 : 
     278                 :     void
     279                 :     operator=(const SensorData& _o)
     280                 :     {
     281                 :         Assign((_o).sensor(), (_o).timestamp(), (_o).values());
     282                 :     }
     283                 : 
     284                 :     bool
     285                 :     operator==(const SensorData& _o) const;
     286                 : 
     287                 :     SensorType&
     288               0 :     sensor()
     289                 :     {
     290               0 :         return sensor_;
     291                 :     }
     292                 :     const SensorType&
     293               0 :     sensor() const
     294                 :     {
     295               0 :         return sensor_;
     296                 :     }
     297                 : 
     298                 :     PRTime&
     299               0 :     timestamp()
     300                 :     {
     301               0 :         return timestamp_;
     302                 :     }
     303                 :     const PRTime&
     304               0 :     timestamp() const
     305                 :     {
     306               0 :         return timestamp_;
     307                 :     }
     308                 : 
     309                 :     InfallibleTArray<float>&
     310               0 :     values()
     311                 :     {
     312               0 :         return values_;
     313                 :     }
     314                 :     const InfallibleTArray<float>&
     315               0 :     values() const
     316                 :     {
     317               0 :         return values_;
     318                 :     }
     319                 : 
     320                 : private:
     321                 :     void
     322                 :     Init();
     323                 : 
     324                 :     void
     325                 :     Assign(
     326                 :             const SensorType& _sensor,
     327                 :             const PRTime& _timestamp,
     328                 :             const InfallibleTArray<float>& _values);
     329                 : 
     330                 :     SensorType sensor_;
     331                 :     PRTime timestamp_;
     332                 :     InfallibleTArray<float> values_;
     333                 : };
     334                 : } // namespace hal
     335                 : } // namespace mozilla
     336                 : 
     337                 : 
     338                 : //-----------------------------------------------------------------------------
     339                 : // Declaration of the IPDL type |struct NetworkInformation|
     340                 : //
     341                 : namespace mozilla {
     342                 : namespace hal {
     343                 : class NetworkInformation MOZ_FINAL
     344                 : {
     345                 : private:
     346                 : 
     347                 : public:
     348                 :     NetworkInformation();
     349                 : 
     350                 :     NetworkInformation(
     351                 :             const double& _bandwidth,
     352                 :             const bool& _canBeMetered)
     353                 :     {
     354                 :         Init();
     355                 :         Assign(_bandwidth, _canBeMetered);
     356                 :     }
     357                 : 
     358               0 :     NetworkInformation(const NetworkInformation& _o)
     359                 :     {
     360               0 :         Init();
     361               0 :         Assign((_o).bandwidth(), (_o).canBeMetered());
     362               0 :     }
     363                 : 
     364                 :     ~NetworkInformation();
     365                 : 
     366                 :     void
     367               0 :     operator=(const NetworkInformation& _o)
     368                 :     {
     369               0 :         Assign((_o).bandwidth(), (_o).canBeMetered());
     370               0 :     }
     371                 : 
     372                 :     bool
     373                 :     operator==(const NetworkInformation& _o) const;
     374                 : 
     375                 :     double&
     376               0 :     bandwidth()
     377                 :     {
     378               0 :         return bandwidth_;
     379                 :     }
     380                 :     const double&
     381               0 :     bandwidth() const
     382                 :     {
     383               0 :         return bandwidth_;
     384                 :     }
     385                 : 
     386                 :     bool&
     387               0 :     canBeMetered()
     388                 :     {
     389               0 :         return canBeMetered_;
     390                 :     }
     391                 :     const bool&
     392               0 :     canBeMetered() const
     393                 :     {
     394               0 :         return canBeMetered_;
     395                 :     }
     396                 : 
     397                 : private:
     398                 :     void
     399                 :     Init();
     400                 : 
     401                 :     void
     402                 :     Assign(
     403                 :             const double& _bandwidth,
     404                 :             const bool& _canBeMetered);
     405                 : 
     406                 :     double bandwidth_;
     407                 :     bool canBeMetered_;
     408                 : };
     409                 : } // namespace hal
     410                 : } // namespace mozilla
     411                 : 
     412                 : 
     413                 : //-----------------------------------------------------------------------------
     414                 : // Declaration of the IPDL type |struct WakeLockInformation|
     415                 : //
     416                 : namespace mozilla {
     417                 : namespace hal {
     418                 : class WakeLockInformation MOZ_FINAL
     419                 : {
     420                 : private:
     421                 : 
     422                 : public:
     423                 :     WakeLockInformation();
     424                 : 
     425                 :     WakeLockInformation(
     426                 :             const uint32_t& _numLocks,
     427                 :             const uint32_t& _numHidden,
     428                 :             const nsString& _topic)
     429                 :     {
     430                 :         Init();
     431                 :         Assign(_numLocks, _numHidden, _topic);
     432                 :     }
     433                 : 
     434                 :     WakeLockInformation(const WakeLockInformation& _o)
     435                 :     {
     436                 :         Init();
     437                 :         Assign((_o).numLocks(), (_o).numHidden(), (_o).topic());
     438                 :     }
     439                 : 
     440                 :     ~WakeLockInformation();
     441                 : 
     442                 :     void
     443                 :     operator=(const WakeLockInformation& _o)
     444                 :     {
     445                 :         Assign((_o).numLocks(), (_o).numHidden(), (_o).topic());
     446                 :     }
     447                 : 
     448                 :     bool
     449                 :     operator==(const WakeLockInformation& _o) const;
     450                 : 
     451                 :     uint32_t&
     452               0 :     numLocks()
     453                 :     {
     454               0 :         return numLocks_;
     455                 :     }
     456                 :     const uint32_t&
     457               0 :     numLocks() const
     458                 :     {
     459               0 :         return numLocks_;
     460                 :     }
     461                 : 
     462                 :     uint32_t&
     463               0 :     numHidden()
     464                 :     {
     465               0 :         return numHidden_;
     466                 :     }
     467                 :     const uint32_t&
     468               0 :     numHidden() const
     469                 :     {
     470               0 :         return numHidden_;
     471                 :     }
     472                 : 
     473                 :     nsString&
     474               0 :     topic()
     475                 :     {
     476               0 :         return topic_;
     477                 :     }
     478                 :     const nsString&
     479               0 :     topic() const
     480                 :     {
     481               0 :         return topic_;
     482                 :     }
     483                 : 
     484                 : private:
     485                 :     void
     486                 :     Init();
     487                 : 
     488                 :     void
     489                 :     Assign(
     490                 :             const uint32_t& _numLocks,
     491                 :             const uint32_t& _numHidden,
     492                 :             const nsString& _topic);
     493                 : 
     494                 :     uint32_t numLocks_;
     495                 :     uint32_t numHidden_;
     496                 :     nsString topic_;
     497                 : };
     498                 : } // namespace hal
     499                 : } // namespace mozilla
     500                 : 
     501                 : //-----------------------------------------------------------------------------
     502                 : // Code common to PHalChild and PHalParent
     503                 : //
     504                 : namespace mozilla {
     505                 : namespace hal_sandbox {
     506                 : namespace PHal {
     507                 : 
     508                 : enum State {
     509                 :     __Dead,
     510                 :     __Null,
     511                 :     __Error,
     512                 :     __Start = __Null
     513                 : };
     514                 : 
     515                 : enum MessageType {
     516                 :     PHalStart = PHalMsgStart << 16,
     517                 :     PHalPreStart = (PHalMsgStart << 16) - 1,
     518                 :     Msg_NotifyBatteryChange__ID,
     519                 :     Msg_NotifyNetworkChange__ID,
     520                 :     Msg_NotifyWakeLockChange__ID,
     521                 :     Msg_Vibrate__ID,
     522                 :     Msg_CancelVibrate__ID,
     523                 :     Msg_EnableBatteryNotifications__ID,
     524                 :     Msg_DisableBatteryNotifications__ID,
     525                 :     Msg_GetCurrentBatteryInformation__ID,
     526                 :     Reply_GetCurrentBatteryInformation__ID,
     527                 :     Msg_EnableNetworkNotifications__ID,
     528                 :     Msg_DisableNetworkNotifications__ID,
     529                 :     Msg_GetCurrentNetworkInformation__ID,
     530                 :     Reply_GetCurrentNetworkInformation__ID,
     531                 :     Msg_GetScreenEnabled__ID,
     532                 :     Reply_GetScreenEnabled__ID,
     533                 :     Msg_SetScreenEnabled__ID,
     534                 :     Msg_GetScreenBrightness__ID,
     535                 :     Reply_GetScreenBrightness__ID,
     536                 :     Msg_SetScreenBrightness__ID,
     537                 :     Msg_AdjustSystemClock__ID,
     538                 :     Msg_SetTimezone__ID,
     539                 :     Msg_SetLight__ID,
     540                 :     Reply_SetLight__ID,
     541                 :     Msg_GetLight__ID,
     542                 :     Reply_GetLight__ID,
     543                 :     Msg_Reboot__ID,
     544                 :     Msg_PowerOff__ID,
     545                 :     Msg_ModifyWakeLock__ID,
     546                 :     Msg_EnableWakeLockNotifications__ID,
     547                 :     Msg_DisableWakeLockNotifications__ID,
     548                 :     Msg_GetWakeLockInfo__ID,
     549                 :     Reply_GetWakeLockInfo__ID,
     550                 :     Msg_NotifySensorChange__ID,
     551                 :     Msg_EnableSensorNotifications__ID,
     552                 :     Msg_DisableSensorNotifications__ID,
     553                 :     Msg___delete____ID,
     554                 :     Reply___delete____ID,
     555                 :     PHalEnd
     556                 : };
     557                 : 
     558                 : bool
     559                 : Transition(
     560                 :         State from,
     561                 :         mozilla::ipc::Trigger trigger,
     562                 :         State* next);
     563                 : 
     564                 : class Msg_NotifyBatteryChange :
     565                 :     public IPC::Message
     566               0 : {
     567                 : private:
     568                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     569                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     570                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     571                 :     typedef mozilla::hal::SensorData SensorData;
     572                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     573                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     574                 :     typedef mozilla::ipc::Shmem Shmem;
     575                 :     typedef mozilla::hal::FlashMode FlashMode;
     576                 :     typedef mozilla::hal::LightType LightType;
     577                 :     typedef mozilla::hal::LightMode LightMode;
     578                 :     typedef mozilla::hal::SensorType SensorType;
     579                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     580                 : 
     581                 : public:
     582                 :     enum {
     583                 :         ID = Msg_NotifyBatteryChange__ID
     584                 :     };
     585               0 :     Msg_NotifyBatteryChange() :
     586               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_NotifyBatteryChange")
     587                 :     {
     588               0 :     }
     589                 : 
     590                 :     void
     591               0 :     Log(
     592                 :             const std::string& __pfx,
     593                 :             FILE* __outf) const
     594                 :     {
     595               0 :         std::string __logmsg;
     596               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     597               0 :         (__logmsg).append(__pfx);
     598               0 :         (__logmsg).append("Msg_NotifyBatteryChange(");
     599                 : 
     600               0 :         (__logmsg).append("[TODO])\n");
     601               0 :         fputs((__logmsg).c_str(), __outf);
     602               0 :     }
     603                 : };
     604                 : 
     605                 : class Msg_NotifyNetworkChange :
     606                 :     public IPC::Message
     607               0 : {
     608                 : private:
     609                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     610                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     611                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     612                 :     typedef mozilla::hal::SensorData SensorData;
     613                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     614                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     615                 :     typedef mozilla::ipc::Shmem Shmem;
     616                 :     typedef mozilla::hal::FlashMode FlashMode;
     617                 :     typedef mozilla::hal::LightType LightType;
     618                 :     typedef mozilla::hal::LightMode LightMode;
     619                 :     typedef mozilla::hal::SensorType SensorType;
     620                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     621                 : 
     622                 : public:
     623                 :     enum {
     624                 :         ID = Msg_NotifyNetworkChange__ID
     625                 :     };
     626               0 :     Msg_NotifyNetworkChange() :
     627               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_NotifyNetworkChange")
     628                 :     {
     629               0 :     }
     630                 : 
     631                 :     void
     632               0 :     Log(
     633                 :             const std::string& __pfx,
     634                 :             FILE* __outf) const
     635                 :     {
     636               0 :         std::string __logmsg;
     637               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     638               0 :         (__logmsg).append(__pfx);
     639               0 :         (__logmsg).append("Msg_NotifyNetworkChange(");
     640                 : 
     641               0 :         (__logmsg).append("[TODO])\n");
     642               0 :         fputs((__logmsg).c_str(), __outf);
     643               0 :     }
     644                 : };
     645                 : 
     646                 : class Msg_NotifyWakeLockChange :
     647                 :     public IPC::Message
     648               0 : {
     649                 : private:
     650                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     651                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     652                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     653                 :     typedef mozilla::hal::SensorData SensorData;
     654                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     655                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     656                 :     typedef mozilla::ipc::Shmem Shmem;
     657                 :     typedef mozilla::hal::FlashMode FlashMode;
     658                 :     typedef mozilla::hal::LightType LightType;
     659                 :     typedef mozilla::hal::LightMode LightMode;
     660                 :     typedef mozilla::hal::SensorType SensorType;
     661                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     662                 : 
     663                 : public:
     664                 :     enum {
     665                 :         ID = Msg_NotifyWakeLockChange__ID
     666                 :     };
     667               0 :     Msg_NotifyWakeLockChange() :
     668               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_NotifyWakeLockChange")
     669                 :     {
     670               0 :     }
     671                 : 
     672                 :     void
     673               0 :     Log(
     674                 :             const std::string& __pfx,
     675                 :             FILE* __outf) const
     676                 :     {
     677               0 :         std::string __logmsg;
     678               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     679               0 :         (__logmsg).append(__pfx);
     680               0 :         (__logmsg).append("Msg_NotifyWakeLockChange(");
     681                 : 
     682               0 :         (__logmsg).append("[TODO])\n");
     683               0 :         fputs((__logmsg).c_str(), __outf);
     684               0 :     }
     685                 : };
     686                 : 
     687                 : class Msg_Vibrate :
     688                 :     public IPC::Message
     689               0 : {
     690                 : private:
     691                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     692                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     693                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     694                 :     typedef mozilla::hal::SensorData SensorData;
     695                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     696                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     697                 :     typedef mozilla::ipc::Shmem Shmem;
     698                 :     typedef mozilla::hal::FlashMode FlashMode;
     699                 :     typedef mozilla::hal::LightType LightType;
     700                 :     typedef mozilla::hal::LightMode LightMode;
     701                 :     typedef mozilla::hal::SensorType SensorType;
     702                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     703                 : 
     704                 : public:
     705                 :     enum {
     706                 :         ID = Msg_Vibrate__ID
     707                 :     };
     708               0 :     Msg_Vibrate() :
     709               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_Vibrate")
     710                 :     {
     711               0 :     }
     712                 : 
     713                 :     void
     714               0 :     Log(
     715                 :             const std::string& __pfx,
     716                 :             FILE* __outf) const
     717                 :     {
     718               0 :         std::string __logmsg;
     719               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     720               0 :         (__logmsg).append(__pfx);
     721               0 :         (__logmsg).append("Msg_Vibrate(");
     722                 : 
     723               0 :         (__logmsg).append("[TODO])\n");
     724               0 :         fputs((__logmsg).c_str(), __outf);
     725               0 :     }
     726                 : };
     727                 : 
     728                 : class Msg_CancelVibrate :
     729                 :     public IPC::Message
     730               0 : {
     731                 : private:
     732                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     733                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     734                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     735                 :     typedef mozilla::hal::SensorData SensorData;
     736                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     737                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     738                 :     typedef mozilla::ipc::Shmem Shmem;
     739                 :     typedef mozilla::hal::FlashMode FlashMode;
     740                 :     typedef mozilla::hal::LightType LightType;
     741                 :     typedef mozilla::hal::LightMode LightMode;
     742                 :     typedef mozilla::hal::SensorType SensorType;
     743                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     744                 : 
     745                 : public:
     746                 :     enum {
     747                 :         ID = Msg_CancelVibrate__ID
     748                 :     };
     749               0 :     Msg_CancelVibrate() :
     750               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_CancelVibrate")
     751                 :     {
     752               0 :     }
     753                 : 
     754                 :     void
     755               0 :     Log(
     756                 :             const std::string& __pfx,
     757                 :             FILE* __outf) const
     758                 :     {
     759               0 :         std::string __logmsg;
     760               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     761               0 :         (__logmsg).append(__pfx);
     762               0 :         (__logmsg).append("Msg_CancelVibrate(");
     763                 : 
     764               0 :         (__logmsg).append("[TODO])\n");
     765               0 :         fputs((__logmsg).c_str(), __outf);
     766               0 :     }
     767                 : };
     768                 : 
     769                 : class Msg_EnableBatteryNotifications :
     770                 :     public IPC::Message
     771               0 : {
     772                 : private:
     773                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     774                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     775                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     776                 :     typedef mozilla::hal::SensorData SensorData;
     777                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     778                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     779                 :     typedef mozilla::ipc::Shmem Shmem;
     780                 :     typedef mozilla::hal::FlashMode FlashMode;
     781                 :     typedef mozilla::hal::LightType LightType;
     782                 :     typedef mozilla::hal::LightMode LightMode;
     783                 :     typedef mozilla::hal::SensorType SensorType;
     784                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     785                 : 
     786                 : public:
     787                 :     enum {
     788                 :         ID = Msg_EnableBatteryNotifications__ID
     789                 :     };
     790               0 :     Msg_EnableBatteryNotifications() :
     791               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_EnableBatteryNotifications")
     792                 :     {
     793               0 :     }
     794                 : 
     795                 :     void
     796               0 :     Log(
     797                 :             const std::string& __pfx,
     798                 :             FILE* __outf) const
     799                 :     {
     800               0 :         std::string __logmsg;
     801               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     802               0 :         (__logmsg).append(__pfx);
     803               0 :         (__logmsg).append("Msg_EnableBatteryNotifications(");
     804                 : 
     805               0 :         (__logmsg).append("[TODO])\n");
     806               0 :         fputs((__logmsg).c_str(), __outf);
     807               0 :     }
     808                 : };
     809                 : 
     810                 : class Msg_DisableBatteryNotifications :
     811                 :     public IPC::Message
     812               0 : {
     813                 : private:
     814                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     815                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     816                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     817                 :     typedef mozilla::hal::SensorData SensorData;
     818                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     819                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     820                 :     typedef mozilla::ipc::Shmem Shmem;
     821                 :     typedef mozilla::hal::FlashMode FlashMode;
     822                 :     typedef mozilla::hal::LightType LightType;
     823                 :     typedef mozilla::hal::LightMode LightMode;
     824                 :     typedef mozilla::hal::SensorType SensorType;
     825                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     826                 : 
     827                 : public:
     828                 :     enum {
     829                 :         ID = Msg_DisableBatteryNotifications__ID
     830                 :     };
     831               0 :     Msg_DisableBatteryNotifications() :
     832               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_DisableBatteryNotifications")
     833                 :     {
     834               0 :     }
     835                 : 
     836                 :     void
     837               0 :     Log(
     838                 :             const std::string& __pfx,
     839                 :             FILE* __outf) const
     840                 :     {
     841               0 :         std::string __logmsg;
     842               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     843               0 :         (__logmsg).append(__pfx);
     844               0 :         (__logmsg).append("Msg_DisableBatteryNotifications(");
     845                 : 
     846               0 :         (__logmsg).append("[TODO])\n");
     847               0 :         fputs((__logmsg).c_str(), __outf);
     848               0 :     }
     849                 : };
     850                 : 
     851                 : class Msg_GetCurrentBatteryInformation :
     852                 :     public IPC::Message
     853               0 : {
     854                 : private:
     855                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     856                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     857                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     858                 :     typedef mozilla::hal::SensorData SensorData;
     859                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     860                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     861                 :     typedef mozilla::ipc::Shmem Shmem;
     862                 :     typedef mozilla::hal::FlashMode FlashMode;
     863                 :     typedef mozilla::hal::LightType LightType;
     864                 :     typedef mozilla::hal::LightMode LightMode;
     865                 :     typedef mozilla::hal::SensorType SensorType;
     866                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     867                 : 
     868                 : public:
     869                 :     enum {
     870                 :         ID = Msg_GetCurrentBatteryInformation__ID
     871                 :     };
     872               0 :     Msg_GetCurrentBatteryInformation() :
     873               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_GetCurrentBatteryInformation")
     874                 :     {
     875               0 :     }
     876                 : 
     877                 :     void
     878               0 :     Log(
     879                 :             const std::string& __pfx,
     880                 :             FILE* __outf) const
     881                 :     {
     882               0 :         std::string __logmsg;
     883               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     884               0 :         (__logmsg).append(__pfx);
     885               0 :         (__logmsg).append("Msg_GetCurrentBatteryInformation(");
     886                 : 
     887               0 :         (__logmsg).append("[TODO])\n");
     888               0 :         fputs((__logmsg).c_str(), __outf);
     889               0 :     }
     890                 : };
     891                 : 
     892                 : class Reply_GetCurrentBatteryInformation :
     893                 :     public IPC::Message
     894               0 : {
     895                 : private:
     896                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     897                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     898                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     899                 :     typedef mozilla::hal::SensorData SensorData;
     900                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     901                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     902                 :     typedef mozilla::ipc::Shmem Shmem;
     903                 :     typedef mozilla::hal::FlashMode FlashMode;
     904                 :     typedef mozilla::hal::LightType LightType;
     905                 :     typedef mozilla::hal::LightMode LightMode;
     906                 :     typedef mozilla::hal::SensorType SensorType;
     907                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     908                 : 
     909                 : public:
     910                 :     enum {
     911                 :         ID = Reply_GetCurrentBatteryInformation__ID
     912                 :     };
     913               0 :     Reply_GetCurrentBatteryInformation() :
     914               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_GetCurrentBatteryInformation")
     915                 :     {
     916               0 :     }
     917                 : 
     918                 :     void
     919               0 :     Log(
     920                 :             const std::string& __pfx,
     921                 :             FILE* __outf) const
     922                 :     {
     923               0 :         std::string __logmsg;
     924               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     925               0 :         (__logmsg).append(__pfx);
     926               0 :         (__logmsg).append("Reply_GetCurrentBatteryInformation(");
     927                 : 
     928               0 :         (__logmsg).append("[TODO])\n");
     929               0 :         fputs((__logmsg).c_str(), __outf);
     930               0 :     }
     931                 : };
     932                 : 
     933                 : class Msg_EnableNetworkNotifications :
     934                 :     public IPC::Message
     935               0 : {
     936                 : private:
     937                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     938                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     939                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     940                 :     typedef mozilla::hal::SensorData SensorData;
     941                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     942                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     943                 :     typedef mozilla::ipc::Shmem Shmem;
     944                 :     typedef mozilla::hal::FlashMode FlashMode;
     945                 :     typedef mozilla::hal::LightType LightType;
     946                 :     typedef mozilla::hal::LightMode LightMode;
     947                 :     typedef mozilla::hal::SensorType SensorType;
     948                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     949                 : 
     950                 : public:
     951                 :     enum {
     952                 :         ID = Msg_EnableNetworkNotifications__ID
     953                 :     };
     954               0 :     Msg_EnableNetworkNotifications() :
     955               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_EnableNetworkNotifications")
     956                 :     {
     957               0 :     }
     958                 : 
     959                 :     void
     960               0 :     Log(
     961                 :             const std::string& __pfx,
     962                 :             FILE* __outf) const
     963                 :     {
     964               0 :         std::string __logmsg;
     965               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     966               0 :         (__logmsg).append(__pfx);
     967               0 :         (__logmsg).append("Msg_EnableNetworkNotifications(");
     968                 : 
     969               0 :         (__logmsg).append("[TODO])\n");
     970               0 :         fputs((__logmsg).c_str(), __outf);
     971               0 :     }
     972                 : };
     973                 : 
     974                 : class Msg_DisableNetworkNotifications :
     975                 :     public IPC::Message
     976               0 : {
     977                 : private:
     978                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     979                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
     980                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
     981                 :     typedef mozilla::hal::SensorData SensorData;
     982                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
     983                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
     984                 :     typedef mozilla::ipc::Shmem Shmem;
     985                 :     typedef mozilla::hal::FlashMode FlashMode;
     986                 :     typedef mozilla::hal::LightType LightType;
     987                 :     typedef mozilla::hal::LightMode LightMode;
     988                 :     typedef mozilla::hal::SensorType SensorType;
     989                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
     990                 : 
     991                 : public:
     992                 :     enum {
     993                 :         ID = Msg_DisableNetworkNotifications__ID
     994                 :     };
     995               0 :     Msg_DisableNetworkNotifications() :
     996               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_DisableNetworkNotifications")
     997                 :     {
     998               0 :     }
     999                 : 
    1000                 :     void
    1001               0 :     Log(
    1002                 :             const std::string& __pfx,
    1003                 :             FILE* __outf) const
    1004                 :     {
    1005               0 :         std::string __logmsg;
    1006               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1007               0 :         (__logmsg).append(__pfx);
    1008               0 :         (__logmsg).append("Msg_DisableNetworkNotifications(");
    1009                 : 
    1010               0 :         (__logmsg).append("[TODO])\n");
    1011               0 :         fputs((__logmsg).c_str(), __outf);
    1012               0 :     }
    1013                 : };
    1014                 : 
    1015                 : class Msg_GetCurrentNetworkInformation :
    1016                 :     public IPC::Message
    1017               0 : {
    1018                 : private:
    1019                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1020                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1021                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1022                 :     typedef mozilla::hal::SensorData SensorData;
    1023                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1024                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1025                 :     typedef mozilla::ipc::Shmem Shmem;
    1026                 :     typedef mozilla::hal::FlashMode FlashMode;
    1027                 :     typedef mozilla::hal::LightType LightType;
    1028                 :     typedef mozilla::hal::LightMode LightMode;
    1029                 :     typedef mozilla::hal::SensorType SensorType;
    1030                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1031                 : 
    1032                 : public:
    1033                 :     enum {
    1034                 :         ID = Msg_GetCurrentNetworkInformation__ID
    1035                 :     };
    1036               0 :     Msg_GetCurrentNetworkInformation() :
    1037               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_GetCurrentNetworkInformation")
    1038                 :     {
    1039               0 :     }
    1040                 : 
    1041                 :     void
    1042               0 :     Log(
    1043                 :             const std::string& __pfx,
    1044                 :             FILE* __outf) const
    1045                 :     {
    1046               0 :         std::string __logmsg;
    1047               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1048               0 :         (__logmsg).append(__pfx);
    1049               0 :         (__logmsg).append("Msg_GetCurrentNetworkInformation(");
    1050                 : 
    1051               0 :         (__logmsg).append("[TODO])\n");
    1052               0 :         fputs((__logmsg).c_str(), __outf);
    1053               0 :     }
    1054                 : };
    1055                 : 
    1056                 : class Reply_GetCurrentNetworkInformation :
    1057                 :     public IPC::Message
    1058               0 : {
    1059                 : private:
    1060                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1061                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1062                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1063                 :     typedef mozilla::hal::SensorData SensorData;
    1064                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1065                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1066                 :     typedef mozilla::ipc::Shmem Shmem;
    1067                 :     typedef mozilla::hal::FlashMode FlashMode;
    1068                 :     typedef mozilla::hal::LightType LightType;
    1069                 :     typedef mozilla::hal::LightMode LightMode;
    1070                 :     typedef mozilla::hal::SensorType SensorType;
    1071                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1072                 : 
    1073                 : public:
    1074                 :     enum {
    1075                 :         ID = Reply_GetCurrentNetworkInformation__ID
    1076                 :     };
    1077               0 :     Reply_GetCurrentNetworkInformation() :
    1078               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_GetCurrentNetworkInformation")
    1079                 :     {
    1080               0 :     }
    1081                 : 
    1082                 :     void
    1083               0 :     Log(
    1084                 :             const std::string& __pfx,
    1085                 :             FILE* __outf) const
    1086                 :     {
    1087               0 :         std::string __logmsg;
    1088               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1089               0 :         (__logmsg).append(__pfx);
    1090               0 :         (__logmsg).append("Reply_GetCurrentNetworkInformation(");
    1091                 : 
    1092               0 :         (__logmsg).append("[TODO])\n");
    1093               0 :         fputs((__logmsg).c_str(), __outf);
    1094               0 :     }
    1095                 : };
    1096                 : 
    1097                 : class Msg_GetScreenEnabled :
    1098                 :     public IPC::Message
    1099               0 : {
    1100                 : private:
    1101                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1102                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1103                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1104                 :     typedef mozilla::hal::SensorData SensorData;
    1105                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1106                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1107                 :     typedef mozilla::ipc::Shmem Shmem;
    1108                 :     typedef mozilla::hal::FlashMode FlashMode;
    1109                 :     typedef mozilla::hal::LightType LightType;
    1110                 :     typedef mozilla::hal::LightMode LightMode;
    1111                 :     typedef mozilla::hal::SensorType SensorType;
    1112                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1113                 : 
    1114                 : public:
    1115                 :     enum {
    1116                 :         ID = Msg_GetScreenEnabled__ID
    1117                 :     };
    1118               0 :     Msg_GetScreenEnabled() :
    1119               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_GetScreenEnabled")
    1120                 :     {
    1121               0 :     }
    1122                 : 
    1123                 :     void
    1124               0 :     Log(
    1125                 :             const std::string& __pfx,
    1126                 :             FILE* __outf) const
    1127                 :     {
    1128               0 :         std::string __logmsg;
    1129               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1130               0 :         (__logmsg).append(__pfx);
    1131               0 :         (__logmsg).append("Msg_GetScreenEnabled(");
    1132                 : 
    1133               0 :         (__logmsg).append("[TODO])\n");
    1134               0 :         fputs((__logmsg).c_str(), __outf);
    1135               0 :     }
    1136                 : };
    1137                 : 
    1138                 : class Reply_GetScreenEnabled :
    1139                 :     public IPC::Message
    1140               0 : {
    1141                 : private:
    1142                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1143                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1144                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1145                 :     typedef mozilla::hal::SensorData SensorData;
    1146                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1147                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1148                 :     typedef mozilla::ipc::Shmem Shmem;
    1149                 :     typedef mozilla::hal::FlashMode FlashMode;
    1150                 :     typedef mozilla::hal::LightType LightType;
    1151                 :     typedef mozilla::hal::LightMode LightMode;
    1152                 :     typedef mozilla::hal::SensorType SensorType;
    1153                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1154                 : 
    1155                 : public:
    1156                 :     enum {
    1157                 :         ID = Reply_GetScreenEnabled__ID
    1158                 :     };
    1159               0 :     Reply_GetScreenEnabled() :
    1160               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_GetScreenEnabled")
    1161                 :     {
    1162               0 :     }
    1163                 : 
    1164                 :     void
    1165               0 :     Log(
    1166                 :             const std::string& __pfx,
    1167                 :             FILE* __outf) const
    1168                 :     {
    1169               0 :         std::string __logmsg;
    1170               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1171               0 :         (__logmsg).append(__pfx);
    1172               0 :         (__logmsg).append("Reply_GetScreenEnabled(");
    1173                 : 
    1174               0 :         (__logmsg).append("[TODO])\n");
    1175               0 :         fputs((__logmsg).c_str(), __outf);
    1176               0 :     }
    1177                 : };
    1178                 : 
    1179                 : class Msg_SetScreenEnabled :
    1180                 :     public IPC::Message
    1181               0 : {
    1182                 : private:
    1183                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1184                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1185                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1186                 :     typedef mozilla::hal::SensorData SensorData;
    1187                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1188                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1189                 :     typedef mozilla::ipc::Shmem Shmem;
    1190                 :     typedef mozilla::hal::FlashMode FlashMode;
    1191                 :     typedef mozilla::hal::LightType LightType;
    1192                 :     typedef mozilla::hal::LightMode LightMode;
    1193                 :     typedef mozilla::hal::SensorType SensorType;
    1194                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1195                 : 
    1196                 : public:
    1197                 :     enum {
    1198                 :         ID = Msg_SetScreenEnabled__ID
    1199                 :     };
    1200               0 :     Msg_SetScreenEnabled() :
    1201               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_SetScreenEnabled")
    1202                 :     {
    1203               0 :     }
    1204                 : 
    1205                 :     void
    1206               0 :     Log(
    1207                 :             const std::string& __pfx,
    1208                 :             FILE* __outf) const
    1209                 :     {
    1210               0 :         std::string __logmsg;
    1211               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1212               0 :         (__logmsg).append(__pfx);
    1213               0 :         (__logmsg).append("Msg_SetScreenEnabled(");
    1214                 : 
    1215               0 :         (__logmsg).append("[TODO])\n");
    1216               0 :         fputs((__logmsg).c_str(), __outf);
    1217               0 :     }
    1218                 : };
    1219                 : 
    1220                 : class Msg_GetScreenBrightness :
    1221                 :     public IPC::Message
    1222               0 : {
    1223                 : private:
    1224                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1225                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1226                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1227                 :     typedef mozilla::hal::SensorData SensorData;
    1228                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1229                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1230                 :     typedef mozilla::ipc::Shmem Shmem;
    1231                 :     typedef mozilla::hal::FlashMode FlashMode;
    1232                 :     typedef mozilla::hal::LightType LightType;
    1233                 :     typedef mozilla::hal::LightMode LightMode;
    1234                 :     typedef mozilla::hal::SensorType SensorType;
    1235                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1236                 : 
    1237                 : public:
    1238                 :     enum {
    1239                 :         ID = Msg_GetScreenBrightness__ID
    1240                 :     };
    1241               0 :     Msg_GetScreenBrightness() :
    1242               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_GetScreenBrightness")
    1243                 :     {
    1244               0 :     }
    1245                 : 
    1246                 :     void
    1247               0 :     Log(
    1248                 :             const std::string& __pfx,
    1249                 :             FILE* __outf) const
    1250                 :     {
    1251               0 :         std::string __logmsg;
    1252               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1253               0 :         (__logmsg).append(__pfx);
    1254               0 :         (__logmsg).append("Msg_GetScreenBrightness(");
    1255                 : 
    1256               0 :         (__logmsg).append("[TODO])\n");
    1257               0 :         fputs((__logmsg).c_str(), __outf);
    1258               0 :     }
    1259                 : };
    1260                 : 
    1261                 : class Reply_GetScreenBrightness :
    1262                 :     public IPC::Message
    1263               0 : {
    1264                 : private:
    1265                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1266                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1267                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1268                 :     typedef mozilla::hal::SensorData SensorData;
    1269                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1270                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1271                 :     typedef mozilla::ipc::Shmem Shmem;
    1272                 :     typedef mozilla::hal::FlashMode FlashMode;
    1273                 :     typedef mozilla::hal::LightType LightType;
    1274                 :     typedef mozilla::hal::LightMode LightMode;
    1275                 :     typedef mozilla::hal::SensorType SensorType;
    1276                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1277                 : 
    1278                 : public:
    1279                 :     enum {
    1280                 :         ID = Reply_GetScreenBrightness__ID
    1281                 :     };
    1282               0 :     Reply_GetScreenBrightness() :
    1283               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_GetScreenBrightness")
    1284                 :     {
    1285               0 :     }
    1286                 : 
    1287                 :     void
    1288               0 :     Log(
    1289                 :             const std::string& __pfx,
    1290                 :             FILE* __outf) const
    1291                 :     {
    1292               0 :         std::string __logmsg;
    1293               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1294               0 :         (__logmsg).append(__pfx);
    1295               0 :         (__logmsg).append("Reply_GetScreenBrightness(");
    1296                 : 
    1297               0 :         (__logmsg).append("[TODO])\n");
    1298               0 :         fputs((__logmsg).c_str(), __outf);
    1299               0 :     }
    1300                 : };
    1301                 : 
    1302                 : class Msg_SetScreenBrightness :
    1303                 :     public IPC::Message
    1304               0 : {
    1305                 : private:
    1306                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1307                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1308                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1309                 :     typedef mozilla::hal::SensorData SensorData;
    1310                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1311                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1312                 :     typedef mozilla::ipc::Shmem Shmem;
    1313                 :     typedef mozilla::hal::FlashMode FlashMode;
    1314                 :     typedef mozilla::hal::LightType LightType;
    1315                 :     typedef mozilla::hal::LightMode LightMode;
    1316                 :     typedef mozilla::hal::SensorType SensorType;
    1317                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1318                 : 
    1319                 : public:
    1320                 :     enum {
    1321                 :         ID = Msg_SetScreenBrightness__ID
    1322                 :     };
    1323               0 :     Msg_SetScreenBrightness() :
    1324               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_SetScreenBrightness")
    1325                 :     {
    1326               0 :     }
    1327                 : 
    1328                 :     void
    1329               0 :     Log(
    1330                 :             const std::string& __pfx,
    1331                 :             FILE* __outf) const
    1332                 :     {
    1333               0 :         std::string __logmsg;
    1334               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1335               0 :         (__logmsg).append(__pfx);
    1336               0 :         (__logmsg).append("Msg_SetScreenBrightness(");
    1337                 : 
    1338               0 :         (__logmsg).append("[TODO])\n");
    1339               0 :         fputs((__logmsg).c_str(), __outf);
    1340               0 :     }
    1341                 : };
    1342                 : 
    1343                 : class Msg_AdjustSystemClock :
    1344                 :     public IPC::Message
    1345               0 : {
    1346                 : private:
    1347                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1348                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1349                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1350                 :     typedef mozilla::hal::SensorData SensorData;
    1351                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1352                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1353                 :     typedef mozilla::ipc::Shmem Shmem;
    1354                 :     typedef mozilla::hal::FlashMode FlashMode;
    1355                 :     typedef mozilla::hal::LightType LightType;
    1356                 :     typedef mozilla::hal::LightMode LightMode;
    1357                 :     typedef mozilla::hal::SensorType SensorType;
    1358                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1359                 : 
    1360                 : public:
    1361                 :     enum {
    1362                 :         ID = Msg_AdjustSystemClock__ID
    1363                 :     };
    1364               0 :     Msg_AdjustSystemClock() :
    1365               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_AdjustSystemClock")
    1366                 :     {
    1367               0 :     }
    1368                 : 
    1369                 :     void
    1370               0 :     Log(
    1371                 :             const std::string& __pfx,
    1372                 :             FILE* __outf) const
    1373                 :     {
    1374               0 :         std::string __logmsg;
    1375               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1376               0 :         (__logmsg).append(__pfx);
    1377               0 :         (__logmsg).append("Msg_AdjustSystemClock(");
    1378                 : 
    1379               0 :         (__logmsg).append("[TODO])\n");
    1380               0 :         fputs((__logmsg).c_str(), __outf);
    1381               0 :     }
    1382                 : };
    1383                 : 
    1384                 : class Msg_SetTimezone :
    1385                 :     public IPC::Message
    1386               0 : {
    1387                 : private:
    1388                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1389                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1390                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1391                 :     typedef mozilla::hal::SensorData SensorData;
    1392                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1393                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1394                 :     typedef mozilla::ipc::Shmem Shmem;
    1395                 :     typedef mozilla::hal::FlashMode FlashMode;
    1396                 :     typedef mozilla::hal::LightType LightType;
    1397                 :     typedef mozilla::hal::LightMode LightMode;
    1398                 :     typedef mozilla::hal::SensorType SensorType;
    1399                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1400                 : 
    1401                 : public:
    1402                 :     enum {
    1403                 :         ID = Msg_SetTimezone__ID
    1404                 :     };
    1405               0 :     Msg_SetTimezone() :
    1406               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_SetTimezone")
    1407                 :     {
    1408               0 :     }
    1409                 : 
    1410                 :     void
    1411               0 :     Log(
    1412                 :             const std::string& __pfx,
    1413                 :             FILE* __outf) const
    1414                 :     {
    1415               0 :         std::string __logmsg;
    1416               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1417               0 :         (__logmsg).append(__pfx);
    1418               0 :         (__logmsg).append("Msg_SetTimezone(");
    1419                 : 
    1420               0 :         (__logmsg).append("[TODO])\n");
    1421               0 :         fputs((__logmsg).c_str(), __outf);
    1422               0 :     }
    1423                 : };
    1424                 : 
    1425                 : class Msg_SetLight :
    1426                 :     public IPC::Message
    1427               0 : {
    1428                 : private:
    1429                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1430                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1431                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1432                 :     typedef mozilla::hal::SensorData SensorData;
    1433                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1434                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1435                 :     typedef mozilla::ipc::Shmem Shmem;
    1436                 :     typedef mozilla::hal::FlashMode FlashMode;
    1437                 :     typedef mozilla::hal::LightType LightType;
    1438                 :     typedef mozilla::hal::LightMode LightMode;
    1439                 :     typedef mozilla::hal::SensorType SensorType;
    1440                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1441                 : 
    1442                 : public:
    1443                 :     enum {
    1444                 :         ID = Msg_SetLight__ID
    1445                 :     };
    1446               0 :     Msg_SetLight() :
    1447               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_SetLight")
    1448                 :     {
    1449               0 :     }
    1450                 : 
    1451                 :     void
    1452               0 :     Log(
    1453                 :             const std::string& __pfx,
    1454                 :             FILE* __outf) const
    1455                 :     {
    1456               0 :         std::string __logmsg;
    1457               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1458               0 :         (__logmsg).append(__pfx);
    1459               0 :         (__logmsg).append("Msg_SetLight(");
    1460                 : 
    1461               0 :         (__logmsg).append("[TODO])\n");
    1462               0 :         fputs((__logmsg).c_str(), __outf);
    1463               0 :     }
    1464                 : };
    1465                 : 
    1466                 : class Reply_SetLight :
    1467                 :     public IPC::Message
    1468               0 : {
    1469                 : private:
    1470                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1471                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1472                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1473                 :     typedef mozilla::hal::SensorData SensorData;
    1474                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1475                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1476                 :     typedef mozilla::ipc::Shmem Shmem;
    1477                 :     typedef mozilla::hal::FlashMode FlashMode;
    1478                 :     typedef mozilla::hal::LightType LightType;
    1479                 :     typedef mozilla::hal::LightMode LightMode;
    1480                 :     typedef mozilla::hal::SensorType SensorType;
    1481                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1482                 : 
    1483                 : public:
    1484                 :     enum {
    1485                 :         ID = Reply_SetLight__ID
    1486                 :     };
    1487               0 :     Reply_SetLight() :
    1488               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_SetLight")
    1489                 :     {
    1490               0 :     }
    1491                 : 
    1492                 :     void
    1493               0 :     Log(
    1494                 :             const std::string& __pfx,
    1495                 :             FILE* __outf) const
    1496                 :     {
    1497               0 :         std::string __logmsg;
    1498               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1499               0 :         (__logmsg).append(__pfx);
    1500               0 :         (__logmsg).append("Reply_SetLight(");
    1501                 : 
    1502               0 :         (__logmsg).append("[TODO])\n");
    1503               0 :         fputs((__logmsg).c_str(), __outf);
    1504               0 :     }
    1505                 : };
    1506                 : 
    1507                 : class Msg_GetLight :
    1508                 :     public IPC::Message
    1509               0 : {
    1510                 : private:
    1511                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1512                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1513                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1514                 :     typedef mozilla::hal::SensorData SensorData;
    1515                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1516                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1517                 :     typedef mozilla::ipc::Shmem Shmem;
    1518                 :     typedef mozilla::hal::FlashMode FlashMode;
    1519                 :     typedef mozilla::hal::LightType LightType;
    1520                 :     typedef mozilla::hal::LightMode LightMode;
    1521                 :     typedef mozilla::hal::SensorType SensorType;
    1522                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1523                 : 
    1524                 : public:
    1525                 :     enum {
    1526                 :         ID = Msg_GetLight__ID
    1527                 :     };
    1528               0 :     Msg_GetLight() :
    1529               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_GetLight")
    1530                 :     {
    1531               0 :     }
    1532                 : 
    1533                 :     void
    1534               0 :     Log(
    1535                 :             const std::string& __pfx,
    1536                 :             FILE* __outf) const
    1537                 :     {
    1538               0 :         std::string __logmsg;
    1539               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1540               0 :         (__logmsg).append(__pfx);
    1541               0 :         (__logmsg).append("Msg_GetLight(");
    1542                 : 
    1543               0 :         (__logmsg).append("[TODO])\n");
    1544               0 :         fputs((__logmsg).c_str(), __outf);
    1545               0 :     }
    1546                 : };
    1547                 : 
    1548                 : class Reply_GetLight :
    1549                 :     public IPC::Message
    1550               0 : {
    1551                 : private:
    1552                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1553                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1554                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1555                 :     typedef mozilla::hal::SensorData SensorData;
    1556                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1557                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1558                 :     typedef mozilla::ipc::Shmem Shmem;
    1559                 :     typedef mozilla::hal::FlashMode FlashMode;
    1560                 :     typedef mozilla::hal::LightType LightType;
    1561                 :     typedef mozilla::hal::LightMode LightMode;
    1562                 :     typedef mozilla::hal::SensorType SensorType;
    1563                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1564                 : 
    1565                 : public:
    1566                 :     enum {
    1567                 :         ID = Reply_GetLight__ID
    1568                 :     };
    1569               0 :     Reply_GetLight() :
    1570               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_GetLight")
    1571                 :     {
    1572               0 :     }
    1573                 : 
    1574                 :     void
    1575               0 :     Log(
    1576                 :             const std::string& __pfx,
    1577                 :             FILE* __outf) const
    1578                 :     {
    1579               0 :         std::string __logmsg;
    1580               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1581               0 :         (__logmsg).append(__pfx);
    1582               0 :         (__logmsg).append("Reply_GetLight(");
    1583                 : 
    1584               0 :         (__logmsg).append("[TODO])\n");
    1585               0 :         fputs((__logmsg).c_str(), __outf);
    1586               0 :     }
    1587                 : };
    1588                 : 
    1589                 : class Msg_Reboot :
    1590                 :     public IPC::Message
    1591               0 : {
    1592                 : private:
    1593                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1594                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1595                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1596                 :     typedef mozilla::hal::SensorData SensorData;
    1597                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1598                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1599                 :     typedef mozilla::ipc::Shmem Shmem;
    1600                 :     typedef mozilla::hal::FlashMode FlashMode;
    1601                 :     typedef mozilla::hal::LightType LightType;
    1602                 :     typedef mozilla::hal::LightMode LightMode;
    1603                 :     typedef mozilla::hal::SensorType SensorType;
    1604                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1605                 : 
    1606                 : public:
    1607                 :     enum {
    1608                 :         ID = Msg_Reboot__ID
    1609                 :     };
    1610               0 :     Msg_Reboot() :
    1611               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_Reboot")
    1612                 :     {
    1613               0 :     }
    1614                 : 
    1615                 :     void
    1616               0 :     Log(
    1617                 :             const std::string& __pfx,
    1618                 :             FILE* __outf) const
    1619                 :     {
    1620               0 :         std::string __logmsg;
    1621               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1622               0 :         (__logmsg).append(__pfx);
    1623               0 :         (__logmsg).append("Msg_Reboot(");
    1624                 : 
    1625               0 :         (__logmsg).append("[TODO])\n");
    1626               0 :         fputs((__logmsg).c_str(), __outf);
    1627               0 :     }
    1628                 : };
    1629                 : 
    1630                 : class Msg_PowerOff :
    1631                 :     public IPC::Message
    1632               0 : {
    1633                 : private:
    1634                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1635                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1636                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1637                 :     typedef mozilla::hal::SensorData SensorData;
    1638                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1639                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1640                 :     typedef mozilla::ipc::Shmem Shmem;
    1641                 :     typedef mozilla::hal::FlashMode FlashMode;
    1642                 :     typedef mozilla::hal::LightType LightType;
    1643                 :     typedef mozilla::hal::LightMode LightMode;
    1644                 :     typedef mozilla::hal::SensorType SensorType;
    1645                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1646                 : 
    1647                 : public:
    1648                 :     enum {
    1649                 :         ID = Msg_PowerOff__ID
    1650                 :     };
    1651               0 :     Msg_PowerOff() :
    1652               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_PowerOff")
    1653                 :     {
    1654               0 :     }
    1655                 : 
    1656                 :     void
    1657               0 :     Log(
    1658                 :             const std::string& __pfx,
    1659                 :             FILE* __outf) const
    1660                 :     {
    1661               0 :         std::string __logmsg;
    1662               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1663               0 :         (__logmsg).append(__pfx);
    1664               0 :         (__logmsg).append("Msg_PowerOff(");
    1665                 : 
    1666               0 :         (__logmsg).append("[TODO])\n");
    1667               0 :         fputs((__logmsg).c_str(), __outf);
    1668               0 :     }
    1669                 : };
    1670                 : 
    1671                 : class Msg_ModifyWakeLock :
    1672                 :     public IPC::Message
    1673               0 : {
    1674                 : private:
    1675                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1676                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1677                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1678                 :     typedef mozilla::hal::SensorData SensorData;
    1679                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1680                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1681                 :     typedef mozilla::ipc::Shmem Shmem;
    1682                 :     typedef mozilla::hal::FlashMode FlashMode;
    1683                 :     typedef mozilla::hal::LightType LightType;
    1684                 :     typedef mozilla::hal::LightMode LightMode;
    1685                 :     typedef mozilla::hal::SensorType SensorType;
    1686                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1687                 : 
    1688                 : public:
    1689                 :     enum {
    1690                 :         ID = Msg_ModifyWakeLock__ID
    1691                 :     };
    1692               0 :     Msg_ModifyWakeLock() :
    1693               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_ModifyWakeLock")
    1694                 :     {
    1695               0 :     }
    1696                 : 
    1697                 :     void
    1698               0 :     Log(
    1699                 :             const std::string& __pfx,
    1700                 :             FILE* __outf) const
    1701                 :     {
    1702               0 :         std::string __logmsg;
    1703               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1704               0 :         (__logmsg).append(__pfx);
    1705               0 :         (__logmsg).append("Msg_ModifyWakeLock(");
    1706                 : 
    1707               0 :         (__logmsg).append("[TODO])\n");
    1708               0 :         fputs((__logmsg).c_str(), __outf);
    1709               0 :     }
    1710                 : };
    1711                 : 
    1712                 : class Msg_EnableWakeLockNotifications :
    1713                 :     public IPC::Message
    1714               0 : {
    1715                 : private:
    1716                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1717                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1718                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1719                 :     typedef mozilla::hal::SensorData SensorData;
    1720                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1721                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1722                 :     typedef mozilla::ipc::Shmem Shmem;
    1723                 :     typedef mozilla::hal::FlashMode FlashMode;
    1724                 :     typedef mozilla::hal::LightType LightType;
    1725                 :     typedef mozilla::hal::LightMode LightMode;
    1726                 :     typedef mozilla::hal::SensorType SensorType;
    1727                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1728                 : 
    1729                 : public:
    1730                 :     enum {
    1731                 :         ID = Msg_EnableWakeLockNotifications__ID
    1732                 :     };
    1733               0 :     Msg_EnableWakeLockNotifications() :
    1734               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_EnableWakeLockNotifications")
    1735                 :     {
    1736               0 :     }
    1737                 : 
    1738                 :     void
    1739               0 :     Log(
    1740                 :             const std::string& __pfx,
    1741                 :             FILE* __outf) const
    1742                 :     {
    1743               0 :         std::string __logmsg;
    1744               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1745               0 :         (__logmsg).append(__pfx);
    1746               0 :         (__logmsg).append("Msg_EnableWakeLockNotifications(");
    1747                 : 
    1748               0 :         (__logmsg).append("[TODO])\n");
    1749               0 :         fputs((__logmsg).c_str(), __outf);
    1750               0 :     }
    1751                 : };
    1752                 : 
    1753                 : class Msg_DisableWakeLockNotifications :
    1754                 :     public IPC::Message
    1755               0 : {
    1756                 : private:
    1757                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1758                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1759                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1760                 :     typedef mozilla::hal::SensorData SensorData;
    1761                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1762                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1763                 :     typedef mozilla::ipc::Shmem Shmem;
    1764                 :     typedef mozilla::hal::FlashMode FlashMode;
    1765                 :     typedef mozilla::hal::LightType LightType;
    1766                 :     typedef mozilla::hal::LightMode LightMode;
    1767                 :     typedef mozilla::hal::SensorType SensorType;
    1768                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1769                 : 
    1770                 : public:
    1771                 :     enum {
    1772                 :         ID = Msg_DisableWakeLockNotifications__ID
    1773                 :     };
    1774               0 :     Msg_DisableWakeLockNotifications() :
    1775               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_DisableWakeLockNotifications")
    1776                 :     {
    1777               0 :     }
    1778                 : 
    1779                 :     void
    1780               0 :     Log(
    1781                 :             const std::string& __pfx,
    1782                 :             FILE* __outf) const
    1783                 :     {
    1784               0 :         std::string __logmsg;
    1785               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1786               0 :         (__logmsg).append(__pfx);
    1787               0 :         (__logmsg).append("Msg_DisableWakeLockNotifications(");
    1788                 : 
    1789               0 :         (__logmsg).append("[TODO])\n");
    1790               0 :         fputs((__logmsg).c_str(), __outf);
    1791               0 :     }
    1792                 : };
    1793                 : 
    1794                 : class Msg_GetWakeLockInfo :
    1795                 :     public IPC::Message
    1796               0 : {
    1797                 : private:
    1798                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1799                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1800                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1801                 :     typedef mozilla::hal::SensorData SensorData;
    1802                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1803                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1804                 :     typedef mozilla::ipc::Shmem Shmem;
    1805                 :     typedef mozilla::hal::FlashMode FlashMode;
    1806                 :     typedef mozilla::hal::LightType LightType;
    1807                 :     typedef mozilla::hal::LightMode LightMode;
    1808                 :     typedef mozilla::hal::SensorType SensorType;
    1809                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1810                 : 
    1811                 : public:
    1812                 :     enum {
    1813                 :         ID = Msg_GetWakeLockInfo__ID
    1814                 :     };
    1815               0 :     Msg_GetWakeLockInfo() :
    1816               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_GetWakeLockInfo")
    1817                 :     {
    1818               0 :     }
    1819                 : 
    1820                 :     void
    1821               0 :     Log(
    1822                 :             const std::string& __pfx,
    1823                 :             FILE* __outf) const
    1824                 :     {
    1825               0 :         std::string __logmsg;
    1826               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1827               0 :         (__logmsg).append(__pfx);
    1828               0 :         (__logmsg).append("Msg_GetWakeLockInfo(");
    1829                 : 
    1830               0 :         (__logmsg).append("[TODO])\n");
    1831               0 :         fputs((__logmsg).c_str(), __outf);
    1832               0 :     }
    1833                 : };
    1834                 : 
    1835                 : class Reply_GetWakeLockInfo :
    1836                 :     public IPC::Message
    1837               0 : {
    1838                 : private:
    1839                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1840                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1841                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1842                 :     typedef mozilla::hal::SensorData SensorData;
    1843                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1844                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1845                 :     typedef mozilla::ipc::Shmem Shmem;
    1846                 :     typedef mozilla::hal::FlashMode FlashMode;
    1847                 :     typedef mozilla::hal::LightType LightType;
    1848                 :     typedef mozilla::hal::LightMode LightMode;
    1849                 :     typedef mozilla::hal::SensorType SensorType;
    1850                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1851                 : 
    1852                 : public:
    1853                 :     enum {
    1854                 :         ID = Reply_GetWakeLockInfo__ID
    1855                 :     };
    1856               0 :     Reply_GetWakeLockInfo() :
    1857               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply_GetWakeLockInfo")
    1858                 :     {
    1859               0 :     }
    1860                 : 
    1861                 :     void
    1862               0 :     Log(
    1863                 :             const std::string& __pfx,
    1864                 :             FILE* __outf) const
    1865                 :     {
    1866               0 :         std::string __logmsg;
    1867               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1868               0 :         (__logmsg).append(__pfx);
    1869               0 :         (__logmsg).append("Reply_GetWakeLockInfo(");
    1870                 : 
    1871               0 :         (__logmsg).append("[TODO])\n");
    1872               0 :         fputs((__logmsg).c_str(), __outf);
    1873               0 :     }
    1874                 : };
    1875                 : 
    1876                 : class Msg_NotifySensorChange :
    1877                 :     public IPC::Message
    1878               0 : {
    1879                 : private:
    1880                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1881                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1882                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1883                 :     typedef mozilla::hal::SensorData SensorData;
    1884                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1885                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1886                 :     typedef mozilla::ipc::Shmem Shmem;
    1887                 :     typedef mozilla::hal::FlashMode FlashMode;
    1888                 :     typedef mozilla::hal::LightType LightType;
    1889                 :     typedef mozilla::hal::LightMode LightMode;
    1890                 :     typedef mozilla::hal::SensorType SensorType;
    1891                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1892                 : 
    1893                 : public:
    1894                 :     enum {
    1895                 :         ID = Msg_NotifySensorChange__ID
    1896                 :     };
    1897               0 :     Msg_NotifySensorChange() :
    1898               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_NotifySensorChange")
    1899                 :     {
    1900               0 :     }
    1901                 : 
    1902                 :     void
    1903               0 :     Log(
    1904                 :             const std::string& __pfx,
    1905                 :             FILE* __outf) const
    1906                 :     {
    1907               0 :         std::string __logmsg;
    1908               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1909               0 :         (__logmsg).append(__pfx);
    1910               0 :         (__logmsg).append("Msg_NotifySensorChange(");
    1911                 : 
    1912               0 :         (__logmsg).append("[TODO])\n");
    1913               0 :         fputs((__logmsg).c_str(), __outf);
    1914               0 :     }
    1915                 : };
    1916                 : 
    1917                 : class Msg_EnableSensorNotifications :
    1918                 :     public IPC::Message
    1919               0 : {
    1920                 : private:
    1921                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1922                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1923                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1924                 :     typedef mozilla::hal::SensorData SensorData;
    1925                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1926                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1927                 :     typedef mozilla::ipc::Shmem Shmem;
    1928                 :     typedef mozilla::hal::FlashMode FlashMode;
    1929                 :     typedef mozilla::hal::LightType LightType;
    1930                 :     typedef mozilla::hal::LightMode LightMode;
    1931                 :     typedef mozilla::hal::SensorType SensorType;
    1932                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1933                 : 
    1934                 : public:
    1935                 :     enum {
    1936                 :         ID = Msg_EnableSensorNotifications__ID
    1937                 :     };
    1938               0 :     Msg_EnableSensorNotifications() :
    1939               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_EnableSensorNotifications")
    1940                 :     {
    1941               0 :     }
    1942                 : 
    1943                 :     void
    1944               0 :     Log(
    1945                 :             const std::string& __pfx,
    1946                 :             FILE* __outf) const
    1947                 :     {
    1948               0 :         std::string __logmsg;
    1949               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1950               0 :         (__logmsg).append(__pfx);
    1951               0 :         (__logmsg).append("Msg_EnableSensorNotifications(");
    1952                 : 
    1953               0 :         (__logmsg).append("[TODO])\n");
    1954               0 :         fputs((__logmsg).c_str(), __outf);
    1955               0 :     }
    1956                 : };
    1957                 : 
    1958                 : class Msg_DisableSensorNotifications :
    1959                 :     public IPC::Message
    1960               0 : {
    1961                 : private:
    1962                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1963                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    1964                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    1965                 :     typedef mozilla::hal::SensorData SensorData;
    1966                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    1967                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    1968                 :     typedef mozilla::ipc::Shmem Shmem;
    1969                 :     typedef mozilla::hal::FlashMode FlashMode;
    1970                 :     typedef mozilla::hal::LightType LightType;
    1971                 :     typedef mozilla::hal::LightMode LightMode;
    1972                 :     typedef mozilla::hal::SensorType SensorType;
    1973                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    1974                 : 
    1975                 : public:
    1976                 :     enum {
    1977                 :         ID = Msg_DisableSensorNotifications__ID
    1978                 :     };
    1979               0 :     Msg_DisableSensorNotifications() :
    1980               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg_DisableSensorNotifications")
    1981                 :     {
    1982               0 :     }
    1983                 : 
    1984                 :     void
    1985               0 :     Log(
    1986                 :             const std::string& __pfx,
    1987                 :             FILE* __outf) const
    1988                 :     {
    1989               0 :         std::string __logmsg;
    1990               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1991               0 :         (__logmsg).append(__pfx);
    1992               0 :         (__logmsg).append("Msg_DisableSensorNotifications(");
    1993                 : 
    1994               0 :         (__logmsg).append("[TODO])\n");
    1995               0 :         fputs((__logmsg).c_str(), __outf);
    1996               0 :     }
    1997                 : };
    1998                 : 
    1999                 : class Msg___delete__ :
    2000                 :     public IPC::Message
    2001               0 : {
    2002                 : private:
    2003                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    2004                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    2005                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    2006                 :     typedef mozilla::hal::SensorData SensorData;
    2007                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    2008                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    2009                 :     typedef mozilla::ipc::Shmem Shmem;
    2010                 :     typedef mozilla::hal::FlashMode FlashMode;
    2011                 :     typedef mozilla::hal::LightType LightType;
    2012                 :     typedef mozilla::hal::LightMode LightMode;
    2013                 :     typedef mozilla::hal::SensorType SensorType;
    2014                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    2015                 : 
    2016                 : public:
    2017                 :     enum {
    2018                 :         ID = Msg___delete____ID
    2019                 :     };
    2020               0 :     Msg___delete__() :
    2021               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Msg___delete__")
    2022                 :     {
    2023               0 :     }
    2024                 : 
    2025                 :     void
    2026               0 :     Log(
    2027                 :             const std::string& __pfx,
    2028                 :             FILE* __outf) const
    2029                 :     {
    2030               0 :         std::string __logmsg;
    2031               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    2032               0 :         (__logmsg).append(__pfx);
    2033               0 :         (__logmsg).append("Msg___delete__(");
    2034                 : 
    2035               0 :         (__logmsg).append("[TODO])\n");
    2036               0 :         fputs((__logmsg).c_str(), __outf);
    2037               0 :     }
    2038                 : };
    2039                 : 
    2040                 : class Reply___delete__ :
    2041                 :     public IPC::Message
    2042                 : {
    2043                 : private:
    2044                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    2045                 :     typedef mozilla::hal::BatteryInformation BatteryInformation;
    2046                 :     typedef mozilla::hal::LightConfiguration LightConfiguration;
    2047                 :     typedef mozilla::hal::SensorData SensorData;
    2048                 :     typedef mozilla::hal::NetworkInformation NetworkInformation;
    2049                 :     typedef mozilla::hal::WakeLockInformation WakeLockInformation;
    2050                 :     typedef mozilla::ipc::Shmem Shmem;
    2051                 :     typedef mozilla::hal::FlashMode FlashMode;
    2052                 :     typedef mozilla::hal::LightType LightType;
    2053                 :     typedef mozilla::hal::LightMode LightMode;
    2054                 :     typedef mozilla::hal::SensorType SensorType;
    2055                 :     typedef mozilla::hal::WakeLockControl WakeLockControl;
    2056                 : 
    2057                 : public:
    2058                 :     enum {
    2059                 :         ID = Reply___delete____ID
    2060                 :     };
    2061                 :     Reply___delete__() :
    2062                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHal::Reply___delete__")
    2063                 :     {
    2064                 :     }
    2065                 : 
    2066                 :     void
    2067                 :     Log(
    2068                 :             const std::string& __pfx,
    2069                 :             FILE* __outf) const
    2070                 :     {
    2071                 :         std::string __logmsg;
    2072                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    2073                 :         (__logmsg).append(__pfx);
    2074                 :         (__logmsg).append("Reply___delete__(");
    2075                 : 
    2076                 :         (__logmsg).append("[TODO])\n");
    2077                 :         fputs((__logmsg).c_str(), __outf);
    2078                 :     }
    2079                 : };
    2080                 : 
    2081                 : 
    2082                 : 
    2083                 : } // namespace PHal
    2084                 : } // namespace hal_sandbox
    2085                 : } // namespace mozilla
    2086                 : 
    2087                 : #endif // ifndef PHal_h

Generated by: LCOV version 1.7