LCOV - code coverage report
Current view: directory - objdir/dist/include - nsIUrlClassifierDBService.h (source / functions) Found Hit Coverage
Test: app.info Lines: 5 5 100.0 %
Date: 2012-04-21 Functions: 5 5 100.0 %

       1                 : /*
       2                 :  * DO NOT EDIT.  THIS FILE IS GENERATED FROM /builds/slave/m-aurora-lnx-codecoverage/build/toolkit/components/url-classifier/nsIUrlClassifierDBService.idl
       3                 :  */
       4                 : 
       5                 : #ifndef __gen_nsIUrlClassifierDBService_h__
       6                 : #define __gen_nsIUrlClassifierDBService_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                 : #include "nsTArray.h"
      18                 : #include "Entries.h"
      19                 : #include "LookupCache.h"
      20                 : class nsIUrlClassifierHashCompleter; /* forward declaration */
      21                 : 
      22                 : 
      23                 : /* starting interface:    nsIUrlClassifierCallback */
      24                 : #define NS_IURLCLASSIFIERCALLBACK_IID_STR "4ca27b6b-a674-4b3d-ab30-d21e2da2dffb"
      25                 : 
      26                 : #define NS_IURLCLASSIFIERCALLBACK_IID \
      27                 :   {0x4ca27b6b, 0xa674, 0x4b3d, \
      28                 :     { 0xab, 0x30, 0xd2, 0x1e, 0x2d, 0xa2, 0xdf, 0xfb }}
      29                 : 
      30              48 : class NS_NO_VTABLE NS_SCRIPTABLE nsIUrlClassifierCallback : public nsISupports {
      31                 :  public: 
      32                 : 
      33                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IURLCLASSIFIERCALLBACK_IID)
      34                 : 
      35                 :   /* void handleEvent (in ACString value); */
      36                 :   NS_SCRIPTABLE NS_IMETHOD HandleEvent(const nsACString & value) = 0;
      37                 : 
      38                 : };
      39                 : 
      40                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIUrlClassifierCallback, NS_IURLCLASSIFIERCALLBACK_IID)
      41                 : 
      42                 : /* Use this macro when declaring classes that implement this interface. */
      43                 : #define NS_DECL_NSIURLCLASSIFIERCALLBACK \
      44                 :   NS_SCRIPTABLE NS_IMETHOD HandleEvent(const nsACString & value); 
      45                 : 
      46                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
      47                 : #define NS_FORWARD_NSIURLCLASSIFIERCALLBACK(_to) \
      48                 :   NS_SCRIPTABLE NS_IMETHOD HandleEvent(const nsACString & value) { return _to HandleEvent(value); } 
      49                 : 
      50                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
      51                 : #define NS_FORWARD_SAFE_NSIURLCLASSIFIERCALLBACK(_to) \
      52                 :   NS_SCRIPTABLE NS_IMETHOD HandleEvent(const nsACString & value) { return !_to ? NS_ERROR_NULL_POINTER : _to->HandleEvent(value); } 
      53                 : 
      54                 : #if 0
      55                 : /* Use the code below as a template for the implementation class for this interface. */
      56                 : 
      57                 : /* Header file */
      58                 : class nsUrlClassifierCallback : public nsIUrlClassifierCallback
      59                 : {
      60                 : public:
      61                 :   NS_DECL_ISUPPORTS
      62                 :   NS_DECL_NSIURLCLASSIFIERCALLBACK
      63                 : 
      64                 :   nsUrlClassifierCallback();
      65                 : 
      66                 : private:
      67                 :   ~nsUrlClassifierCallback();
      68                 : 
      69                 : protected:
      70                 :   /* additional members */
      71                 : };
      72                 : 
      73                 : /* Implementation file */
      74                 : NS_IMPL_ISUPPORTS1(nsUrlClassifierCallback, nsIUrlClassifierCallback)
      75                 : 
      76                 : nsUrlClassifierCallback::nsUrlClassifierCallback()
      77                 : {
      78                 :   /* member initializers and constructor code */
      79                 : }
      80                 : 
      81                 : nsUrlClassifierCallback::~nsUrlClassifierCallback()
      82                 : {
      83                 :   /* destructor code */
      84                 : }
      85                 : 
      86                 : /* void handleEvent (in ACString value); */
      87                 : NS_IMETHODIMP nsUrlClassifierCallback::HandleEvent(const nsACString & value)
      88                 : {
      89                 :     return NS_ERROR_NOT_IMPLEMENTED;
      90                 : }
      91                 : 
      92                 : /* End of implementation class template. */
      93                 : #endif
      94                 : 
      95                 : 
      96                 : /* starting interface:    nsIUrlClassifierUpdateObserver */
      97                 : #define NS_IURLCLASSIFIERUPDATEOBSERVER_IID_STR "bbb33c65-e783-476c-8db0-6ddb91826c07"
      98                 : 
      99                 : #define NS_IURLCLASSIFIERUPDATEOBSERVER_IID \
     100                 :   {0xbbb33c65, 0xe783, 0x476c, \
     101                 :     { 0x8d, 0xb0, 0x6d, 0xdb, 0x91, 0x82, 0x6c, 0x07 }}
     102                 : 
     103              84 : class NS_NO_VTABLE NS_SCRIPTABLE nsIUrlClassifierUpdateObserver : public nsISupports {
     104                 :  public: 
     105                 : 
     106                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IURLCLASSIFIERUPDATEOBSERVER_IID)
     107                 : 
     108                 :   /* void updateUrlRequested (in ACString url, in ACString table, in ACString serverMAC); */
     109                 :   NS_SCRIPTABLE NS_IMETHOD UpdateUrlRequested(const nsACString & url, const nsACString & table, const nsACString & serverMAC) = 0;
     110                 : 
     111                 :   /* void rekeyRequested (); */
     112                 :   NS_SCRIPTABLE NS_IMETHOD RekeyRequested(void) = 0;
     113                 : 
     114                 :   /* void streamFinished (in nsresult status, in unsigned long delay); */
     115                 :   NS_SCRIPTABLE NS_IMETHOD StreamFinished(nsresult status, PRUint32 delay) = 0;
     116                 : 
     117                 :   /* void updateError (in nsresult error); */
     118                 :   NS_SCRIPTABLE NS_IMETHOD UpdateError(nsresult error) = 0;
     119                 : 
     120                 :   /* void updateSuccess (in unsigned long requestedTimeout); */
     121                 :   NS_SCRIPTABLE NS_IMETHOD UpdateSuccess(PRUint32 requestedTimeout) = 0;
     122                 : 
     123                 : };
     124                 : 
     125                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIUrlClassifierUpdateObserver, NS_IURLCLASSIFIERUPDATEOBSERVER_IID)
     126                 : 
     127                 : /* Use this macro when declaring classes that implement this interface. */
     128                 : #define NS_DECL_NSIURLCLASSIFIERUPDATEOBSERVER \
     129                 :   NS_SCRIPTABLE NS_IMETHOD UpdateUrlRequested(const nsACString & url, const nsACString & table, const nsACString & serverMAC); \
     130                 :   NS_SCRIPTABLE NS_IMETHOD RekeyRequested(void); \
     131                 :   NS_SCRIPTABLE NS_IMETHOD StreamFinished(nsresult status, PRUint32 delay); \
     132                 :   NS_SCRIPTABLE NS_IMETHOD UpdateError(nsresult error); \
     133                 :   NS_SCRIPTABLE NS_IMETHOD UpdateSuccess(PRUint32 requestedTimeout); 
     134                 : 
     135                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     136                 : #define NS_FORWARD_NSIURLCLASSIFIERUPDATEOBSERVER(_to) \
     137                 :   NS_SCRIPTABLE NS_IMETHOD UpdateUrlRequested(const nsACString & url, const nsACString & table, const nsACString & serverMAC) { return _to UpdateUrlRequested(url, table, serverMAC); } \
     138                 :   NS_SCRIPTABLE NS_IMETHOD RekeyRequested(void) { return _to RekeyRequested(); } \
     139                 :   NS_SCRIPTABLE NS_IMETHOD StreamFinished(nsresult status, PRUint32 delay) { return _to StreamFinished(status, delay); } \
     140                 :   NS_SCRIPTABLE NS_IMETHOD UpdateError(nsresult error) { return _to UpdateError(error); } \
     141                 :   NS_SCRIPTABLE NS_IMETHOD UpdateSuccess(PRUint32 requestedTimeout) { return _to UpdateSuccess(requestedTimeout); } 
     142                 : 
     143                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     144                 : #define NS_FORWARD_SAFE_NSIURLCLASSIFIERUPDATEOBSERVER(_to) \
     145                 :   NS_SCRIPTABLE NS_IMETHOD UpdateUrlRequested(const nsACString & url, const nsACString & table, const nsACString & serverMAC) { return !_to ? NS_ERROR_NULL_POINTER : _to->UpdateUrlRequested(url, table, serverMAC); } \
     146                 :   NS_SCRIPTABLE NS_IMETHOD RekeyRequested(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->RekeyRequested(); } \
     147                 :   NS_SCRIPTABLE NS_IMETHOD StreamFinished(nsresult status, PRUint32 delay) { return !_to ? NS_ERROR_NULL_POINTER : _to->StreamFinished(status, delay); } \
     148                 :   NS_SCRIPTABLE NS_IMETHOD UpdateError(nsresult error) { return !_to ? NS_ERROR_NULL_POINTER : _to->UpdateError(error); } \
     149                 :   NS_SCRIPTABLE NS_IMETHOD UpdateSuccess(PRUint32 requestedTimeout) { return !_to ? NS_ERROR_NULL_POINTER : _to->UpdateSuccess(requestedTimeout); } 
     150                 : 
     151                 : #if 0
     152                 : /* Use the code below as a template for the implementation class for this interface. */
     153                 : 
     154                 : /* Header file */
     155                 : class nsUrlClassifierUpdateObserver : public nsIUrlClassifierUpdateObserver
     156                 : {
     157                 : public:
     158                 :   NS_DECL_ISUPPORTS
     159                 :   NS_DECL_NSIURLCLASSIFIERUPDATEOBSERVER
     160                 : 
     161                 :   nsUrlClassifierUpdateObserver();
     162                 : 
     163                 : private:
     164                 :   ~nsUrlClassifierUpdateObserver();
     165                 : 
     166                 : protected:
     167                 :   /* additional members */
     168                 : };
     169                 : 
     170                 : /* Implementation file */
     171                 : NS_IMPL_ISUPPORTS1(nsUrlClassifierUpdateObserver, nsIUrlClassifierUpdateObserver)
     172                 : 
     173                 : nsUrlClassifierUpdateObserver::nsUrlClassifierUpdateObserver()
     174                 : {
     175                 :   /* member initializers and constructor code */
     176                 : }
     177                 : 
     178                 : nsUrlClassifierUpdateObserver::~nsUrlClassifierUpdateObserver()
     179                 : {
     180                 :   /* destructor code */
     181                 : }
     182                 : 
     183                 : /* void updateUrlRequested (in ACString url, in ACString table, in ACString serverMAC); */
     184                 : NS_IMETHODIMP nsUrlClassifierUpdateObserver::UpdateUrlRequested(const nsACString & url, const nsACString & table, const nsACString & serverMAC)
     185                 : {
     186                 :     return NS_ERROR_NOT_IMPLEMENTED;
     187                 : }
     188                 : 
     189                 : /* void rekeyRequested (); */
     190                 : NS_IMETHODIMP nsUrlClassifierUpdateObserver::RekeyRequested()
     191                 : {
     192                 :     return NS_ERROR_NOT_IMPLEMENTED;
     193                 : }
     194                 : 
     195                 : /* void streamFinished (in nsresult status, in unsigned long delay); */
     196                 : NS_IMETHODIMP nsUrlClassifierUpdateObserver::StreamFinished(nsresult status, PRUint32 delay)
     197                 : {
     198                 :     return NS_ERROR_NOT_IMPLEMENTED;
     199                 : }
     200                 : 
     201                 : /* void updateError (in nsresult error); */
     202                 : NS_IMETHODIMP nsUrlClassifierUpdateObserver::UpdateError(nsresult error)
     203                 : {
     204                 :     return NS_ERROR_NOT_IMPLEMENTED;
     205                 : }
     206                 : 
     207                 : /* void updateSuccess (in unsigned long requestedTimeout); */
     208                 : NS_IMETHODIMP nsUrlClassifierUpdateObserver::UpdateSuccess(PRUint32 requestedTimeout)
     209                 : {
     210                 :     return NS_ERROR_NOT_IMPLEMENTED;
     211                 : }
     212                 : 
     213                 : /* End of implementation class template. */
     214                 : #endif
     215                 : 
     216                 : 
     217                 : /* starting interface:    nsIUrlClassifierDBService */
     218                 : #define NS_IURLCLASSIFIERDBSERVICE_IID_STR "7aae3f3a-527d-488b-a448-45dca6db0e80"
     219                 : 
     220                 : #define NS_IURLCLASSIFIERDBSERVICE_IID \
     221                 :   {0x7aae3f3a, 0x527d, 0x488b, \
     222                 :     { 0xa4, 0x48, 0x45, 0xdc, 0xa6, 0xdb, 0x0e, 0x80 }}
     223                 : 
     224              21 : class NS_NO_VTABLE NS_SCRIPTABLE nsIUrlClassifierDBService : public nsISupports {
     225                 :  public: 
     226                 : 
     227                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IURLCLASSIFIERDBSERVICE_IID)
     228                 : 
     229                 :   /* void lookup (in ACString spec, in nsIUrlClassifierCallback c); */
     230                 :   NS_SCRIPTABLE NS_IMETHOD Lookup(const nsACString & spec, nsIUrlClassifierCallback *c) = 0;
     231                 : 
     232                 :   /* void getTables (in nsIUrlClassifierCallback c); */
     233                 :   NS_SCRIPTABLE NS_IMETHOD GetTables(nsIUrlClassifierCallback *c) = 0;
     234                 : 
     235                 :   /* void setHashCompleter (in ACString tableName, in nsIUrlClassifierHashCompleter completer); */
     236                 :   NS_SCRIPTABLE NS_IMETHOD SetHashCompleter(const nsACString & tableName, nsIUrlClassifierHashCompleter *completer) = 0;
     237                 : 
     238                 :   /* void beginUpdate (in nsIUrlClassifierUpdateObserver updater, in ACString tables, in ACString clientKey); */
     239                 :   NS_SCRIPTABLE NS_IMETHOD BeginUpdate(nsIUrlClassifierUpdateObserver *updater, const nsACString & tables, const nsACString & clientKey) = 0;
     240                 : 
     241                 :   /* void beginStream (in ACString table, in ACString serverMAC); */
     242                 :   NS_SCRIPTABLE NS_IMETHOD BeginStream(const nsACString & table, const nsACString & serverMAC) = 0;
     243                 : 
     244                 :   /* void updateStream (in ACString updateChunk); */
     245                 :   NS_SCRIPTABLE NS_IMETHOD UpdateStream(const nsACString & updateChunk) = 0;
     246                 : 
     247                 :   /* void finishStream (); */
     248                 :   NS_SCRIPTABLE NS_IMETHOD FinishStream(void) = 0;
     249                 : 
     250                 :   /* void finishUpdate (); */
     251                 :   NS_SCRIPTABLE NS_IMETHOD FinishUpdate(void) = 0;
     252                 : 
     253                 :   /* void cancelUpdate (); */
     254                 :   NS_SCRIPTABLE NS_IMETHOD CancelUpdate(void) = 0;
     255                 : 
     256                 :   /* void resetDatabase (); */
     257                 :   NS_SCRIPTABLE NS_IMETHOD ResetDatabase(void) = 0;
     258                 : 
     259                 : };
     260                 : 
     261                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIUrlClassifierDBService, NS_IURLCLASSIFIERDBSERVICE_IID)
     262                 : 
     263                 : /* Use this macro when declaring classes that implement this interface. */
     264                 : #define NS_DECL_NSIURLCLASSIFIERDBSERVICE \
     265                 :   NS_SCRIPTABLE NS_IMETHOD Lookup(const nsACString & spec, nsIUrlClassifierCallback *c); \
     266                 :   NS_SCRIPTABLE NS_IMETHOD GetTables(nsIUrlClassifierCallback *c); \
     267                 :   NS_SCRIPTABLE NS_IMETHOD SetHashCompleter(const nsACString & tableName, nsIUrlClassifierHashCompleter *completer); \
     268                 :   NS_SCRIPTABLE NS_IMETHOD BeginUpdate(nsIUrlClassifierUpdateObserver *updater, const nsACString & tables, const nsACString & clientKey); \
     269                 :   NS_SCRIPTABLE NS_IMETHOD BeginStream(const nsACString & table, const nsACString & serverMAC); \
     270                 :   NS_SCRIPTABLE NS_IMETHOD UpdateStream(const nsACString & updateChunk); \
     271                 :   NS_SCRIPTABLE NS_IMETHOD FinishStream(void); \
     272                 :   NS_SCRIPTABLE NS_IMETHOD FinishUpdate(void); \
     273                 :   NS_SCRIPTABLE NS_IMETHOD CancelUpdate(void); \
     274                 :   NS_SCRIPTABLE NS_IMETHOD ResetDatabase(void); 
     275                 : 
     276                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     277                 : #define NS_FORWARD_NSIURLCLASSIFIERDBSERVICE(_to) \
     278                 :   NS_SCRIPTABLE NS_IMETHOD Lookup(const nsACString & spec, nsIUrlClassifierCallback *c) { return _to Lookup(spec, c); } \
     279                 :   NS_SCRIPTABLE NS_IMETHOD GetTables(nsIUrlClassifierCallback *c) { return _to GetTables(c); } \
     280                 :   NS_SCRIPTABLE NS_IMETHOD SetHashCompleter(const nsACString & tableName, nsIUrlClassifierHashCompleter *completer) { return _to SetHashCompleter(tableName, completer); } \
     281                 :   NS_SCRIPTABLE NS_IMETHOD BeginUpdate(nsIUrlClassifierUpdateObserver *updater, const nsACString & tables, const nsACString & clientKey) { return _to BeginUpdate(updater, tables, clientKey); } \
     282                 :   NS_SCRIPTABLE NS_IMETHOD BeginStream(const nsACString & table, const nsACString & serverMAC) { return _to BeginStream(table, serverMAC); } \
     283                 :   NS_SCRIPTABLE NS_IMETHOD UpdateStream(const nsACString & updateChunk) { return _to UpdateStream(updateChunk); } \
     284                 :   NS_SCRIPTABLE NS_IMETHOD FinishStream(void) { return _to FinishStream(); } \
     285                 :   NS_SCRIPTABLE NS_IMETHOD FinishUpdate(void) { return _to FinishUpdate(); } \
     286                 :   NS_SCRIPTABLE NS_IMETHOD CancelUpdate(void) { return _to CancelUpdate(); } \
     287                 :   NS_SCRIPTABLE NS_IMETHOD ResetDatabase(void) { return _to ResetDatabase(); } 
     288                 : 
     289                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     290                 : #define NS_FORWARD_SAFE_NSIURLCLASSIFIERDBSERVICE(_to) \
     291                 :   NS_SCRIPTABLE NS_IMETHOD Lookup(const nsACString & spec, nsIUrlClassifierCallback *c) { return !_to ? NS_ERROR_NULL_POINTER : _to->Lookup(spec, c); } \
     292                 :   NS_SCRIPTABLE NS_IMETHOD GetTables(nsIUrlClassifierCallback *c) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTables(c); } \
     293                 :   NS_SCRIPTABLE NS_IMETHOD SetHashCompleter(const nsACString & tableName, nsIUrlClassifierHashCompleter *completer) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetHashCompleter(tableName, completer); } \
     294                 :   NS_SCRIPTABLE NS_IMETHOD BeginUpdate(nsIUrlClassifierUpdateObserver *updater, const nsACString & tables, const nsACString & clientKey) { return !_to ? NS_ERROR_NULL_POINTER : _to->BeginUpdate(updater, tables, clientKey); } \
     295                 :   NS_SCRIPTABLE NS_IMETHOD BeginStream(const nsACString & table, const nsACString & serverMAC) { return !_to ? NS_ERROR_NULL_POINTER : _to->BeginStream(table, serverMAC); } \
     296                 :   NS_SCRIPTABLE NS_IMETHOD UpdateStream(const nsACString & updateChunk) { return !_to ? NS_ERROR_NULL_POINTER : _to->UpdateStream(updateChunk); } \
     297                 :   NS_SCRIPTABLE NS_IMETHOD FinishStream(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->FinishStream(); } \
     298                 :   NS_SCRIPTABLE NS_IMETHOD FinishUpdate(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->FinishUpdate(); } \
     299                 :   NS_SCRIPTABLE NS_IMETHOD CancelUpdate(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CancelUpdate(); } \
     300                 :   NS_SCRIPTABLE NS_IMETHOD ResetDatabase(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ResetDatabase(); } 
     301                 : 
     302                 : #if 0
     303                 : /* Use the code below as a template for the implementation class for this interface. */
     304                 : 
     305                 : /* Header file */
     306                 : class nsUrlClassifierDBService : public nsIUrlClassifierDBService
     307                 : {
     308                 : public:
     309                 :   NS_DECL_ISUPPORTS
     310                 :   NS_DECL_NSIURLCLASSIFIERDBSERVICE
     311                 : 
     312                 :   nsUrlClassifierDBService();
     313                 : 
     314                 : private:
     315                 :   ~nsUrlClassifierDBService();
     316                 : 
     317                 : protected:
     318                 :   /* additional members */
     319                 : };
     320                 : 
     321                 : /* Implementation file */
     322                 : NS_IMPL_ISUPPORTS1(nsUrlClassifierDBService, nsIUrlClassifierDBService)
     323                 : 
     324                 : nsUrlClassifierDBService::nsUrlClassifierDBService()
     325                 : {
     326                 :   /* member initializers and constructor code */
     327                 : }
     328                 : 
     329                 : nsUrlClassifierDBService::~nsUrlClassifierDBService()
     330                 : {
     331                 :   /* destructor code */
     332                 : }
     333                 : 
     334                 : /* void lookup (in ACString spec, in nsIUrlClassifierCallback c); */
     335                 : NS_IMETHODIMP nsUrlClassifierDBService::Lookup(const nsACString & spec, nsIUrlClassifierCallback *c)
     336                 : {
     337                 :     return NS_ERROR_NOT_IMPLEMENTED;
     338                 : }
     339                 : 
     340                 : /* void getTables (in nsIUrlClassifierCallback c); */
     341                 : NS_IMETHODIMP nsUrlClassifierDBService::GetTables(nsIUrlClassifierCallback *c)
     342                 : {
     343                 :     return NS_ERROR_NOT_IMPLEMENTED;
     344                 : }
     345                 : 
     346                 : /* void setHashCompleter (in ACString tableName, in nsIUrlClassifierHashCompleter completer); */
     347                 : NS_IMETHODIMP nsUrlClassifierDBService::SetHashCompleter(const nsACString & tableName, nsIUrlClassifierHashCompleter *completer)
     348                 : {
     349                 :     return NS_ERROR_NOT_IMPLEMENTED;
     350                 : }
     351                 : 
     352                 : /* void beginUpdate (in nsIUrlClassifierUpdateObserver updater, in ACString tables, in ACString clientKey); */
     353                 : NS_IMETHODIMP nsUrlClassifierDBService::BeginUpdate(nsIUrlClassifierUpdateObserver *updater, const nsACString & tables, const nsACString & clientKey)
     354                 : {
     355                 :     return NS_ERROR_NOT_IMPLEMENTED;
     356                 : }
     357                 : 
     358                 : /* void beginStream (in ACString table, in ACString serverMAC); */
     359                 : NS_IMETHODIMP nsUrlClassifierDBService::BeginStream(const nsACString & table, const nsACString & serverMAC)
     360                 : {
     361                 :     return NS_ERROR_NOT_IMPLEMENTED;
     362                 : }
     363                 : 
     364                 : /* void updateStream (in ACString updateChunk); */
     365                 : NS_IMETHODIMP nsUrlClassifierDBService::UpdateStream(const nsACString & updateChunk)
     366                 : {
     367                 :     return NS_ERROR_NOT_IMPLEMENTED;
     368                 : }
     369                 : 
     370                 : /* void finishStream (); */
     371                 : NS_IMETHODIMP nsUrlClassifierDBService::FinishStream()
     372                 : {
     373                 :     return NS_ERROR_NOT_IMPLEMENTED;
     374                 : }
     375                 : 
     376                 : /* void finishUpdate (); */
     377                 : NS_IMETHODIMP nsUrlClassifierDBService::FinishUpdate()
     378                 : {
     379                 :     return NS_ERROR_NOT_IMPLEMENTED;
     380                 : }
     381                 : 
     382                 : /* void cancelUpdate (); */
     383                 : NS_IMETHODIMP nsUrlClassifierDBService::CancelUpdate()
     384                 : {
     385                 :     return NS_ERROR_NOT_IMPLEMENTED;
     386                 : }
     387                 : 
     388                 : /* void resetDatabase (); */
     389                 : NS_IMETHODIMP nsUrlClassifierDBService::ResetDatabase()
     390                 : {
     391                 :     return NS_ERROR_NOT_IMPLEMENTED;
     392                 : }
     393                 : 
     394                 : /* End of implementation class template. */
     395                 : #endif
     396                 : 
     397                 : 
     398                 : /* starting interface:    nsIUrlClassifierDBServiceWorker */
     399                 : #define NS_IURLCLASSIFIERDBSERVICEWORKER_IID_STR "0445be75-b114-43ea-89dc-aa16af26e77e"
     400                 : 
     401                 : #define NS_IURLCLASSIFIERDBSERVICEWORKER_IID \
     402                 :   {0x0445be75, 0xb114, 0x43ea, \
     403                 :     { 0x89, 0xdc, 0xaa, 0x16, 0xaf, 0x26, 0xe7, 0x7e }}
     404                 : 
     405              14 : class NS_NO_VTABLE NS_SCRIPTABLE nsIUrlClassifierDBServiceWorker : public nsIUrlClassifierDBService {
     406                 :  public: 
     407                 : 
     408                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IURLCLASSIFIERDBSERVICEWORKER_IID)
     409                 : 
     410                 :   /* void closeDb (); */
     411                 :   NS_SCRIPTABLE NS_IMETHOD CloseDb(void) = 0;
     412                 : 
     413                 :   /* [noscript] void cacheCompletions (in CacheCompletionArray completions); */
     414                 :   NS_IMETHOD CacheCompletions(nsTArray<mozilla::safebrowsing::CacheResult> *completions) = 0;
     415                 : 
     416                 :   /* [noscript] void cacheMisses (in PrefixArray misses); */
     417                 :   NS_IMETHOD CacheMisses(mozilla::safebrowsing::PrefixArray *misses) = 0;
     418                 : 
     419                 : };
     420                 : 
     421                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIUrlClassifierDBServiceWorker, NS_IURLCLASSIFIERDBSERVICEWORKER_IID)
     422                 : 
     423                 : /* Use this macro when declaring classes that implement this interface. */
     424                 : #define NS_DECL_NSIURLCLASSIFIERDBSERVICEWORKER \
     425                 :   NS_SCRIPTABLE NS_IMETHOD CloseDb(void); \
     426                 :   NS_IMETHOD CacheCompletions(nsTArray<mozilla::safebrowsing::CacheResult> *completions); \
     427                 :   NS_IMETHOD CacheMisses(mozilla::safebrowsing::PrefixArray *misses); 
     428                 : 
     429                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     430                 : #define NS_FORWARD_NSIURLCLASSIFIERDBSERVICEWORKER(_to) \
     431                 :   NS_SCRIPTABLE NS_IMETHOD CloseDb(void) { return _to CloseDb(); } \
     432                 :   NS_IMETHOD CacheCompletions(nsTArray<mozilla::safebrowsing::CacheResult> *completions) { return _to CacheCompletions(completions); } \
     433                 :   NS_IMETHOD CacheMisses(mozilla::safebrowsing::PrefixArray *misses) { return _to CacheMisses(misses); } 
     434                 : 
     435                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     436                 : #define NS_FORWARD_SAFE_NSIURLCLASSIFIERDBSERVICEWORKER(_to) \
     437                 :   NS_SCRIPTABLE NS_IMETHOD CloseDb(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CloseDb(); } \
     438                 :   NS_IMETHOD CacheCompletions(nsTArray<mozilla::safebrowsing::CacheResult> *completions) { return !_to ? NS_ERROR_NULL_POINTER : _to->CacheCompletions(completions); } \
     439                 :   NS_IMETHOD CacheMisses(mozilla::safebrowsing::PrefixArray *misses) { return !_to ? NS_ERROR_NULL_POINTER : _to->CacheMisses(misses); } 
     440                 : 
     441                 : #if 0
     442                 : /* Use the code below as a template for the implementation class for this interface. */
     443                 : 
     444                 : /* Header file */
     445                 : class nsUrlClassifierDBServiceWorker : public nsIUrlClassifierDBServiceWorker
     446                 : {
     447                 : public:
     448                 :   NS_DECL_ISUPPORTS
     449                 :   NS_DECL_NSIURLCLASSIFIERDBSERVICEWORKER
     450                 : 
     451                 :   nsUrlClassifierDBServiceWorker();
     452                 : 
     453                 : private:
     454                 :   ~nsUrlClassifierDBServiceWorker();
     455                 : 
     456                 : protected:
     457                 :   /* additional members */
     458                 : };
     459                 : 
     460                 : /* Implementation file */
     461                 : NS_IMPL_ISUPPORTS1(nsUrlClassifierDBServiceWorker, nsIUrlClassifierDBServiceWorker)
     462                 : 
     463                 : nsUrlClassifierDBServiceWorker::nsUrlClassifierDBServiceWorker()
     464                 : {
     465                 :   /* member initializers and constructor code */
     466                 : }
     467                 : 
     468                 : nsUrlClassifierDBServiceWorker::~nsUrlClassifierDBServiceWorker()
     469                 : {
     470                 :   /* destructor code */
     471                 : }
     472                 : 
     473                 : /* void closeDb (); */
     474                 : NS_IMETHODIMP nsUrlClassifierDBServiceWorker::CloseDb()
     475                 : {
     476                 :     return NS_ERROR_NOT_IMPLEMENTED;
     477                 : }
     478                 : 
     479                 : /* [noscript] void cacheCompletions (in CacheCompletionArray completions); */
     480                 : NS_IMETHODIMP nsUrlClassifierDBServiceWorker::CacheCompletions(nsTArray<mozilla::safebrowsing::CacheResult> *completions)
     481                 : {
     482                 :     return NS_ERROR_NOT_IMPLEMENTED;
     483                 : }
     484                 : 
     485                 : /* [noscript] void cacheMisses (in PrefixArray misses); */
     486                 : NS_IMETHODIMP nsUrlClassifierDBServiceWorker::CacheMisses(mozilla::safebrowsing::PrefixArray *misses)
     487                 : {
     488                 :     return NS_ERROR_NOT_IMPLEMENTED;
     489                 : }
     490                 : 
     491                 : /* End of implementation class template. */
     492                 : #endif
     493                 : 
     494                 : 
     495                 : /* starting interface:    nsIUrlClassifierLookupCallback */
     496                 : #define NS_IURLCLASSIFIERLOOKUPCALLBACK_IID_STR "b903dc8f-dff1-42fe-894b-36e7a59bb801"
     497                 : 
     498                 : #define NS_IURLCLASSIFIERLOOKUPCALLBACK_IID \
     499                 :   {0xb903dc8f, 0xdff1, 0x42fe, \
     500                 :     { 0x89, 0x4b, 0x36, 0xe7, 0xa5, 0x9b, 0xb8, 0x01 }}
     501                 : 
     502             280 : class NS_NO_VTABLE nsIUrlClassifierLookupCallback : public nsISupports {
     503                 :  public: 
     504                 : 
     505                 :   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IURLCLASSIFIERLOOKUPCALLBACK_IID)
     506                 : 
     507                 :   /* void lookupComplete (in ResultArray results); */
     508                 :   NS_IMETHOD LookupComplete(nsTArray<mozilla::safebrowsing::LookupResult> *results) = 0;
     509                 : 
     510                 : };
     511                 : 
     512                 :   NS_DEFINE_STATIC_IID_ACCESSOR(nsIUrlClassifierLookupCallback, NS_IURLCLASSIFIERLOOKUPCALLBACK_IID)
     513                 : 
     514                 : /* Use this macro when declaring classes that implement this interface. */
     515                 : #define NS_DECL_NSIURLCLASSIFIERLOOKUPCALLBACK \
     516                 :   NS_IMETHOD LookupComplete(nsTArray<mozilla::safebrowsing::LookupResult> *results); 
     517                 : 
     518                 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
     519                 : #define NS_FORWARD_NSIURLCLASSIFIERLOOKUPCALLBACK(_to) \
     520                 :   NS_IMETHOD LookupComplete(nsTArray<mozilla::safebrowsing::LookupResult> *results) { return _to LookupComplete(results); } 
     521                 : 
     522                 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
     523                 : #define NS_FORWARD_SAFE_NSIURLCLASSIFIERLOOKUPCALLBACK(_to) \
     524                 :   NS_IMETHOD LookupComplete(nsTArray<mozilla::safebrowsing::LookupResult> *results) { return !_to ? NS_ERROR_NULL_POINTER : _to->LookupComplete(results); } 
     525                 : 
     526                 : #if 0
     527                 : /* Use the code below as a template for the implementation class for this interface. */
     528                 : 
     529                 : /* Header file */
     530                 : class nsUrlClassifierLookupCallback : public nsIUrlClassifierLookupCallback
     531                 : {
     532                 : public:
     533                 :   NS_DECL_ISUPPORTS
     534                 :   NS_DECL_NSIURLCLASSIFIERLOOKUPCALLBACK
     535                 : 
     536                 :   nsUrlClassifierLookupCallback();
     537                 : 
     538                 : private:
     539                 :   ~nsUrlClassifierLookupCallback();
     540                 : 
     541                 : protected:
     542                 :   /* additional members */
     543                 : };
     544                 : 
     545                 : /* Implementation file */
     546                 : NS_IMPL_ISUPPORTS1(nsUrlClassifierLookupCallback, nsIUrlClassifierLookupCallback)
     547                 : 
     548                 : nsUrlClassifierLookupCallback::nsUrlClassifierLookupCallback()
     549                 : {
     550                 :   /* member initializers and constructor code */
     551                 : }
     552                 : 
     553                 : nsUrlClassifierLookupCallback::~nsUrlClassifierLookupCallback()
     554                 : {
     555                 :   /* destructor code */
     556                 : }
     557                 : 
     558                 : /* void lookupComplete (in ResultArray results); */
     559                 : NS_IMETHODIMP nsUrlClassifierLookupCallback::LookupComplete(nsTArray<mozilla::safebrowsing::LookupResult> *results)
     560                 : {
     561                 :     return NS_ERROR_NOT_IMPLEMENTED;
     562                 : }
     563                 : 
     564                 : /* End of implementation class template. */
     565                 : #endif
     566                 : 
     567                 : 
     568                 : #endif /* __gen_nsIUrlClassifierDBService_h__ */

Generated by: LCOV version 1.7