The Tor Browser: xpcom/ds/nsSupportsPrimitives.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

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

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

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

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

     6 #include "nsSupportsPrimitives.h"

     7 #include "nsMemory.h"

     8 #include "prprf.h"

    10 using mozilla::fallible_t;

    12 /***************************************************************************/

    14 NS_IMPL_ISUPPORTS(nsSupportsIDImpl, nsISupportsID, nsISupportsPrimitive)

    16 nsSupportsIDImpl::nsSupportsIDImpl()

    17     : mData(nullptr)

    18 {

    19 }

    21 NS_IMETHODIMP nsSupportsIDImpl::GetType(uint16_t *aType)

    22 {

    23     NS_ASSERTION(aType, "Bad pointer");

    24     *aType = TYPE_ID;

    26     return NS_OK;

    27 }

    29 NS_IMETHODIMP nsSupportsIDImpl::GetData(nsID **aData)

    30 {

    31     NS_ASSERTION(aData, "Bad pointer");

    32     if(mData)

    33     {

    34         *aData = (nsID*) nsMemory::Clone(mData, sizeof(nsID));

    35         return *aData ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

    36     }

    37     *aData = nullptr;

    38     return NS_OK;

    39 }

    41 NS_IMETHODIMP nsSupportsIDImpl::SetData(const nsID *aData)

    42 {

    43     if(mData)

    44       nsMemory::Free(mData);

    45     if(aData)

    46         mData = (nsID*) nsMemory::Clone(aData, sizeof(nsID));

    47     else

    48         mData = nullptr;

    49     return NS_OK;

    50 }

    52 NS_IMETHODIMP nsSupportsIDImpl::ToString(char **_retval)

    53 {

    54     char* result;

    55     NS_ASSERTION(_retval, "Bad pointer");

    56     if(mData)

    57     {

    58         result = mData->ToString();

    59     }

    60     else

    61     {

    62         static const char nullStr[] = "null";

    63         result = (char*) nsMemory::Clone(nullStr, sizeof(nullStr));

    64     }

    66     *_retval = result;

    67     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

    68 }

    70 /*****************************************************************************

    71  * nsSupportsCStringImpl

    72  *****************************************************************************/

    74 NS_IMPL_ISUPPORTS(nsSupportsCStringImpl, nsISupportsCString,

    75                   nsISupportsPrimitive)

    77 NS_IMETHODIMP nsSupportsCStringImpl::GetType(uint16_t *aType)

    78 {

    79     NS_ASSERTION(aType, "Bad pointer");

    81     *aType = TYPE_CSTRING;

    82     return NS_OK;

    83 }

    85 NS_IMETHODIMP nsSupportsCStringImpl::GetData(nsACString& aData)

    86 {

    87     aData = mData;

    88     return NS_OK;

    89 }

    91 NS_IMETHODIMP nsSupportsCStringImpl::ToString(char **_retval)

    92 {

    93     *_retval = ToNewCString(mData);

    95     if (!*_retval)

    96         return NS_ERROR_OUT_OF_MEMORY;

    98     return NS_OK;

    99 }

   101 NS_IMETHODIMP nsSupportsCStringImpl::SetData(const nsACString& aData)

   102 {

   103     bool ok = mData.Assign(aData, fallible_t());

   104     if (!ok)

   105         return NS_ERROR_OUT_OF_MEMORY;

   106     return NS_OK;

   107 }

   109 /*****************************************************************************

   110  * nsSupportsStringImpl

   111  *****************************************************************************/

   113 NS_IMPL_ISUPPORTS(nsSupportsStringImpl, nsISupportsString,

   114                   nsISupportsPrimitive)

   116 NS_IMETHODIMP nsSupportsStringImpl::GetType(uint16_t *aType)

   117 {

   118     NS_ASSERTION(aType, "Bad pointer");

   120     *aType = TYPE_STRING;

   121     return NS_OK;

   122 }

   124 NS_IMETHODIMP nsSupportsStringImpl::GetData(nsAString& aData)

   125 {

   126     aData = mData;

   127     return NS_OK;

   128 }

   130 NS_IMETHODIMP nsSupportsStringImpl::ToString(char16_t **_retval)

   131 {

   132     *_retval = ToNewUnicode(mData);

   134     if (!*_retval)

   135         return NS_ERROR_OUT_OF_MEMORY;

   137     return NS_OK;

   138 }

   140 NS_IMETHODIMP nsSupportsStringImpl::SetData(const nsAString& aData)

   141 {

   142     bool ok = mData.Assign(aData, fallible_t());

   143     if (!ok)

   144         return NS_ERROR_OUT_OF_MEMORY;

   145     return NS_OK;

   146 }

   148 /***************************************************************************/

   150 NS_IMPL_ISUPPORTS(nsSupportsPRBoolImpl, nsISupportsPRBool,

   151                   nsISupportsPrimitive)

   153 nsSupportsPRBoolImpl::nsSupportsPRBoolImpl()

   154     : mData(false)

   155 {

   156 }

   158 NS_IMETHODIMP nsSupportsPRBoolImpl::GetType(uint16_t *aType)

   159 {

   160     NS_ASSERTION(aType, "Bad pointer");

   161     *aType = TYPE_PRBOOL;

   163     return NS_OK;

   164 }

   166 NS_IMETHODIMP nsSupportsPRBoolImpl::GetData(bool *aData)

   167 {

   168     NS_ASSERTION(aData, "Bad pointer");

   169     *aData = mData;

   170     return NS_OK;

   171 }

   173 NS_IMETHODIMP nsSupportsPRBoolImpl::SetData(bool aData)

   174 {

   175     mData = aData;

   176     return NS_OK;

   177 }

   179 NS_IMETHODIMP nsSupportsPRBoolImpl::ToString(char **_retval)

   180 {

   181     NS_ASSERTION(_retval, "Bad pointer");

   182     const char * str = mData ? "true" : "false";

   183     char* result = (char*) nsMemory::Clone(str,

   184                                 (strlen(str)+1)*sizeof(char));

   185     *_retval = result;

   186     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   187 }

   189 /***************************************************************************/

   191 NS_IMPL_ISUPPORTS(nsSupportsPRUint8Impl, nsISupportsPRUint8,

   192                   nsISupportsPrimitive)

   194 nsSupportsPRUint8Impl::nsSupportsPRUint8Impl()

   195     : mData(0)

   196 {

   197 }

   199 NS_IMETHODIMP nsSupportsPRUint8Impl::GetType(uint16_t *aType)

   200 {

   201     NS_ASSERTION(aType, "Bad pointer");

   202     *aType = TYPE_PRUINT8;

   204     return NS_OK;

   205 }

   207 NS_IMETHODIMP nsSupportsPRUint8Impl::GetData(uint8_t *aData)

   208 {

   209     NS_ASSERTION(aData, "Bad pointer");

   210     *aData = mData;

   211     return NS_OK;

   212 }

   214 NS_IMETHODIMP nsSupportsPRUint8Impl::SetData(uint8_t aData)

   215 {

   216     mData = aData;

   217     return NS_OK;

   218 }

   220 NS_IMETHODIMP nsSupportsPRUint8Impl::ToString(char **_retval)

   221 {

   222     NS_ASSERTION(_retval, "Bad pointer");

   223     static const int size = 8;

   224     char buf[size];

   226     PR_snprintf(buf, size, "%u", (uint16_t) mData);

   228     char* result = (char*) nsMemory::Clone(buf,

   229                                 (strlen(buf)+1)*sizeof(char));

   230     *_retval = result;

   231     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   232 }

   234 /***************************************************************************/

   236 NS_IMPL_ISUPPORTS(nsSupportsPRUint16Impl, nsISupportsPRUint16,

   237                   nsISupportsPrimitive)

   239 nsSupportsPRUint16Impl::nsSupportsPRUint16Impl()

   240     : mData(0)

   241 {

   242 }

   244 NS_IMETHODIMP nsSupportsPRUint16Impl::GetType(uint16_t *aType)

   245 {

   246     NS_ASSERTION(aType, "Bad pointer");

   247     *aType = TYPE_PRUINT16;

   249     return NS_OK;

   250 }

   252 NS_IMETHODIMP nsSupportsPRUint16Impl::GetData(uint16_t *aData)

   253 {

   254     NS_ASSERTION(aData, "Bad pointer");

   255     *aData = mData;

   256     return NS_OK;

   257 }

   259 NS_IMETHODIMP nsSupportsPRUint16Impl::SetData(uint16_t aData)

   260 {

   261     mData = aData;

   262     return NS_OK;

   263 }

   265 NS_IMETHODIMP nsSupportsPRUint16Impl::ToString(char **_retval)

   266 {

   267     NS_ASSERTION(_retval, "Bad pointer");

   268     static const int size = 8;

   269     char buf[size];

   271     PR_snprintf(buf, size, "%u", (int) mData);

   273     char* result = (char*) nsMemory::Clone(buf,

   274                                 (strlen(buf)+1)*sizeof(char));

   275     *_retval = result;

   276     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   277 }

   279 /***************************************************************************/

   281 NS_IMPL_ISUPPORTS(nsSupportsPRUint32Impl, nsISupportsPRUint32,

   282                   nsISupportsPrimitive)

   284 nsSupportsPRUint32Impl::nsSupportsPRUint32Impl()

   285     : mData(0)

   286 {

   287 }

   289 NS_IMETHODIMP nsSupportsPRUint32Impl::GetType(uint16_t *aType)

   290 {

   291     NS_ASSERTION(aType, "Bad pointer");

   292     *aType = TYPE_PRUINT32;

   294     return NS_OK;

   295 }

   297 NS_IMETHODIMP nsSupportsPRUint32Impl::GetData(uint32_t *aData)

   298 {

   299     NS_ASSERTION(aData, "Bad pointer");

   300     *aData = mData;

   301     return NS_OK;

   302 }

   304 NS_IMETHODIMP nsSupportsPRUint32Impl::SetData(uint32_t aData)

   305 {

   306     mData = aData;

   307     return NS_OK;

   308 }

   310 NS_IMETHODIMP nsSupportsPRUint32Impl::ToString(char **_retval)

   311 {

   312     NS_ASSERTION(_retval, "Bad pointer");

   313     static const int size = 16;

   314     char buf[size];

   316     PR_snprintf(buf, size, "%lu", mData);

   318     char* result = (char*) nsMemory::Clone(buf,

   319                                 (strlen(buf)+1)*sizeof(char));

   320     *_retval = result;

   321     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   322 }

   324 /***************************************************************************/

   326 NS_IMPL_ISUPPORTS(nsSupportsPRUint64Impl, nsISupportsPRUint64,

   327                   nsISupportsPrimitive)

   329 nsSupportsPRUint64Impl::nsSupportsPRUint64Impl()

   330     : mData(0)

   331 {

   332 }

   334 NS_IMETHODIMP nsSupportsPRUint64Impl::GetType(uint16_t *aType)

   335 {

   336     NS_ASSERTION(aType, "Bad pointer");

   337     *aType = TYPE_PRUINT64;

   339     return NS_OK;

   340 }

   342 NS_IMETHODIMP nsSupportsPRUint64Impl::GetData(uint64_t *aData)

   343 {

   344     NS_ASSERTION(aData, "Bad pointer");

   345     *aData = mData;

   346     return NS_OK;

   347 }

   349 NS_IMETHODIMP nsSupportsPRUint64Impl::SetData(uint64_t aData)

   350 {

   351     mData = aData;

   352     return NS_OK;

   353 }

   355 NS_IMETHODIMP nsSupportsPRUint64Impl::ToString(char **_retval)

   356 {

   357     NS_ASSERTION(_retval, "Bad pointer");

   358     static const int size = 32;

   359     char buf[size];

   361     PR_snprintf(buf, size, "%llu", mData);

   363     char* result = (char*) nsMemory::Clone(buf,

   364                                 (strlen(buf)+1)*sizeof(char));

   365     *_retval = result;

   366     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   367 }

   369 /***************************************************************************/

   371 NS_IMPL_ISUPPORTS(nsSupportsPRTimeImpl, nsISupportsPRTime,

   372                   nsISupportsPrimitive)

   374 nsSupportsPRTimeImpl::nsSupportsPRTimeImpl()

   375     : mData(0)

   376 {

   377 }

   379 NS_IMETHODIMP nsSupportsPRTimeImpl::GetType(uint16_t *aType)

   380 {

   381     NS_ASSERTION(aType, "Bad pointer");

   382     *aType = TYPE_PRTIME;

   384     return NS_OK;

   385 }

   387 NS_IMETHODIMP nsSupportsPRTimeImpl::GetData(PRTime *aData)

   388 {

   389     NS_ASSERTION(aData, "Bad pointer");

   390     *aData = mData;

   391     return NS_OK;

   392 }

   394 NS_IMETHODIMP nsSupportsPRTimeImpl::SetData(PRTime aData)

   395 {

   396     mData = aData;

   397     return NS_OK;

   398 }

   400 NS_IMETHODIMP nsSupportsPRTimeImpl::ToString(char **_retval)

   401 {

   402     NS_ASSERTION(_retval, "Bad pointer");

   403     static const int size = 32;

   404     char buf[size];

   406     PR_snprintf(buf, size, "%llu", mData);

   408     char* result = (char*) nsMemory::Clone(buf,

   409                                 (strlen(buf)+1)*sizeof(char));

   410     *_retval = result;

   411     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   412 }

   414 /***************************************************************************/

   416 NS_IMPL_ISUPPORTS(nsSupportsCharImpl, nsISupportsChar,

   417                   nsISupportsPrimitive)

   419 nsSupportsCharImpl::nsSupportsCharImpl()

   420     : mData(0)

   421 {

   422 }

   424 NS_IMETHODIMP nsSupportsCharImpl::GetType(uint16_t *aType)

   425 {

   426     NS_ASSERTION(aType, "Bad pointer");

   427     *aType = TYPE_CHAR;

   429     return NS_OK;

   430 }

   432 NS_IMETHODIMP nsSupportsCharImpl::GetData(char *aData)

   433 {

   434     NS_ASSERTION(aData, "Bad pointer");

   435     *aData = mData;

   436     return NS_OK;

   437 }

   439 NS_IMETHODIMP nsSupportsCharImpl::SetData(char aData)

   440 {

   441     mData = aData;

   442     return NS_OK;

   443 }

   445 NS_IMETHODIMP nsSupportsCharImpl::ToString(char **_retval)

   446 {

   447     char* result;

   448     NS_ASSERTION(_retval, "Bad pointer");

   450     if(nullptr != (result = (char*) nsMemory::Alloc(2*sizeof(char))))

   451     {

   452         result[0] = mData;

   453         result[1] = '\0';

   454     }

   455     *_retval = result;

   456     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   457 }

   459 /***************************************************************************/

   461 NS_IMPL_ISUPPORTS(nsSupportsPRInt16Impl, nsISupportsPRInt16,

   462                   nsISupportsPrimitive)

   464 nsSupportsPRInt16Impl::nsSupportsPRInt16Impl()

   465     : mData(0)

   466 {

   467 }

   469 NS_IMETHODIMP nsSupportsPRInt16Impl::GetType(uint16_t *aType)

   470 {

   471     NS_ASSERTION(aType, "Bad pointer");

   472     *aType = TYPE_PRINT16;

   474     return NS_OK;

   475 }

   477 NS_IMETHODIMP nsSupportsPRInt16Impl::GetData(int16_t *aData)

   478 {

   479     NS_ASSERTION(aData, "Bad pointer");

   480     *aData = mData;

   481     return NS_OK;

   482 }

   484 NS_IMETHODIMP nsSupportsPRInt16Impl::SetData(int16_t aData)

   485 {

   486     mData = aData;

   487     return NS_OK;

   488 }

   490 NS_IMETHODIMP nsSupportsPRInt16Impl::ToString(char **_retval)

   491 {

   492     NS_ASSERTION(_retval, "Bad pointer");

   493     static const int size = 8;

   494     char buf[size];

   496     PR_snprintf(buf, size, "%d", mData);

   498     char* result = (char*) nsMemory::Clone(buf,

   499                                 (strlen(buf)+1)*sizeof(char));

   500     *_retval = result;

   501     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   502 }

   504 /***************************************************************************/

   506 NS_IMPL_ISUPPORTS(nsSupportsPRInt32Impl, nsISupportsPRInt32,

   507                   nsISupportsPrimitive)

   509 nsSupportsPRInt32Impl::nsSupportsPRInt32Impl()

   510     : mData(0)

   511 {

   512 }

   514 NS_IMETHODIMP nsSupportsPRInt32Impl::GetType(uint16_t *aType)

   515 {

   516     NS_ASSERTION(aType, "Bad pointer");

   517     *aType = TYPE_PRINT32;

   519     return NS_OK;

   520 }

   522 NS_IMETHODIMP nsSupportsPRInt32Impl::GetData(int32_t *aData)

   523 {

   524     NS_ASSERTION(aData, "Bad pointer");

   525     *aData = mData;

   526     return NS_OK;

   527 }

   529 NS_IMETHODIMP nsSupportsPRInt32Impl::SetData(int32_t aData)

   530 {

   531     mData = aData;

   532     return NS_OK;

   533 }

   535 NS_IMETHODIMP nsSupportsPRInt32Impl::ToString(char **_retval)

   536 {

   537     NS_ASSERTION(_retval, "Bad pointer");

   538     static const int size = 16;

   539     char buf[size];

   541     PR_snprintf(buf, size, "%ld", mData);

   543     char* result = (char*) nsMemory::Clone(buf,

   544                                 (strlen(buf)+1)*sizeof(char));

   545     *_retval = result;

   546     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   547 }

   549 /***************************************************************************/

   551 NS_IMPL_ISUPPORTS(nsSupportsPRInt64Impl, nsISupportsPRInt64,

   552                   nsISupportsPrimitive)

   554 nsSupportsPRInt64Impl::nsSupportsPRInt64Impl()

   555     : mData(0)

   556 {

   557 }

   559 NS_IMETHODIMP nsSupportsPRInt64Impl::GetType(uint16_t *aType)

   560 {

   561     NS_ASSERTION(aType, "Bad pointer");

   562     *aType = TYPE_PRINT64;

   564     return NS_OK;

   565 }

   567 NS_IMETHODIMP nsSupportsPRInt64Impl::GetData(int64_t *aData)

   568 {

   569     NS_ASSERTION(aData, "Bad pointer");

   570     *aData = mData;

   571     return NS_OK;

   572 }

   574 NS_IMETHODIMP nsSupportsPRInt64Impl::SetData(int64_t aData)

   575 {

   576     mData = aData;

   577     return NS_OK;

   578 }

   580 NS_IMETHODIMP nsSupportsPRInt64Impl::ToString(char **_retval)

   581 {

   582     NS_ASSERTION(_retval, "Bad pointer");

   583     static const int size = 32;

   584     char buf[size];

   586     PR_snprintf(buf, size, "%lld", mData);

   588     char* result = (char*) nsMemory::Clone(buf,

   589                                 (strlen(buf)+1)*sizeof(char));

   590     *_retval = result;

   591     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   592 }

   594 /***************************************************************************/

   596 NS_IMPL_ISUPPORTS(nsSupportsFloatImpl, nsISupportsFloat,

   597                   nsISupportsPrimitive)

   599 nsSupportsFloatImpl::nsSupportsFloatImpl()

   600     : mData(float(0.0))

   601 {

   602 }

   604 NS_IMETHODIMP nsSupportsFloatImpl::GetType(uint16_t *aType)

   605 {

   606     NS_ASSERTION(aType, "Bad pointer");

   607     *aType = TYPE_FLOAT;

   609     return NS_OK;

   610 }

   612 NS_IMETHODIMP nsSupportsFloatImpl::GetData(float *aData)

   613 {

   614     NS_ASSERTION(aData, "Bad pointer");

   615     *aData = mData;

   616     return NS_OK;

   617 }

   619 NS_IMETHODIMP nsSupportsFloatImpl::SetData(float aData)

   620 {

   621     mData = aData;

   622     return NS_OK;

   623 }

   625 NS_IMETHODIMP nsSupportsFloatImpl::ToString(char **_retval)

   626 {

   627     NS_ASSERTION(_retval, "Bad pointer");

   628     static const int size = 32;

   629     char buf[size];

   631     PR_snprintf(buf, size, "%f", (double) mData);

   633     char* result = (char*) nsMemory::Clone(buf,

   634                                 (strlen(buf)+1)*sizeof(char));

   635     *_retval = result;

   636     return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   637 }

   639 /***************************************************************************/

   641 NS_IMPL_ISUPPORTS(nsSupportsDoubleImpl, nsISupportsDouble,

   642                   nsISupportsPrimitive)

   644 nsSupportsDoubleImpl::nsSupportsDoubleImpl()

   645     : mData(double(0.0))

   646 {

   647 }

   649 NS_IMETHODIMP nsSupportsDoubleImpl::GetType(uint16_t *aType)

   650 {

   651     NS_ASSERTION(aType, "Bad pointer");

   652     *aType = TYPE_DOUBLE;

   654     return NS_OK;

   655 }

   657 NS_IMETHODIMP nsSupportsDoubleImpl::GetData(double *aData)

   658 {

   659     NS_ASSERTION(aData, "Bad pointer");

   660     *aData = mData;

   661     return NS_OK;

   662 }

   664 NS_IMETHODIMP nsSupportsDoubleImpl::SetData(double aData)

   665 {

   666     mData = aData;

   667     return NS_OK;

   668 }

   670 NS_IMETHODIMP nsSupportsDoubleImpl::ToString(char **_retval)

   671 {

   672     NS_ASSERTION(_retval, "Bad pointer");

   673     static const int size = 32;

   674     char buf[size];

   676     PR_snprintf(buf, size, "%f", mData);

   678     char* result = (char*) nsMemory::Clone(buf,

   679                                 (strlen(buf)+1)*sizeof(char));

   680     *_retval = result;

   681     return  result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   682 }

   684 /***************************************************************************/

   687 NS_IMPL_ISUPPORTS(nsSupportsVoidImpl, nsISupportsVoid,

   688                   nsISupportsPrimitive)

   690 nsSupportsVoidImpl::nsSupportsVoidImpl()

   691     : mData(nullptr)

   692 {

   693 }

   695 NS_IMETHODIMP nsSupportsVoidImpl::GetType(uint16_t *aType)

   696 {

   697     NS_ASSERTION(aType, "Bad pointer");

   698     *aType = TYPE_VOID;

   700     return NS_OK;

   701 }

   703 NS_IMETHODIMP nsSupportsVoidImpl::GetData(void * *aData)

   704 {

   705     NS_ASSERTION(aData, "Bad pointer");

   706     *aData = mData;

   707     return NS_OK;

   708 }

   710 NS_IMETHODIMP nsSupportsVoidImpl::SetData(void * aData)

   711 {

   712     mData = aData;

   713     return NS_OK;

   714 }

   716 NS_IMETHODIMP nsSupportsVoidImpl::ToString(char **_retval)

   717 {

   718     NS_ASSERTION(_retval, "Bad pointer");

   720     static const char str[] = "[raw data]";

   721     char* result = (char*) nsMemory::Clone(str, sizeof(str));

   722     *_retval = result;

   723     return  result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   724 }

   726 /***************************************************************************/

   729 NS_IMPL_ISUPPORTS(nsSupportsInterfacePointerImpl,

   730                   nsISupportsInterfacePointer,

   731                   nsISupportsPrimitive)

   733 nsSupportsInterfacePointerImpl::nsSupportsInterfacePointerImpl()

   734     : mIID(nullptr)

   735 {

   736 }

   738 nsSupportsInterfacePointerImpl::~nsSupportsInterfacePointerImpl()

   739 {

   740     if (mIID) {

   741         nsMemory::Free(mIID);

   742     }

   743 }

   745 NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetType(uint16_t *aType)

   746 {

   747     NS_ASSERTION(aType, "Bad pointer");

   748     *aType = TYPE_INTERFACE_POINTER;

   750     return NS_OK;

   751 }

   753 NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetData(nsISupports **aData)

   754 {

   755     NS_ASSERTION(aData,"Bad pointer");

   757     *aData = mData;

   758     NS_IF_ADDREF(*aData);

   760     return NS_OK;

   761 }

   763 NS_IMETHODIMP nsSupportsInterfacePointerImpl::SetData(nsISupports * aData)

   764 {

   765     mData = aData;

   767     return NS_OK;

   768 }

   770 NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetDataIID(nsID **aIID)

   771 {

   772     NS_ASSERTION(aIID,"Bad pointer");

   774     if(mIID)

   775     {

   776         *aIID = (nsID*) nsMemory::Clone(mIID, sizeof(nsID));

   777         return *aIID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   778     }

   779     *aIID = nullptr;

   780     return NS_OK;

   781 }

   783 NS_IMETHODIMP nsSupportsInterfacePointerImpl::SetDataIID(const nsID *aIID)

   784 {

   785     if(mIID)

   786         nsMemory::Free(mIID);

   787     if(aIID)

   788         mIID = (nsID*) nsMemory::Clone(aIID, sizeof(nsID));

   789     else

   790         mIID = nullptr;

   792     return NS_OK;

   793 }

   795 NS_IMETHODIMP nsSupportsInterfacePointerImpl::ToString(char **_retval)

   796 {

   797     NS_ASSERTION(_retval, "Bad pointer");

   799     static const char str[] = "[interface pointer]";

   801     // jband sez: think about asking nsIInterfaceInfoManager whether

   802     // the interface has a known human-readable name

   803     char* result = (char*) nsMemory::Clone(str, sizeof(str));

   804     *_retval = result;

   805     return  result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;

   806 }

   808 /***************************************************************************/

   810 NS_IMPL_ISUPPORTS(nsSupportsDependentCString,nsISupportsCString,nsISupportsPrimitive)

   812 nsSupportsDependentCString::nsSupportsDependentCString(const char* aStr)

   813     : mData(aStr)

   814 { }

   816 NS_IMETHODIMP

   817 nsSupportsDependentCString::GetType(uint16_t *aType)

   818 {

   819     if (NS_WARN_IF(!aType))

   820         return NS_ERROR_INVALID_ARG;

   822     *aType = TYPE_CSTRING;

   823     return NS_OK;

   824 }

   826 NS_IMETHODIMP

   827 nsSupportsDependentCString::GetData(nsACString& aData)

   828 {

   829     aData = mData;

   830     return NS_OK;

   831 }

   833 NS_IMETHODIMP

   834 nsSupportsDependentCString::ToString(char **_retval)

   835 {

   836     if (NS_WARN_IF(!_retval))

   837         return NS_ERROR_INVALID_ARG;

   839     *_retval = ToNewCString(mData);

   840     if (!*_retval)

   841         return NS_ERROR_OUT_OF_MEMORY;

   843     return NS_OK;

   844 }

   846 NS_IMETHODIMP

   847 nsSupportsDependentCString::SetData(const nsACString& aData)

   848 {

   849     return NS_ERROR_NOT_IMPLEMENTED;

   850 }

The Tor Browser / file revision

xpcom/ds/nsSupportsPrimitives.cpp@6474c204b198

xpcom/ds/nsSupportsPrimitives.cpp