LCOV - app.info - objdir/dist/include/nsIMemoryReporter.h

LCOV - code coverage report
| Current view: | directory - objdir/dist/include - nsIMemoryReporter.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 4 | 4 | 100.0 %
| Date: | 2012-07-07 | Functions: | 4 | 4 | 100.0 %

           1                 : /*
           2                 :  * DO NOT EDIT.  THIS FILE IS GENERATED FROM /builds/slave/m-rel-lnx-codecoverage/build/xpcom/base/nsIMemoryReporter.idl
           3                 :  */
           4                 :
           5                 : #ifndef __gen_nsIMemoryReporter_h__
           6                 : #define __gen_nsIMemoryReporter_h__
           7                 :
           8                 :
           9                 : #ifndef __gen_nsISupports_h__
          10                 : #include "nsISupports.h"
          11                 : #endif
          12                 :
          13                 : /* For IDL files that don't want to include root IDL files. */
          14                 : #ifndef NS_NO_VTABLE
          15                 : #define NS_NO_VTABLE
          16                 : #endif
          17                 : class nsISimpleEnumerator; /* forward declaration */
          18                 :
          19                 :
          20                 : /* starting interface:    nsIMemoryReporter */
          21                 : #define NS_IMEMORYREPORTER_IID_STR "b2c39f65-1799-4b92-a806-ab3cf6af3cfa"
          22                 :
          23                 : #define NS_IMEMORYREPORTER_IID \
          24                 :   {0xb2c39f65, 0x1799, 0x4b92, \
          25                 :     { 0xa8, 0x06, 0xab, 0x3c, 0xf6, 0xaf, 0x3c, 0xfa }}
          26                 :
          27           25146 : class NS_NO_VTABLE NS_SCRIPTABLE nsIMemoryReporter : public nsISupports {
          28                 :  public:
          29                 :
          30                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMEMORYREPORTER_IID)
          31                 :
          32                 :   /* readonly attribute ACString process; */
          33                 :   NS_SCRIPTABLE NS_IMETHOD GetProcess(nsACString & aProcess) = 0;
          34                 :
          35                 :   /* readonly attribute AUTF8String path; */
          36                 :   NS_SCRIPTABLE NS_IMETHOD GetPath(nsACString & aPath) = 0;
          37                 :
          38                 :   enum {
          39                 :     KIND_NONHEAP = 0,
          40                 :     KIND_HEAP = 1,
          41                 :     KIND_OTHER = 2,
          42                 :     KIND_MAPPED = 0
          43                 :   };
          44                 :
          45                 :   /* readonly attribute PRInt32 kind; */
          46                 :   NS_SCRIPTABLE NS_IMETHOD GetKind(PRInt32 *aKind) = 0;
          47                 :
          48                 :   enum {
          49                 :     UNITS_BYTES = 0,
          50                 :     UNITS_COUNT = 1,
          51                 :     UNITS_COUNT_CUMULATIVE = 2,
          52                 :     UNITS_PERCENTAGE = 3
          53                 :   };
          54                 :
          55                 :   /* readonly attribute PRInt32 units; */
          56                 :   NS_SCRIPTABLE NS_IMETHOD GetUnits(PRInt32 *aUnits) = 0;
          57                 :
          58                 :   /* readonly attribute PRInt64 amount; */
          59                 :   NS_SCRIPTABLE NS_IMETHOD GetAmount(PRInt64 *aAmount) = 0;
          60                 :
          61                 :   /* readonly attribute AUTF8String description; */
          62                 :   NS_SCRIPTABLE NS_IMETHOD GetDescription(nsACString & aDescription) = 0;
          63                 :
          64                 : };
          65                 :
          66                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIMemoryReporter, NS_IMEMORYREPORTER_IID)
          67                 :
          68                 : /* Use this macro when declaring classes that implement this interface. */
          69                 : #define NS_DECL_NSIMEMORYREPORTER \
          70                 :   NS_SCRIPTABLE NS_IMETHOD GetProcess(nsACString & aProcess); \
          71                 :   NS_SCRIPTABLE NS_IMETHOD GetPath(nsACString & aPath); \
          72                 :   NS_SCRIPTABLE NS_IMETHOD GetKind(PRInt32 *aKind); \
          73                 :   NS_SCRIPTABLE NS_IMETHOD GetUnits(PRInt32 *aUnits); \
          74                 :   NS_SCRIPTABLE NS_IMETHOD GetAmount(PRInt64 *aAmount); \
          75                 :   NS_SCRIPTABLE NS_IMETHOD GetDescription(nsACString & aDescription);
          76                 :
          77                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
          78                 : #define NS_FORWARD_NSIMEMORYREPORTER(_to) \
          79                 :   NS_SCRIPTABLE NS_IMETHOD GetProcess(nsACString & aProcess) { return _to GetProcess(aProcess); } \
          80                 :   NS_SCRIPTABLE NS_IMETHOD GetPath(nsACString & aPath) { return _to GetPath(aPath); } \
          81                 :   NS_SCRIPTABLE NS_IMETHOD GetKind(PRInt32 *aKind) { return _to GetKind(aKind); } \
          82                 :   NS_SCRIPTABLE NS_IMETHOD GetUnits(PRInt32 *aUnits) { return _to GetUnits(aUnits); } \
          83                 :   NS_SCRIPTABLE NS_IMETHOD GetAmount(PRInt64 *aAmount) { return _to GetAmount(aAmount); } \
          84                 :   NS_SCRIPTABLE NS_IMETHOD GetDescription(nsACString & aDescription) { return _to GetDescription(aDescription); }
          85                 :
          86                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
          87                 : #define NS_FORWARD_SAFE_NSIMEMORYREPORTER(_to) \
          88                 :   NS_SCRIPTABLE NS_IMETHOD GetProcess(nsACString & aProcess) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetProcess(aProcess); } \
          89                 :   NS_SCRIPTABLE NS_IMETHOD GetPath(nsACString & aPath) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPath(aPath); } \
          90                 :   NS_SCRIPTABLE NS_IMETHOD GetKind(PRInt32 *aKind) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetKind(aKind); } \
          91                 :   NS_SCRIPTABLE NS_IMETHOD GetUnits(PRInt32 *aUnits) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUnits(aUnits); } \
          92                 :   NS_SCRIPTABLE NS_IMETHOD GetAmount(PRInt64 *aAmount) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAmount(aAmount); } \
          93                 :   NS_SCRIPTABLE NS_IMETHOD GetDescription(nsACString & aDescription) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDescription(aDescription); }
          94                 :
          95                 : #if 0
          96                 : /* Use the code below as a template for the implementation class for this interface. */
          97                 :
          98                 : /* Header file */
          99                 : class nsMemoryReporter : public nsIMemoryReporter
         100                 : {
         101                 : public:
         102                 :   NS_DECL_ISUPPORTS
         103                 :   NS_DECL_NSIMEMORYREPORTER
         104                 :
         105                 :   nsMemoryReporter();
         106                 :
         107                 : private:
         108                 :   ~nsMemoryReporter();
         109                 :
         110                 : protected:
         111                 :   /* additional members */
         112                 : };
         113                 :
         114                 : /* Implementation file */
         115                 : NS_IMPL_ISUPPORTS1(nsMemoryReporter, nsIMemoryReporter)
         116                 :
         117                 : nsMemoryReporter::nsMemoryReporter()
         118                 : {
         119                 :   /* member initializers and constructor code */
         120                 : }
         121                 :
         122                 : nsMemoryReporter::~nsMemoryReporter()
         123                 : {
         124                 :   /* destructor code */
         125                 : }
         126                 :
         127                 : /* readonly attribute ACString process; */
         128                 : NS_IMETHODIMP nsMemoryReporter::GetProcess(nsACString & aProcess)
         129                 : {
         130                 :     return NS_ERROR_NOT_IMPLEMENTED;
         131                 : }
         132                 :
         133                 : /* readonly attribute AUTF8String path; */
         134                 : NS_IMETHODIMP nsMemoryReporter::GetPath(nsACString & aPath)
         135                 : {
         136                 :     return NS_ERROR_NOT_IMPLEMENTED;
         137                 : }
         138                 :
         139                 : /* readonly attribute PRInt32 kind; */
         140                 : NS_IMETHODIMP nsMemoryReporter::GetKind(PRInt32 *aKind)
         141                 : {
         142                 :     return NS_ERROR_NOT_IMPLEMENTED;
         143                 : }
         144                 :
         145                 : /* readonly attribute PRInt32 units; */
         146                 : NS_IMETHODIMP nsMemoryReporter::GetUnits(PRInt32 *aUnits)
         147                 : {
         148                 :     return NS_ERROR_NOT_IMPLEMENTED;
         149                 : }
         150                 :
         151                 : /* readonly attribute PRInt64 amount; */
         152                 : NS_IMETHODIMP nsMemoryReporter::GetAmount(PRInt64 *aAmount)
         153                 : {
         154                 :     return NS_ERROR_NOT_IMPLEMENTED;
         155                 : }
         156                 :
         157                 : /* readonly attribute AUTF8String description; */
         158                 : NS_IMETHODIMP nsMemoryReporter::GetDescription(nsACString & aDescription)
         159                 : {
         160                 :     return NS_ERROR_NOT_IMPLEMENTED;
         161                 : }
         162                 :
         163                 : /* End of implementation class template. */
         164                 : #endif
         165                 :
         166                 :
         167                 : /* starting interface:    nsIMemoryMultiReporterCallback */
         168                 : #define NS_IMEMORYMULTIREPORTERCALLBACK_IID_STR "5b15f3fa-ba15-443c-8337-7770f5f0ce5d"
         169                 :
         170                 : #define NS_IMEMORYMULTIREPORTERCALLBACK_IID \
         171                 :   {0x5b15f3fa, 0xba15, 0x443c, \
         172                 :     { 0x83, 0x37, 0x77, 0x70, 0xf5, 0xf0, 0xce, 0x5d }}
         173                 :
         174               3 : class NS_NO_VTABLE NS_SCRIPTABLE nsIMemoryMultiReporterCallback : public nsISupports {
         175                 :  public:
         176                 :
         177                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMEMORYMULTIREPORTERCALLBACK_IID)
         178                 :
         179                 :   /* void callback (in ACString process, in AUTF8String path, in PRInt32 kind, in PRInt32 units, in PRInt64 amount, in AUTF8String description, in nsISupports closure); */
         180                 :   NS_SCRIPTABLE NS_IMETHOD Callback(const nsACString & process, const nsACString & path, PRInt32 kind, PRInt32 units, PRInt64 amount, const nsACString & description, nsISupports *closure) = 0;
         181                 :
         182                 : };
         183                 :
         184                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIMemoryMultiReporterCallback, NS_IMEMORYMULTIREPORTERCALLBACK_IID)
         185                 :
         186                 : /* Use this macro when declaring classes that implement this interface. */
         187                 : #define NS_DECL_NSIMEMORYMULTIREPORTERCALLBACK \
         188                 :   NS_SCRIPTABLE NS_IMETHOD Callback(const nsACString & process, const nsACString & path, PRInt32 kind, PRInt32 units, PRInt64 amount, const nsACString & description, nsISupports *closure);
         189                 :
         190                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
         191                 : #define NS_FORWARD_NSIMEMORYMULTIREPORTERCALLBACK(_to) \
         192                 :   NS_SCRIPTABLE NS_IMETHOD Callback(const nsACString & process, const nsACString & path, PRInt32 kind, PRInt32 units, PRInt64 amount, const nsACString & description, nsISupports *closure) { return _to Callback(process, path, kind, units, amount, description, closure); }
         193                 :
         194                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
         195                 : #define NS_FORWARD_SAFE_NSIMEMORYMULTIREPORTERCALLBACK(_to) \
         196                 :   NS_SCRIPTABLE NS_IMETHOD Callback(const nsACString & process, const nsACString & path, PRInt32 kind, PRInt32 units, PRInt64 amount, const nsACString & description, nsISupports *closure) { return !_to ? NS_ERROR_NULL_POINTER : _to->Callback(process, path, kind, units, amount, description, closure); }
         197                 :
         198                 : #if 0
         199                 : /* Use the code below as a template for the implementation class for this interface. */
         200                 :
         201                 : /* Header file */
         202                 : class nsMemoryMultiReporterCallback : public nsIMemoryMultiReporterCallback
         203                 : {
         204                 : public:
         205                 :   NS_DECL_ISUPPORTS
         206                 :   NS_DECL_NSIMEMORYMULTIREPORTERCALLBACK
         207                 :
         208                 :   nsMemoryMultiReporterCallback();
         209                 :
         210                 : private:
         211                 :   ~nsMemoryMultiReporterCallback();
         212                 :
         213                 : protected:
         214                 :   /* additional members */
         215                 : };
         216                 :
         217                 : /* Implementation file */
         218                 : NS_IMPL_ISUPPORTS1(nsMemoryMultiReporterCallback, nsIMemoryMultiReporterCallback)
         219                 :
         220                 : nsMemoryMultiReporterCallback::nsMemoryMultiReporterCallback()
         221                 : {
         222                 :   /* member initializers and constructor code */
         223                 : }
         224                 :
         225                 : nsMemoryMultiReporterCallback::~nsMemoryMultiReporterCallback()
         226                 : {
         227                 :   /* destructor code */
         228                 : }
         229                 :
         230                 : /* void callback (in ACString process, in AUTF8String path, in PRInt32 kind, in PRInt32 units, in PRInt64 amount, in AUTF8String description, in nsISupports closure); */
         231                 : NS_IMETHODIMP nsMemoryMultiReporterCallback::Callback(const nsACString & process, const nsACString & path, PRInt32 kind, PRInt32 units, PRInt64 amount, const nsACString & description, nsISupports *closure)
         232                 : {
         233                 :     return NS_ERROR_NOT_IMPLEMENTED;
         234                 : }
         235                 :
         236                 : /* End of implementation class template. */
         237                 : #endif
         238                 :
         239                 :
         240                 : /* starting interface:    nsIMemoryMultiReporter */
         241                 : #define NS_IMEMORYMULTIREPORTER_IID_STR "61d498d5-b460-4398-a8ea-7f75208534b4"
         242                 :
         243                 : #define NS_IMEMORYMULTIREPORTER_IID \
         244                 :   {0x61d498d5, 0xb460, 0x4398, \
         245                 :     { 0xa8, 0xea, 0x7f, 0x75, 0x20, 0x85, 0x34, 0xb4 }}
         246                 :
         247            6527 : class NS_NO_VTABLE NS_SCRIPTABLE nsIMemoryMultiReporter : public nsISupports {
         248                 :  public:
         249                 :
         250                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMEMORYMULTIREPORTER_IID)
         251                 :
         252                 :   /* readonly attribute ACString name; */
         253                 :   NS_SCRIPTABLE NS_IMETHOD GetName(nsACString & aName) = 0;
         254                 :
         255                 :   /* void collectReports (in nsIMemoryMultiReporterCallback callback, in nsISupports closure); */
         256                 :   NS_SCRIPTABLE NS_IMETHOD CollectReports(nsIMemoryMultiReporterCallback *callback, nsISupports *closure) = 0;
         257                 :
         258                 :   /* readonly attribute PRInt64 explicitNonHeap; */
         259                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicitNonHeap(PRInt64 *aExplicitNonHeap) = 0;
         260                 :
         261                 : };
         262                 :
         263                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIMemoryMultiReporter, NS_IMEMORYMULTIREPORTER_IID)
         264                 :
         265                 : /* Use this macro when declaring classes that implement this interface. */
         266                 : #define NS_DECL_NSIMEMORYMULTIREPORTER \
         267                 :   NS_SCRIPTABLE NS_IMETHOD GetName(nsACString & aName); \
         268                 :   NS_SCRIPTABLE NS_IMETHOD CollectReports(nsIMemoryMultiReporterCallback *callback, nsISupports *closure); \
         269                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicitNonHeap(PRInt64 *aExplicitNonHeap);
         270                 :
         271                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
         272                 : #define NS_FORWARD_NSIMEMORYMULTIREPORTER(_to) \
         273                 :   NS_SCRIPTABLE NS_IMETHOD GetName(nsACString & aName) { return _to GetName(aName); } \
         274                 :   NS_SCRIPTABLE NS_IMETHOD CollectReports(nsIMemoryMultiReporterCallback *callback, nsISupports *closure) { return _to CollectReports(callback, closure); } \
         275                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicitNonHeap(PRInt64 *aExplicitNonHeap) { return _to GetExplicitNonHeap(aExplicitNonHeap); }
         276                 :
         277                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
         278                 : #define NS_FORWARD_SAFE_NSIMEMORYMULTIREPORTER(_to) \
         279                 :   NS_SCRIPTABLE NS_IMETHOD GetName(nsACString & aName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetName(aName); } \
         280                 :   NS_SCRIPTABLE NS_IMETHOD CollectReports(nsIMemoryMultiReporterCallback *callback, nsISupports *closure) { return !_to ? NS_ERROR_NULL_POINTER : _to->CollectReports(callback, closure); } \
         281                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicitNonHeap(PRInt64 *aExplicitNonHeap) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetExplicitNonHeap(aExplicitNonHeap); }
         282                 :
         283                 : #if 0
         284                 : /* Use the code below as a template for the implementation class for this interface. */
         285                 :
         286                 : /* Header file */
         287                 : class nsMemoryMultiReporter : public nsIMemoryMultiReporter
         288                 : {
         289                 : public:
         290                 :   NS_DECL_ISUPPORTS
         291                 :   NS_DECL_NSIMEMORYMULTIREPORTER
         292                 :
         293                 :   nsMemoryMultiReporter();
         294                 :
         295                 : private:
         296                 :   ~nsMemoryMultiReporter();
         297                 :
         298                 : protected:
         299                 :   /* additional members */
         300                 : };
         301                 :
         302                 : /* Implementation file */
         303                 : NS_IMPL_ISUPPORTS1(nsMemoryMultiReporter, nsIMemoryMultiReporter)
         304                 :
         305                 : nsMemoryMultiReporter::nsMemoryMultiReporter()
         306                 : {
         307                 :   /* member initializers and constructor code */
         308                 : }
         309                 :
         310                 : nsMemoryMultiReporter::~nsMemoryMultiReporter()
         311                 : {
         312                 :   /* destructor code */
         313                 : }
         314                 :
         315                 : /* readonly attribute ACString name; */
         316                 : NS_IMETHODIMP nsMemoryMultiReporter::GetName(nsACString & aName)
         317                 : {
         318                 :     return NS_ERROR_NOT_IMPLEMENTED;
         319                 : }
         320                 :
         321                 : /* void collectReports (in nsIMemoryMultiReporterCallback callback, in nsISupports closure); */
         322                 : NS_IMETHODIMP nsMemoryMultiReporter::CollectReports(nsIMemoryMultiReporterCallback *callback, nsISupports *closure)
         323                 : {
         324                 :     return NS_ERROR_NOT_IMPLEMENTED;
         325                 : }
         326                 :
         327                 : /* readonly attribute PRInt64 explicitNonHeap; */
         328                 : NS_IMETHODIMP nsMemoryMultiReporter::GetExplicitNonHeap(PRInt64 *aExplicitNonHeap)
         329                 : {
         330                 :     return NS_ERROR_NOT_IMPLEMENTED;
         331                 : }
         332                 :
         333                 : /* End of implementation class template. */
         334                 : #endif
         335                 :
         336                 :
         337                 : /* starting interface:    nsIMemoryReporterManager */
         338                 : #define NS_IMEMORYREPORTERMANAGER_IID_STR "4527b1d8-a81f-4af3-9623-80e4120392c7"
         339                 :
         340                 : #define NS_IMEMORYREPORTERMANAGER_IID \
         341                 :   {0x4527b1d8, 0xa81f, 0x4af3, \
         342                 :     { 0x96, 0x23, 0x80, 0xe4, 0x12, 0x03, 0x92, 0xc7 }}
         343                 :
         344            1419 : class NS_NO_VTABLE NS_SCRIPTABLE nsIMemoryReporterManager : public nsISupports {
         345                 :  public:
         346                 :
         347                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMEMORYREPORTERMANAGER_IID)
         348                 :
         349                 :   /* nsISimpleEnumerator enumerateReporters (); */
         350                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM) = 0;
         351                 :
         352                 :   /* nsISimpleEnumerator enumerateMultiReporters (); */
         353                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateMultiReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM) = 0;
         354                 :
         355                 :   /* void registerReporter (in nsIMemoryReporter reporter); */
         356                 :   NS_SCRIPTABLE NS_IMETHOD RegisterReporter(nsIMemoryReporter *reporter) = 0;
         357                 :
         358                 :   /* void registerMultiReporter (in nsIMemoryMultiReporter reporter); */
         359                 :   NS_SCRIPTABLE NS_IMETHOD RegisterMultiReporter(nsIMemoryMultiReporter *reporter) = 0;
         360                 :
         361                 :   /* void unregisterReporter (in nsIMemoryReporter reporter); */
         362                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterReporter(nsIMemoryReporter *reporter) = 0;
         363                 :
         364                 :   /* void unregisterMultiReporter (in nsIMemoryMultiReporter reporter); */
         365                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterMultiReporter(nsIMemoryMultiReporter *reporter) = 0;
         366                 :
         367                 :   /* void init (); */
         368                 :   NS_SCRIPTABLE NS_IMETHOD Init(void) = 0;
         369                 :
         370                 :   /* readonly attribute PRInt64 resident; */
         371                 :   NS_SCRIPTABLE NS_IMETHOD GetResident(PRInt64 *aResident) = 0;
         372                 :
         373                 :   /* readonly attribute PRInt64 explicit; */
         374                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicit(PRInt64 *aExplicit) = 0;
         375                 :
         376                 :   /* readonly attribute boolean hasMozMallocUsableSize; */
         377                 :   NS_SCRIPTABLE NS_IMETHOD GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize) = 0;
         378                 :
         379                 : };
         380                 :
         381                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIMemoryReporterManager, NS_IMEMORYREPORTERMANAGER_IID)
         382                 :
         383                 : /* Use this macro when declaring classes that implement this interface. */
         384                 : #define NS_DECL_NSIMEMORYREPORTERMANAGER \
         385                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM); \
         386                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateMultiReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM); \
         387                 :   NS_SCRIPTABLE NS_IMETHOD RegisterReporter(nsIMemoryReporter *reporter); \
         388                 :   NS_SCRIPTABLE NS_IMETHOD RegisterMultiReporter(nsIMemoryMultiReporter *reporter); \
         389                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterReporter(nsIMemoryReporter *reporter); \
         390                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterMultiReporter(nsIMemoryMultiReporter *reporter); \
         391                 :   NS_SCRIPTABLE NS_IMETHOD Init(void); \
         392                 :   NS_SCRIPTABLE NS_IMETHOD GetResident(PRInt64 *aResident); \
         393                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicit(PRInt64 *aExplicit); \
         394                 :   NS_SCRIPTABLE NS_IMETHOD GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize);
         395                 :
         396                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
         397                 : #define NS_FORWARD_NSIMEMORYREPORTERMANAGER(_to) \
         398                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM) { return _to EnumerateReporters(_retval); } \
         399                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateMultiReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM) { return _to EnumerateMultiReporters(_retval); } \
         400                 :   NS_SCRIPTABLE NS_IMETHOD RegisterReporter(nsIMemoryReporter *reporter) { return _to RegisterReporter(reporter); } \
         401                 :   NS_SCRIPTABLE NS_IMETHOD RegisterMultiReporter(nsIMemoryMultiReporter *reporter) { return _to RegisterMultiReporter(reporter); } \
         402                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterReporter(nsIMemoryReporter *reporter) { return _to UnregisterReporter(reporter); } \
         403                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterMultiReporter(nsIMemoryMultiReporter *reporter) { return _to UnregisterMultiReporter(reporter); } \
         404                 :   NS_SCRIPTABLE NS_IMETHOD Init(void) { return _to Init(); } \
         405                 :   NS_SCRIPTABLE NS_IMETHOD GetResident(PRInt64 *aResident) { return _to GetResident(aResident); } \
         406                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicit(PRInt64 *aExplicit) { return _to GetExplicit(aExplicit); } \
         407                 :   NS_SCRIPTABLE NS_IMETHOD GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize) { return _to GetHasMozMallocUsableSize(aHasMozMallocUsableSize); }
         408                 :
         409                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
         410                 : #define NS_FORWARD_SAFE_NSIMEMORYREPORTERMANAGER(_to) \
         411                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->EnumerateReporters(_retval); } \
         412                 :   NS_SCRIPTABLE NS_IMETHOD EnumerateMultiReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->EnumerateMultiReporters(_retval); } \
         413                 :   NS_SCRIPTABLE NS_IMETHOD RegisterReporter(nsIMemoryReporter *reporter) { return !_to ? NS_ERROR_NULL_POINTER : _to->RegisterReporter(reporter); } \
         414                 :   NS_SCRIPTABLE NS_IMETHOD RegisterMultiReporter(nsIMemoryMultiReporter *reporter) { return !_to ? NS_ERROR_NULL_POINTER : _to->RegisterMultiReporter(reporter); } \
         415                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterReporter(nsIMemoryReporter *reporter) { return !_to ? NS_ERROR_NULL_POINTER : _to->UnregisterReporter(reporter); } \
         416                 :   NS_SCRIPTABLE NS_IMETHOD UnregisterMultiReporter(nsIMemoryMultiReporter *reporter) { return !_to ? NS_ERROR_NULL_POINTER : _to->UnregisterMultiReporter(reporter); } \
         417                 :   NS_SCRIPTABLE NS_IMETHOD Init(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(); } \
         418                 :   NS_SCRIPTABLE NS_IMETHOD GetResident(PRInt64 *aResident) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetResident(aResident); } \
         419                 :   NS_SCRIPTABLE NS_IMETHOD GetExplicit(PRInt64 *aExplicit) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetExplicit(aExplicit); } \
         420                 :   NS_SCRIPTABLE NS_IMETHOD GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetHasMozMallocUsableSize(aHasMozMallocUsableSize); }
         421                 :
         422                 : #if 0
         423                 : /* Use the code below as a template for the implementation class for this interface. */
         424                 :
         425                 : /* Header file */
         426                 : class nsMemoryReporterManager : public nsIMemoryReporterManager
         427                 : {
         428                 : public:
         429                 :   NS_DECL_ISUPPORTS
         430                 :   NS_DECL_NSIMEMORYREPORTERMANAGER
         431                 :
         432                 :   nsMemoryReporterManager();
         433                 :
         434                 : private:
         435                 :   ~nsMemoryReporterManager();
         436                 :
         437                 : protected:
         438                 :   /* additional members */
         439                 : };
         440                 :
         441                 : /* Implementation file */
         442                 : NS_IMPL_ISUPPORTS1(nsMemoryReporterManager, nsIMemoryReporterManager)
         443                 :
         444                 : nsMemoryReporterManager::nsMemoryReporterManager()
         445                 : {
         446                 :   /* member initializers and constructor code */
         447                 : }
         448                 :
         449                 : nsMemoryReporterManager::~nsMemoryReporterManager()
         450                 : {
         451                 :   /* destructor code */
         452                 : }
         453                 :
         454                 : /* nsISimpleEnumerator enumerateReporters (); */
         455                 : NS_IMETHODIMP nsMemoryReporterManager::EnumerateReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM)
         456                 : {
         457                 :     return NS_ERROR_NOT_IMPLEMENTED;
         458                 : }
         459                 :
         460                 : /* nsISimpleEnumerator enumerateMultiReporters (); */
         461                 : NS_IMETHODIMP nsMemoryReporterManager::EnumerateMultiReporters(nsISimpleEnumerator * *_retval NS_OUTPARAM)
         462                 : {
         463                 :     return NS_ERROR_NOT_IMPLEMENTED;
         464                 : }
         465                 :
         466                 : /* void registerReporter (in nsIMemoryReporter reporter); */
         467                 : NS_IMETHODIMP nsMemoryReporterManager::RegisterReporter(nsIMemoryReporter *reporter)
         468                 : {
         469                 :     return NS_ERROR_NOT_IMPLEMENTED;
         470                 : }
         471                 :
         472                 : /* void registerMultiReporter (in nsIMemoryMultiReporter reporter); */
         473                 : NS_IMETHODIMP nsMemoryReporterManager::RegisterMultiReporter(nsIMemoryMultiReporter *reporter)
         474                 : {
         475                 :     return NS_ERROR_NOT_IMPLEMENTED;
         476                 : }
         477                 :
         478                 : /* void unregisterReporter (in nsIMemoryReporter reporter); */
         479                 : NS_IMETHODIMP nsMemoryReporterManager::UnregisterReporter(nsIMemoryReporter *reporter)
         480                 : {
         481                 :     return NS_ERROR_NOT_IMPLEMENTED;
         482                 : }
         483                 :
         484                 : /* void unregisterMultiReporter (in nsIMemoryMultiReporter reporter); */
         485                 : NS_IMETHODIMP nsMemoryReporterManager::UnregisterMultiReporter(nsIMemoryMultiReporter *reporter)
         486                 : {
         487                 :     return NS_ERROR_NOT_IMPLEMENTED;
         488                 : }
         489                 :
         490                 : /* void init (); */
         491                 : NS_IMETHODIMP nsMemoryReporterManager::Init()
         492                 : {
         493                 :     return NS_ERROR_NOT_IMPLEMENTED;
         494                 : }
         495                 :
         496                 : /* readonly attribute PRInt64 resident; */
         497                 : NS_IMETHODIMP nsMemoryReporterManager::GetResident(PRInt64 *aResident)
         498                 : {
         499                 :     return NS_ERROR_NOT_IMPLEMENTED;
         500                 : }
         501                 :
         502                 : /* readonly attribute PRInt64 explicit; */
         503                 : NS_IMETHODIMP nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit)
         504                 : {
         505                 :     return NS_ERROR_NOT_IMPLEMENTED;
         506                 : }
         507                 :
         508                 : /* readonly attribute boolean hasMozMallocUsableSize; */
         509                 : NS_IMETHODIMP nsMemoryReporterManager::GetHasMozMallocUsableSize(bool *aHasMozMallocUsableSize)
         510                 : {
         511                 :     return NS_ERROR_NOT_IMPLEMENTED;
         512                 : }
         513                 :
         514                 : /* End of implementation class template. */
         515                 : #endif
         516                 :
         517                 :
         518                 : /*
         519                 :  * Note that this defaults 'process' to "", which is usually what's desired.
         520                 :  */
         521                 : #define NS_MEMORY_REPORTER_IMPLEMENT_HELPER(_classname, _path, _kind, _units, _amountFunction, _desc, _ts) \
         522                 :     class MemoryReporter_##_classname MOZ_FINAL : public nsIMemoryReporter {                  \
         523                 :     public:                                                                                   \
         524                 :       NS_DECL_ISUPPORTS                                                                       \
         525                 :       NS_IMETHOD GetProcess(nsACString &process) { process.Truncate(); return NS_OK; } \
         526                 :       NS_IMETHOD GetPath(nsACString &memoryPath) { memoryPath.Assign(_path); return NS_OK; } \
         527                 :       NS_IMETHOD GetKind(int *kind) { *kind = _kind; return NS_OK; }                          \
         528                 :       NS_IMETHOD GetUnits(int *units) { *units = _units; return NS_OK; }                      \
         529                 :       NS_IMETHOD GetAmount(PRInt64 *amount) { *amount = _amountFunction(); return NS_OK; }     \
         530                 :       NS_IMETHOD GetDescription(nsACString &desc) { desc.Assign(_desc); return NS_OK; } \
         531                 :     };                                                                                        \
         532                 :     NS_IMPL##_ts##ISUPPORTS1(MemoryReporter_##_classname, nsIMemoryReporter)
         533                 : #define NS_MEMORY_REPORTER_IMPLEMENT(_c, _p, _k, _u, _a, _d) \
         534                 :         NS_MEMORY_REPORTER_IMPLEMENT_HELPER(_c, _p, _k, _u, _a, _d, _)
         535                 : #define NS_THREADSAFE_MEMORY_REPORTER_IMPLEMENT(_c, _p, _k, _u, _a, _d) \
         536                 :         NS_MEMORY_REPORTER_IMPLEMENT_HELPER(_c, _p, _k, _u, _a, _d, _THREADSAFE_)
         537                 : #define NS_MEMORY_REPORTER_NAME(_classname)  MemoryReporter_##_classname
         538                 : nsresult NS_RegisterMemoryReporter(nsIMemoryReporter *reporter);
         539                 : nsresult NS_RegisterMemoryMultiReporter(nsIMemoryMultiReporter *reporter);
         540                 : nsresult NS_UnregisterMemoryReporter(nsIMemoryReporter *reporter);
         541                 : nsresult NS_UnregisterMemoryMultiReporter(nsIMemoryMultiReporter *reporter);
         542                 : // Because DMD is not a tool that comes with the standard Valgrind
         543                 : // distribution, we have to #include our own local copy of dmd.h.  Ugly but
         544                 : // unavoidable.
         545                 : #ifdef MOZ_DMD
         546                 : #if MOZ_MEMORY
         547                 : #error "--disable-jemalloc should have been forced when --enable-dmd was specified"
         548                 : #endif
         549                 : #include "dmd.h"
         550                 : #endif
         551                 : namespace mozilla {
         552                 : /*
         553                 :  * Functions generated via this macro should be used by all traversal-based
         554                 :  * memory reporters.  Such functions return |moz_malloc_size_of(ptr)|;  this
         555                 :  * will always be zero on some obscure platforms.
         556                 :  *
         557                 :  * You might be wondering why we have a macro that creates multiple functions
         558                 :  * distinguished only by |name|, instead of a single MemoryReporterMallocSizeOf
         559                 :  * function.  It's mostly to help with DMD integration, though it sometimes
         560                 :  * also helps with debugging and temporary ad hoc profiling.  The |name| chosen
         561                 :  * doesn't matter greatly, but it's best to make it similar to the path used by
         562                 :  * the relevant memory reporter(s).
         563                 :  */
         564                 : #define NS_MEMORY_REPORTER_MALLOC_SIZEOF_FUN(fn, name)                        \
         565                 :   static size_t fn(const void *ptr)                                           \
         566                 :   {                                                                           \
         567                 :       size_t usable = moz_malloc_size_of(ptr);                                \
         568                 :       VALGRIND_DMD_REPORT(ptr, usable, name);                                 \
         569                 :       return usable;                                                          \
         570                 :   }
         571                 : /*
         572                 :  * Like NS_MEMORY_REPORTER_MALLOC_SIZEOF_FUN, but the created function sends an
         573                 :  * "unreport" message to DMD.
         574                 :  */
         575                 : #define NS_MEMORY_REPORTER_MALLOC_SIZEOF_FUN_UN(fn)                           \
         576                 :   static size_t fn(const void *ptr)                                           \
         577                 :   {                                                                           \
         578                 :       size_t usable = moz_malloc_size_of(ptr);                                \
         579                 :       VALGRIND_DMD_UNREPORT(ptr);                                             \
         580                 :       return usable;                                                          \
         581                 :   }
         582                 : #ifdef MOZ_DMD
         583                 : /*
         584                 :  * This runs all the memory reporters but does nothing with the results;  i.e.
         585                 :  * it does the minimal amount of work possible for DMD to do its thing.  Then
         586                 :  * it dumps the DMD output to stderr (or somewhere else, if one of
         587                 :  * DMD/Valgrind's logging options was used).
         588                 :  */
         589                 : void DMDCheckAndDump();
         590                 : #else
         591                 : #define VALGRIND_DMD_REPORT(ptr, usable, name)
         592                 : #define VALGRIND_DMD_UNREPORT(ptr)
         593                 : #endif  /* defined(MOZ_DMD) */
         594                 : }
         595                 :
         596                 : #endif /* __gen_nsIMemoryReporter_h__ */

Generated by: LCOV version 1.7