LCOV - code coverage report
Current view: directory - objdir/dist/include - nsIFrameMessageManager.h (source / functions) Found Hit Coverage
Test: app.info Lines: 6 5 83.3 %
Date: 2012-06-02 Functions: 6 5 83.3 %

       1                 : /*
       2                 :  * DO NOT EDIT.  THIS FILE IS GENERATED FROM /builds/slave/m-beta-lnx-codecoverage/build/content/base/public/nsIFrameMessageManager.idl
       3                 :  */
       4                 : 
       5                 : #ifndef __gen_nsIFrameMessageManager_h__
       6                 : #define __gen_nsIFrameMessageManager_h__
       7                 : 
       8                 : 
       9                 : #ifndef __gen_nsISupports_h__
      10                 : #include "nsISupports.h"
      11                 : #endif
      12                 : 
      13                 : #include "jspubtd.h"
      14                 : 
      15                 : /* For IDL files that don't want to include root IDL files. */
      16                 : #ifndef NS_NO_VTABLE
      17                 : #define NS_NO_VTABLE
      18                 : #endif
      19                 : class nsIDOMWindow; /* forward declaration */
      20                 : 
      21                 : class nsIDocShell; /* forward declaration */
      22                 : 
      23                 : class nsIContent; /* forward declaration */
      24                 : 
      25                 : 
      26                 : /* starting interface:    nsIFrameMessageListener */
      27                 : #define NS_IFRAMEMESSAGELISTENER_IID_STR "938fcb95-3d63-46be-aa72-94d08fd3b418"
      28                 : 
      29                 : #define NS_IFRAMEMESSAGELISTENER_IID \
      30                 :   {0x938fcb95, 0x3d63, 0x46be, \
      31                 :     { 0xaa, 0x72, 0x94, 0xd0, 0x8f, 0xd3, 0xb4, 0x18 }}
      32                 : 
      33                 : class NS_NO_VTABLE NS_SCRIPTABLE nsIFrameMessageListener : public nsISupports {
      34                 :  public: 
      35                 : 
      36                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IFRAMEMESSAGELISTENER_IID)
      37                 : 
      38                 :   /* void receiveMessage (); */
      39                 :   NS_SCRIPTABLE NS_IMETHOD ReceiveMessage(void) = 0;
      40                 : 
      41                 : };
      42                 : 
      43                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIFrameMessageListener, NS_IFRAMEMESSAGELISTENER_IID)
      44                 : 
      45                 : /* Use this macro when declaring classes that implement this interface. */
      46                 : #define NS_DECL_NSIFRAMEMESSAGELISTENER \
      47                 :   NS_SCRIPTABLE NS_IMETHOD ReceiveMessage(void); 
      48                 : 
      49                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
      50                 : #define NS_FORWARD_NSIFRAMEMESSAGELISTENER(_to) \
      51                 :   NS_SCRIPTABLE NS_IMETHOD ReceiveMessage(void) { return _to ReceiveMessage(); } 
      52                 : 
      53                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
      54                 : #define NS_FORWARD_SAFE_NSIFRAMEMESSAGELISTENER(_to) \
      55                 :   NS_SCRIPTABLE NS_IMETHOD ReceiveMessage(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReceiveMessage(); } 
      56                 : 
      57                 : #if 0
      58                 : /* Use the code below as a template for the implementation class for this interface. */
      59                 : 
      60                 : /* Header file */
      61                 : class nsFrameMessageListener : public nsIFrameMessageListener
      62                 : {
      63                 : public:
      64                 :   NS_DECL_ISUPPORTS
      65                 :   NS_DECL_NSIFRAMEMESSAGELISTENER
      66                 : 
      67                 :   nsFrameMessageListener();
      68                 : 
      69                 : private:
      70                 :   ~nsFrameMessageListener();
      71                 : 
      72                 : protected:
      73                 :   /* additional members */
      74                 : };
      75                 : 
      76                 : /* Implementation file */
      77                 : NS_IMPL_ISUPPORTS1(nsFrameMessageListener, nsIFrameMessageListener)
      78                 : 
      79                 : nsFrameMessageListener::nsFrameMessageListener()
      80                 : {
      81                 :   /* member initializers and constructor code */
      82                 : }
      83                 : 
      84                 : nsFrameMessageListener::~nsFrameMessageListener()
      85                 : {
      86                 :   /* destructor code */
      87                 : }
      88                 : 
      89                 : /* void receiveMessage (); */
      90                 : NS_IMETHODIMP nsFrameMessageListener::ReceiveMessage()
      91                 : {
      92                 :     return NS_ERROR_NOT_IMPLEMENTED;
      93                 : }
      94                 : 
      95                 : /* End of implementation class template. */
      96                 : #endif
      97                 : 
      98                 : 
      99                 : /* starting interface:    nsIFrameMessageManager */
     100                 : #define NS_IFRAMEMESSAGEMANAGER_IID_STR "9be42627-a5db-456f-8de2-9097da45a8c3"
     101                 : 
     102                 : #define NS_IFRAMEMESSAGEMANAGER_IID \
     103                 :   {0x9be42627, 0xa5db, 0x456f, \
     104                 :     { 0x8d, 0xe2, 0x90, 0x97, 0xda, 0x45, 0xa8, 0xc3 }}
     105                 : 
     106             500 : class NS_NO_VTABLE NS_SCRIPTABLE nsIFrameMessageManager : public nsISupports {
     107                 :  public: 
     108                 : 
     109                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IFRAMEMESSAGEMANAGER_IID)
     110                 : 
     111                 :   /* void addMessageListener (in AString aMessage, in nsIFrameMessageListener aListener); */
     112                 :   NS_SCRIPTABLE NS_IMETHOD AddMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener) = 0;
     113                 : 
     114                 :   /* void removeMessageListener (in AString aMessage, in nsIFrameMessageListener aListener); */
     115                 :   NS_SCRIPTABLE NS_IMETHOD RemoveMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener) = 0;
     116                 : 
     117                 :   /* [implicit_jscontext,optional_argc] void sendAsyncMessage ([optional] in AString messageName, [optional] in jsval obj); */
     118                 :   NS_SCRIPTABLE NS_IMETHOD SendAsyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc) = 0;
     119                 : 
     120                 :   /* [notxpcom] boolean markForCC (); */
     121                 :   NS_IMETHOD_(bool) MarkForCC(void) = 0;
     122                 : 
     123                 : };
     124                 : 
     125                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIFrameMessageManager, NS_IFRAMEMESSAGEMANAGER_IID)
     126                 : 
     127                 : /* Use this macro when declaring classes that implement this interface. */
     128                 : #define NS_DECL_NSIFRAMEMESSAGEMANAGER \
     129                 :   NS_SCRIPTABLE NS_IMETHOD AddMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener); \
     130                 :   NS_SCRIPTABLE NS_IMETHOD RemoveMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener); \
     131                 :   NS_SCRIPTABLE NS_IMETHOD SendAsyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc); \
     132                 :   NS_IMETHOD_(bool) MarkForCC(void); 
     133                 : 
     134                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     135                 : #define NS_FORWARD_NSIFRAMEMESSAGEMANAGER(_to) \
     136                 :   NS_SCRIPTABLE NS_IMETHOD AddMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener) { return _to AddMessageListener(aMessage, aListener); } \
     137                 :   NS_SCRIPTABLE NS_IMETHOD RemoveMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener) { return _to RemoveMessageListener(aMessage, aListener); } \
     138                 :   NS_SCRIPTABLE NS_IMETHOD SendAsyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc) { return _to SendAsyncMessage(messageName, obj, cx, _argc); } \
     139                 :   NS_IMETHOD_(bool) MarkForCC(void) { return _to MarkForCC(); } 
     140                 : 
     141                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     142                 : #define NS_FORWARD_SAFE_NSIFRAMEMESSAGEMANAGER(_to) \
     143                 :   NS_SCRIPTABLE NS_IMETHOD AddMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->AddMessageListener(aMessage, aListener); } \
     144                 :   NS_SCRIPTABLE NS_IMETHOD RemoveMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveMessageListener(aMessage, aListener); } \
     145                 :   NS_SCRIPTABLE NS_IMETHOD SendAsyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc) { return !_to ? NS_ERROR_NULL_POINTER : _to->SendAsyncMessage(messageName, obj, cx, _argc); } \
     146                 :   NS_IMETHOD_(bool) MarkForCC(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->MarkForCC(); } 
     147                 : 
     148                 : #if 0
     149                 : /* Use the code below as a template for the implementation class for this interface. */
     150                 : 
     151                 : /* Header file */
     152                 : class nsFrameMessageManager : public nsIFrameMessageManager
     153                 : {
     154                 : public:
     155                 :   NS_DECL_ISUPPORTS
     156                 :   NS_DECL_NSIFRAMEMESSAGEMANAGER
     157                 : 
     158                 :   nsFrameMessageManager();
     159                 : 
     160                 : private:
     161                 :   ~nsFrameMessageManager();
     162                 : 
     163                 : protected:
     164                 :   /* additional members */
     165                 : };
     166                 : 
     167                 : /* Implementation file */
     168                 : NS_IMPL_ISUPPORTS1(nsFrameMessageManager, nsIFrameMessageManager)
     169                 : 
     170                 : nsFrameMessageManager::nsFrameMessageManager()
     171                 : {
     172                 :   /* member initializers and constructor code */
     173                 : }
     174                 : 
     175                 : nsFrameMessageManager::~nsFrameMessageManager()
     176                 : {
     177                 :   /* destructor code */
     178                 : }
     179                 : 
     180                 : /* void addMessageListener (in AString aMessage, in nsIFrameMessageListener aListener); */
     181                 : NS_IMETHODIMP nsFrameMessageManager::AddMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener)
     182                 : {
     183                 :     return NS_ERROR_NOT_IMPLEMENTED;
     184                 : }
     185                 : 
     186                 : /* void removeMessageListener (in AString aMessage, in nsIFrameMessageListener aListener); */
     187                 : NS_IMETHODIMP nsFrameMessageManager::RemoveMessageListener(const nsAString & aMessage, nsIFrameMessageListener *aListener)
     188                 : {
     189                 :     return NS_ERROR_NOT_IMPLEMENTED;
     190                 : }
     191                 : 
     192                 : /* [implicit_jscontext,optional_argc] void sendAsyncMessage ([optional] in AString messageName, [optional] in jsval obj); */
     193                 : NS_IMETHODIMP nsFrameMessageManager::SendAsyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc)
     194                 : {
     195                 :     return NS_ERROR_NOT_IMPLEMENTED;
     196                 : }
     197                 : 
     198                 : /* [notxpcom] boolean markForCC (); */
     199                 : NS_IMETHODIMP_(bool) nsFrameMessageManager::MarkForCC()
     200                 : {
     201                 :     return NS_ERROR_NOT_IMPLEMENTED;
     202                 : }
     203                 : 
     204                 : /* End of implementation class template. */
     205                 : #endif
     206                 : 
     207                 : 
     208                 : /* starting interface:    nsISyncMessageSender */
     209                 : #define NS_ISYNCMESSAGESENDER_IID_STR "28a36ac7-2868-4fa0-ae24-be957d7dce10"
     210                 : 
     211                 : #define NS_ISYNCMESSAGESENDER_IID \
     212                 :   {0x28a36ac7, 0x2868, 0x4fa0, \
     213                 :     { 0xae, 0x24, 0xbe, 0x95, 0x7d, 0x7d, 0xce, 0x10 }}
     214                 : 
     215             250 : class NS_NO_VTABLE NS_SCRIPTABLE nsISyncMessageSender : public nsIFrameMessageManager {
     216                 :  public: 
     217                 : 
     218                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ISYNCMESSAGESENDER_IID)
     219                 : 
     220                 :   /* [implicit_jscontext,optional_argc] jsval sendSyncMessage ([optional] in AString messageName, [optional] in jsval obj); */
     221                 :   NS_SCRIPTABLE NS_IMETHOD SendSyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc, JS::Value *_retval NS_OUTPARAM) = 0;
     222                 : 
     223                 : };
     224                 : 
     225                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsISyncMessageSender, NS_ISYNCMESSAGESENDER_IID)
     226                 : 
     227                 : /* Use this macro when declaring classes that implement this interface. */
     228                 : #define NS_DECL_NSISYNCMESSAGESENDER \
     229                 :   NS_SCRIPTABLE NS_IMETHOD SendSyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc, JS::Value *_retval NS_OUTPARAM); 
     230                 : 
     231                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     232                 : #define NS_FORWARD_NSISYNCMESSAGESENDER(_to) \
     233                 :   NS_SCRIPTABLE NS_IMETHOD SendSyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc, JS::Value *_retval NS_OUTPARAM) { return _to SendSyncMessage(messageName, obj, cx, _argc, _retval); } 
     234                 : 
     235                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     236                 : #define NS_FORWARD_SAFE_NSISYNCMESSAGESENDER(_to) \
     237                 :   NS_SCRIPTABLE NS_IMETHOD SendSyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc, JS::Value *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->SendSyncMessage(messageName, obj, cx, _argc, _retval); } 
     238                 : 
     239                 : #if 0
     240                 : /* Use the code below as a template for the implementation class for this interface. */
     241                 : 
     242                 : /* Header file */
     243                 : class nsSyncMessageSender : public nsISyncMessageSender
     244                 : {
     245                 : public:
     246                 :   NS_DECL_ISUPPORTS
     247                 :   NS_DECL_NSISYNCMESSAGESENDER
     248                 : 
     249                 :   nsSyncMessageSender();
     250                 : 
     251                 : private:
     252                 :   ~nsSyncMessageSender();
     253                 : 
     254                 : protected:
     255                 :   /* additional members */
     256                 : };
     257                 : 
     258                 : /* Implementation file */
     259                 : NS_IMPL_ISUPPORTS1(nsSyncMessageSender, nsISyncMessageSender)
     260                 : 
     261                 : nsSyncMessageSender::nsSyncMessageSender()
     262                 : {
     263                 :   /* member initializers and constructor code */
     264                 : }
     265                 : 
     266                 : nsSyncMessageSender::~nsSyncMessageSender()
     267                 : {
     268                 :   /* destructor code */
     269                 : }
     270                 : 
     271                 : /* [implicit_jscontext,optional_argc] jsval sendSyncMessage ([optional] in AString messageName, [optional] in jsval obj); */
     272                 : NS_IMETHODIMP nsSyncMessageSender::SendSyncMessage(const nsAString & messageName, const JS::Value & obj, JSContext* cx, PRUint8 _argc, JS::Value *_retval NS_OUTPARAM)
     273                 : {
     274                 :     return NS_ERROR_NOT_IMPLEMENTED;
     275                 : }
     276                 : 
     277                 : /* End of implementation class template. */
     278                 : #endif
     279                 : 
     280                 : 
     281                 : /* starting interface:    nsIContentFrameMessageManager */
     282                 : #define NS_ICONTENTFRAMEMESSAGEMANAGER_IID_STR "a83f4393-e3cf-44da-8867-1f9174c2c595"
     283                 : 
     284                 : #define NS_ICONTENTFRAMEMESSAGEMANAGER_IID \
     285                 :   {0xa83f4393, 0xe3cf, 0x44da, \
     286                 :     { 0x88, 0x67, 0x1f, 0x91, 0x74, 0xc2, 0xc5, 0x95 }}
     287                 : 
     288             250 : class NS_NO_VTABLE NS_SCRIPTABLE nsIContentFrameMessageManager : public nsISyncMessageSender {
     289                 :  public: 
     290                 : 
     291                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICONTENTFRAMEMESSAGEMANAGER_IID)
     292                 : 
     293                 :   /* readonly attribute nsIDOMWindow content; */
     294                 :   NS_SCRIPTABLE NS_IMETHOD GetContent(nsIDOMWindow * *aContent) = 0;
     295                 : 
     296                 :   /* readonly attribute nsIDocShell docShell; */
     297                 :   NS_SCRIPTABLE NS_IMETHOD GetDocShell(nsIDocShell * *aDocShell) = 0;
     298                 : 
     299                 :   /* void dump (in DOMString aStr); */
     300                 :   NS_SCRIPTABLE NS_IMETHOD Dump(const nsAString & aStr) = 0;
     301                 : 
     302                 :   /* void privateNoteIntentionalCrash (); */
     303                 :   NS_SCRIPTABLE NS_IMETHOD PrivateNoteIntentionalCrash(void) = 0;
     304                 : 
     305                 :   /* DOMString atob (in DOMString aAsciiString); */
     306                 :   NS_SCRIPTABLE NS_IMETHOD Atob(const nsAString & aAsciiString, nsAString & _retval NS_OUTPARAM) = 0;
     307                 : 
     308                 :   /* DOMString btoa (in DOMString aBase64Data); */
     309                 :   NS_SCRIPTABLE NS_IMETHOD Btoa(const nsAString & aBase64Data, nsAString & _retval NS_OUTPARAM) = 0;
     310                 : 
     311                 : };
     312                 : 
     313                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIContentFrameMessageManager, NS_ICONTENTFRAMEMESSAGEMANAGER_IID)
     314                 : 
     315                 : /* Use this macro when declaring classes that implement this interface. */
     316                 : #define NS_DECL_NSICONTENTFRAMEMESSAGEMANAGER \
     317                 :   NS_SCRIPTABLE NS_IMETHOD GetContent(nsIDOMWindow * *aContent); \
     318                 :   NS_SCRIPTABLE NS_IMETHOD GetDocShell(nsIDocShell * *aDocShell); \
     319                 :   NS_SCRIPTABLE NS_IMETHOD Dump(const nsAString & aStr); \
     320                 :   NS_SCRIPTABLE NS_IMETHOD PrivateNoteIntentionalCrash(void); \
     321                 :   NS_SCRIPTABLE NS_IMETHOD Atob(const nsAString & aAsciiString, nsAString & _retval NS_OUTPARAM); \
     322                 :   NS_SCRIPTABLE NS_IMETHOD Btoa(const nsAString & aBase64Data, nsAString & _retval NS_OUTPARAM); 
     323                 : 
     324                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     325                 : #define NS_FORWARD_NSICONTENTFRAMEMESSAGEMANAGER(_to) \
     326                 :   NS_SCRIPTABLE NS_IMETHOD GetContent(nsIDOMWindow * *aContent) { return _to GetContent(aContent); } \
     327                 :   NS_SCRIPTABLE NS_IMETHOD GetDocShell(nsIDocShell * *aDocShell) { return _to GetDocShell(aDocShell); } \
     328                 :   NS_SCRIPTABLE NS_IMETHOD Dump(const nsAString & aStr) { return _to Dump(aStr); } \
     329                 :   NS_SCRIPTABLE NS_IMETHOD PrivateNoteIntentionalCrash(void) { return _to PrivateNoteIntentionalCrash(); } \
     330                 :   NS_SCRIPTABLE NS_IMETHOD Atob(const nsAString & aAsciiString, nsAString & _retval NS_OUTPARAM) { return _to Atob(aAsciiString, _retval); } \
     331                 :   NS_SCRIPTABLE NS_IMETHOD Btoa(const nsAString & aBase64Data, nsAString & _retval NS_OUTPARAM) { return _to Btoa(aBase64Data, _retval); } 
     332                 : 
     333                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     334                 : #define NS_FORWARD_SAFE_NSICONTENTFRAMEMESSAGEMANAGER(_to) \
     335                 :   NS_SCRIPTABLE NS_IMETHOD GetContent(nsIDOMWindow * *aContent) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetContent(aContent); } \
     336                 :   NS_SCRIPTABLE NS_IMETHOD GetDocShell(nsIDocShell * *aDocShell) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDocShell(aDocShell); } \
     337                 :   NS_SCRIPTABLE NS_IMETHOD Dump(const nsAString & aStr) { return !_to ? NS_ERROR_NULL_POINTER : _to->Dump(aStr); } \
     338                 :   NS_SCRIPTABLE NS_IMETHOD PrivateNoteIntentionalCrash(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->PrivateNoteIntentionalCrash(); } \
     339                 :   NS_SCRIPTABLE NS_IMETHOD Atob(const nsAString & aAsciiString, nsAString & _retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->Atob(aAsciiString, _retval); } \
     340                 :   NS_SCRIPTABLE NS_IMETHOD Btoa(const nsAString & aBase64Data, nsAString & _retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->Btoa(aBase64Data, _retval); } 
     341                 : 
     342                 : #if 0
     343                 : /* Use the code below as a template for the implementation class for this interface. */
     344                 : 
     345                 : /* Header file */
     346                 : class nsContentFrameMessageManager : public nsIContentFrameMessageManager
     347                 : {
     348                 : public:
     349                 :   NS_DECL_ISUPPORTS
     350                 :   NS_DECL_NSICONTENTFRAMEMESSAGEMANAGER
     351                 : 
     352                 :   nsContentFrameMessageManager();
     353                 : 
     354                 : private:
     355                 :   ~nsContentFrameMessageManager();
     356                 : 
     357                 : protected:
     358                 :   /* additional members */
     359                 : };
     360                 : 
     361                 : /* Implementation file */
     362                 : NS_IMPL_ISUPPORTS1(nsContentFrameMessageManager, nsIContentFrameMessageManager)
     363                 : 
     364                 : nsContentFrameMessageManager::nsContentFrameMessageManager()
     365                 : {
     366                 :   /* member initializers and constructor code */
     367                 : }
     368                 : 
     369                 : nsContentFrameMessageManager::~nsContentFrameMessageManager()
     370                 : {
     371                 :   /* destructor code */
     372                 : }
     373                 : 
     374                 : /* readonly attribute nsIDOMWindow content; */
     375                 : NS_IMETHODIMP nsContentFrameMessageManager::GetContent(nsIDOMWindow * *aContent)
     376                 : {
     377                 :     return NS_ERROR_NOT_IMPLEMENTED;
     378                 : }
     379                 : 
     380                 : /* readonly attribute nsIDocShell docShell; */
     381                 : NS_IMETHODIMP nsContentFrameMessageManager::GetDocShell(nsIDocShell * *aDocShell)
     382                 : {
     383                 :     return NS_ERROR_NOT_IMPLEMENTED;
     384                 : }
     385                 : 
     386                 : /* void dump (in DOMString aStr); */
     387                 : NS_IMETHODIMP nsContentFrameMessageManager::Dump(const nsAString & aStr)
     388                 : {
     389                 :     return NS_ERROR_NOT_IMPLEMENTED;
     390                 : }
     391                 : 
     392                 : /* void privateNoteIntentionalCrash (); */
     393                 : NS_IMETHODIMP nsContentFrameMessageManager::PrivateNoteIntentionalCrash()
     394                 : {
     395                 :     return NS_ERROR_NOT_IMPLEMENTED;
     396                 : }
     397                 : 
     398                 : /* DOMString atob (in DOMString aAsciiString); */
     399                 : NS_IMETHODIMP nsContentFrameMessageManager::Atob(const nsAString & aAsciiString, nsAString & _retval NS_OUTPARAM)
     400                 : {
     401                 :     return NS_ERROR_NOT_IMPLEMENTED;
     402                 : }
     403                 : 
     404                 : /* DOMString btoa (in DOMString aBase64Data); */
     405                 : NS_IMETHODIMP nsContentFrameMessageManager::Btoa(const nsAString & aBase64Data, nsAString & _retval NS_OUTPARAM)
     406                 : {
     407                 :     return NS_ERROR_NOT_IMPLEMENTED;
     408                 : }
     409                 : 
     410                 : /* End of implementation class template. */
     411                 : #endif
     412                 : 
     413                 : 
     414                 : /* starting interface:    nsIInProcessContentFrameMessageManager */
     415                 : #define NS_IINPROCESSCONTENTFRAMEMESSAGEMANAGER_IID_STR "f0936c56-e92c-4927-a85b-e289c3d4a01c"
     416                 : 
     417                 : #define NS_IINPROCESSCONTENTFRAMEMESSAGEMANAGER_IID \
     418                 :   {0xf0936c56, 0xe92c, 0x4927, \
     419                 :     { 0xa8, 0x5b, 0xe2, 0x89, 0xc3, 0xd4, 0xa0, 0x1c }}
     420                 : 
     421               0 : class NS_NO_VTABLE nsIInProcessContentFrameMessageManager : public nsIContentFrameMessageManager {
     422                 :  public: 
     423                 : 
     424                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IINPROCESSCONTENTFRAMEMESSAGEMANAGER_IID)
     425                 : 
     426                 :   /* [notxpcom] nsIContent getOwnerContent (); */
     427                 :   NS_IMETHOD_(nsIContent *) GetOwnerContent(void) = 0;
     428                 : 
     429                 : };
     430                 : 
     431                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIInProcessContentFrameMessageManager, NS_IINPROCESSCONTENTFRAMEMESSAGEMANAGER_IID)
     432                 : 
     433                 : /* Use this macro when declaring classes that implement this interface. */
     434                 : #define NS_DECL_NSIINPROCESSCONTENTFRAMEMESSAGEMANAGER \
     435                 :   NS_IMETHOD_(nsIContent *) GetOwnerContent(void); 
     436                 : 
     437                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     438                 : #define NS_FORWARD_NSIINPROCESSCONTENTFRAMEMESSAGEMANAGER(_to) \
     439                 :   NS_IMETHOD_(nsIContent *) GetOwnerContent(void) { return _to GetOwnerContent(); } 
     440                 : 
     441                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     442                 : #define NS_FORWARD_SAFE_NSIINPROCESSCONTENTFRAMEMESSAGEMANAGER(_to) \
     443                 :   NS_IMETHOD_(nsIContent *) GetOwnerContent(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOwnerContent(); } 
     444                 : 
     445                 : #if 0
     446                 : /* Use the code below as a template for the implementation class for this interface. */
     447                 : 
     448                 : /* Header file */
     449                 : class nsInProcessContentFrameMessageManager : public nsIInProcessContentFrameMessageManager
     450                 : {
     451                 : public:
     452                 :   NS_DECL_ISUPPORTS
     453                 :   NS_DECL_NSIINPROCESSCONTENTFRAMEMESSAGEMANAGER
     454                 : 
     455                 :   nsInProcessContentFrameMessageManager();
     456                 : 
     457                 : private:
     458                 :   ~nsInProcessContentFrameMessageManager();
     459                 : 
     460                 : protected:
     461                 :   /* additional members */
     462                 : };
     463                 : 
     464                 : /* Implementation file */
     465                 : NS_IMPL_ISUPPORTS1(nsInProcessContentFrameMessageManager, nsIInProcessContentFrameMessageManager)
     466                 : 
     467                 : nsInProcessContentFrameMessageManager::nsInProcessContentFrameMessageManager()
     468                 : {
     469                 :   /* member initializers and constructor code */
     470                 : }
     471                 : 
     472                 : nsInProcessContentFrameMessageManager::~nsInProcessContentFrameMessageManager()
     473                 : {
     474                 :   /* destructor code */
     475                 : }
     476                 : 
     477                 : /* [notxpcom] nsIContent getOwnerContent (); */
     478                 : NS_IMETHODIMP_(nsIContent *) nsInProcessContentFrameMessageManager::GetOwnerContent()
     479                 : {
     480                 :     return NS_ERROR_NOT_IMPLEMENTED;
     481                 : }
     482                 : 
     483                 : /* End of implementation class template. */
     484                 : #endif
     485                 : 
     486                 : 
     487                 : /* starting interface:    nsITreeItemFrameMessageManager */
     488                 : #define NS_ITREEITEMFRAMEMESSAGEMANAGER_IID_STR "09f79e8c-101b-432b-a494-02f9b5e111c0"
     489                 : 
     490                 : #define NS_ITREEITEMFRAMEMESSAGEMANAGER_IID \
     491                 :   {0x09f79e8c, 0x101b, 0x432b, \
     492                 :     { 0xa4, 0x94, 0x02, 0xf9, 0xb5, 0xe1, 0x11, 0xc0 }}
     493                 : 
     494             250 : class NS_NO_VTABLE NS_SCRIPTABLE nsITreeItemFrameMessageManager : public nsIFrameMessageManager {
     495                 :  public: 
     496                 : 
     497                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ITREEITEMFRAMEMESSAGEMANAGER_IID)
     498                 : 
     499                 :   /* readonly attribute unsigned long childCount; */
     500                 :   NS_SCRIPTABLE NS_IMETHOD GetChildCount(PRUint32 *aChildCount) = 0;
     501                 : 
     502                 :   /* nsITreeItemFrameMessageManager getChildAt (in unsigned long aIndex); */
     503                 :   NS_SCRIPTABLE NS_IMETHOD GetChildAt(PRUint32 aIndex, nsITreeItemFrameMessageManager * *_retval NS_OUTPARAM) = 0;
     504                 : 
     505                 : };
     506                 : 
     507                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsITreeItemFrameMessageManager, NS_ITREEITEMFRAMEMESSAGEMANAGER_IID)
     508                 : 
     509                 : /* Use this macro when declaring classes that implement this interface. */
     510                 : #define NS_DECL_NSITREEITEMFRAMEMESSAGEMANAGER \
     511                 :   NS_SCRIPTABLE NS_IMETHOD GetChildCount(PRUint32 *aChildCount); \
     512                 :   NS_SCRIPTABLE NS_IMETHOD GetChildAt(PRUint32 aIndex, nsITreeItemFrameMessageManager * *_retval NS_OUTPARAM); 
     513                 : 
     514                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     515                 : #define NS_FORWARD_NSITREEITEMFRAMEMESSAGEMANAGER(_to) \
     516                 :   NS_SCRIPTABLE NS_IMETHOD GetChildCount(PRUint32 *aChildCount) { return _to GetChildCount(aChildCount); } \
     517                 :   NS_SCRIPTABLE NS_IMETHOD GetChildAt(PRUint32 aIndex, nsITreeItemFrameMessageManager * *_retval NS_OUTPARAM) { return _to GetChildAt(aIndex, _retval); } 
     518                 : 
     519                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     520                 : #define NS_FORWARD_SAFE_NSITREEITEMFRAMEMESSAGEMANAGER(_to) \
     521                 :   NS_SCRIPTABLE NS_IMETHOD GetChildCount(PRUint32 *aChildCount) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetChildCount(aChildCount); } \
     522                 :   NS_SCRIPTABLE NS_IMETHOD GetChildAt(PRUint32 aIndex, nsITreeItemFrameMessageManager * *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetChildAt(aIndex, _retval); } 
     523                 : 
     524                 : #if 0
     525                 : /* Use the code below as a template for the implementation class for this interface. */
     526                 : 
     527                 : /* Header file */
     528                 : class nsTreeItemFrameMessageManager : public nsITreeItemFrameMessageManager
     529                 : {
     530                 : public:
     531                 :   NS_DECL_ISUPPORTS
     532                 :   NS_DECL_NSITREEITEMFRAMEMESSAGEMANAGER
     533                 : 
     534                 :   nsTreeItemFrameMessageManager();
     535                 : 
     536                 : private:
     537                 :   ~nsTreeItemFrameMessageManager();
     538                 : 
     539                 : protected:
     540                 :   /* additional members */
     541                 : };
     542                 : 
     543                 : /* Implementation file */
     544                 : NS_IMPL_ISUPPORTS1(nsTreeItemFrameMessageManager, nsITreeItemFrameMessageManager)
     545                 : 
     546                 : nsTreeItemFrameMessageManager::nsTreeItemFrameMessageManager()
     547                 : {
     548                 :   /* member initializers and constructor code */
     549                 : }
     550                 : 
     551                 : nsTreeItemFrameMessageManager::~nsTreeItemFrameMessageManager()
     552                 : {
     553                 :   /* destructor code */
     554                 : }
     555                 : 
     556                 : /* readonly attribute unsigned long childCount; */
     557                 : NS_IMETHODIMP nsTreeItemFrameMessageManager::GetChildCount(PRUint32 *aChildCount)
     558                 : {
     559                 :     return NS_ERROR_NOT_IMPLEMENTED;
     560                 : }
     561                 : 
     562                 : /* nsITreeItemFrameMessageManager getChildAt (in unsigned long aIndex); */
     563                 : NS_IMETHODIMP nsTreeItemFrameMessageManager::GetChildAt(PRUint32 aIndex, nsITreeItemFrameMessageManager * *_retval NS_OUTPARAM)
     564                 : {
     565                 :     return NS_ERROR_NOT_IMPLEMENTED;
     566                 : }
     567                 : 
     568                 : /* End of implementation class template. */
     569                 : #endif
     570                 : 
     571                 : 
     572                 : /* starting interface:    nsIChromeFrameMessageManager */
     573                 : #define NS_ICHROMEFRAMEMESSAGEMANAGER_IID_STR "a51597f0-d669-4260-83e6-1d426a8ac802"
     574                 : 
     575                 : #define NS_ICHROMEFRAMEMESSAGEMANAGER_IID \
     576                 :   {0xa51597f0, 0xd669, 0x4260, \
     577                 :     { 0x83, 0xe6, 0x1d, 0x42, 0x6a, 0x8a, 0xc8, 0x02 }}
     578                 : 
     579             250 : class NS_NO_VTABLE NS_SCRIPTABLE nsIChromeFrameMessageManager : public nsITreeItemFrameMessageManager {
     580                 :  public: 
     581                 : 
     582                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICHROMEFRAMEMESSAGEMANAGER_IID)
     583                 : 
     584                 :   /* void loadFrameScript (in AString aURL, in boolean aAllowDelayedLoad); */
     585                 :   NS_SCRIPTABLE NS_IMETHOD LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad) = 0;
     586                 : 
     587                 :   /* void removeDelayedFrameScript (in AString aURL); */
     588                 :   NS_SCRIPTABLE NS_IMETHOD RemoveDelayedFrameScript(const nsAString & aURL) = 0;
     589                 : 
     590                 : };
     591                 : 
     592                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIChromeFrameMessageManager, NS_ICHROMEFRAMEMESSAGEMANAGER_IID)
     593                 : 
     594                 : /* Use this macro when declaring classes that implement this interface. */
     595                 : #define NS_DECL_NSICHROMEFRAMEMESSAGEMANAGER \
     596                 :   NS_SCRIPTABLE NS_IMETHOD LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad); \
     597                 :   NS_SCRIPTABLE NS_IMETHOD RemoveDelayedFrameScript(const nsAString & aURL); 
     598                 : 
     599                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     600                 : #define NS_FORWARD_NSICHROMEFRAMEMESSAGEMANAGER(_to) \
     601                 :   NS_SCRIPTABLE NS_IMETHOD LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad) { return _to LoadFrameScript(aURL, aAllowDelayedLoad); } \
     602                 :   NS_SCRIPTABLE NS_IMETHOD RemoveDelayedFrameScript(const nsAString & aURL) { return _to RemoveDelayedFrameScript(aURL); } 
     603                 : 
     604                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     605                 : #define NS_FORWARD_SAFE_NSICHROMEFRAMEMESSAGEMANAGER(_to) \
     606                 :   NS_SCRIPTABLE NS_IMETHOD LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad) { return !_to ? NS_ERROR_NULL_POINTER : _to->LoadFrameScript(aURL, aAllowDelayedLoad); } \
     607                 :   NS_SCRIPTABLE NS_IMETHOD RemoveDelayedFrameScript(const nsAString & aURL) { return !_to ? NS_ERROR_NULL_POINTER : _to->RemoveDelayedFrameScript(aURL); } 
     608                 : 
     609                 : #if 0
     610                 : /* Use the code below as a template for the implementation class for this interface. */
     611                 : 
     612                 : /* Header file */
     613                 : class nsChromeFrameMessageManager : public nsIChromeFrameMessageManager
     614                 : {
     615                 : public:
     616                 :   NS_DECL_ISUPPORTS
     617                 :   NS_DECL_NSICHROMEFRAMEMESSAGEMANAGER
     618                 : 
     619                 :   nsChromeFrameMessageManager();
     620                 : 
     621                 : private:
     622                 :   ~nsChromeFrameMessageManager();
     623                 : 
     624                 : protected:
     625                 :   /* additional members */
     626                 : };
     627                 : 
     628                 : /* Implementation file */
     629                 : NS_IMPL_ISUPPORTS1(nsChromeFrameMessageManager, nsIChromeFrameMessageManager)
     630                 : 
     631                 : nsChromeFrameMessageManager::nsChromeFrameMessageManager()
     632                 : {
     633                 :   /* member initializers and constructor code */
     634                 : }
     635                 : 
     636                 : nsChromeFrameMessageManager::~nsChromeFrameMessageManager()
     637                 : {
     638                 :   /* destructor code */
     639                 : }
     640                 : 
     641                 : /* void loadFrameScript (in AString aURL, in boolean aAllowDelayedLoad); */
     642                 : NS_IMETHODIMP nsChromeFrameMessageManager::LoadFrameScript(const nsAString & aURL, bool aAllowDelayedLoad)
     643                 : {
     644                 :     return NS_ERROR_NOT_IMPLEMENTED;
     645                 : }
     646                 : 
     647                 : /* void removeDelayedFrameScript (in AString aURL); */
     648                 : NS_IMETHODIMP nsChromeFrameMessageManager::RemoveDelayedFrameScript(const nsAString & aURL)
     649                 : {
     650                 :     return NS_ERROR_NOT_IMPLEMENTED;
     651                 : }
     652                 : 
     653                 : /* End of implementation class template. */
     654                 : #endif
     655                 : 
     656                 : 
     657                 : #endif /* __gen_nsIFrameMessageManager_h__ */

Generated by: LCOV version 1.7