The Tor Browser: xpcom/glue/nsComponentManagerUtils.cpp@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     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 #ifndef nsXPCOM_h__

     7 #include "nsXPCOM.h"

     8 #endif

    10 #ifndef nsCOMPtr_h__

    11 #include "nsCOMPtr.h"

    12 #endif

    14 #include "nsComponentManagerUtils.h"

    15 #include "nsServiceManagerUtils.h"

    17 #include "nsIComponentManager.h"

    19 #ifndef MOZILLA_INTERNAL_API

    21 nsresult

    22 CallGetService(const nsCID &aCID, const nsIID &aIID, void **aResult)

    23 {

    24     nsCOMPtr<nsIServiceManager> servMgr;

    25     nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));

    26     if (servMgr)

    27         status = servMgr->GetService(aCID, aIID, aResult);

    28     return status;

    29 }

    31 nsresult

    32 CallGetService(const char *aContractID, const nsIID &aIID, void **aResult)

    33 {

    34     nsCOMPtr<nsIServiceManager> servMgr;

    35     nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));

    36     if (servMgr)

    37         status = servMgr->GetServiceByContractID(aContractID, aIID, aResult);

    38     return status;

    39 }

    41 #else

    43 #include "nsComponentManager.h"

    45 nsresult

    46 CallGetService(const nsCID &aCID, const nsIID &aIID, void **aResult)

    47 {

    48     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;

    49     if (NS_WARN_IF(!compMgr))

    50         return NS_ERROR_NOT_INITIALIZED;

    52     return compMgr->nsComponentManagerImpl::GetService(aCID, aIID, aResult);

    53 }

    55 nsresult

    56 CallGetService(const char *aContractID, const nsIID &aIID, void **aResult)

    57 {

    58     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;

    59     if (NS_WARN_IF(!compMgr))

    60         return NS_ERROR_NOT_INITIALIZED;

    62     return compMgr->

    63         nsComponentManagerImpl::GetServiceByContractID(aContractID,

    64                                                        aIID, aResult);

    65 }

    67 #endif

    69 #ifndef MOZILLA_INTERNAL_API

    71 nsresult

    72 CallCreateInstance(const nsCID &aCID, nsISupports *aDelegate,

    73                    const nsIID &aIID, void **aResult)

    74 {

    75     nsCOMPtr<nsIComponentManager> compMgr;

    76     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));

    77     if (compMgr)

    78         status = compMgr->CreateInstance(aCID, aDelegate, aIID, aResult);

    79     return status;

    80 }

    82 nsresult

    83 CallCreateInstance(const char *aContractID, nsISupports *aDelegate,

    84                    const nsIID &aIID, void **aResult)

    85 {

    86     nsCOMPtr<nsIComponentManager> compMgr;

    87     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));

    88     if (compMgr)

    89         status = compMgr->CreateInstanceByContractID(aContractID, aDelegate,

    90                                                      aIID, aResult);

    91     return status;

    92 }

    94 nsresult

    95 CallGetClassObject(const nsCID &aCID, const nsIID &aIID, void **aResult)

    96 {

    97     nsCOMPtr<nsIComponentManager> compMgr;

    98     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));

    99     if (compMgr)

   100         status = compMgr->GetClassObject(aCID, aIID, aResult);

   101     return status;

   102 }

   104 nsresult

   105 CallGetClassObject(const char *aContractID, const nsIID &aIID, void **aResult)

   106 {

   107     nsCOMPtr<nsIComponentManager> compMgr;

   108     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));

   109     if (compMgr)

   110         status = compMgr->GetClassObjectByContractID(aContractID, aIID,

   111                                                      aResult);

   112     return status;

   113 }

   115 #else

   117 #include "nsComponentManager.h"

   119 nsresult

   120 CallCreateInstance(const nsCID &aCID, nsISupports *aDelegate,

   121                    const nsIID &aIID, void **aResult)

   122 {

   123     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;

   124     if (NS_WARN_IF(!compMgr))

   125         return NS_ERROR_NOT_INITIALIZED;

   127     return compMgr->

   128         nsComponentManagerImpl::CreateInstance(aCID, aDelegate, aIID, aResult);

   129 }

   131 nsresult

   132 CallCreateInstance(const char *aContractID, nsISupports *aDelegate,

   133                    const nsIID &aIID, void **aResult)

   134 {

   135     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;

   136     if (NS_WARN_IF(!compMgr))

   137         return NS_ERROR_NOT_INITIALIZED;

   139     return compMgr->

   140         nsComponentManagerImpl::CreateInstanceByContractID(aContractID,

   141                                                            aDelegate, aIID,

   142                                                            aResult);

   143 }

   145 nsresult

   146 CallGetClassObject(const nsCID &aCID, const nsIID &aIID, void **aResult)

   147 {

   148     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;

   149     if (NS_WARN_IF(!compMgr))

   150         return NS_ERROR_NOT_INITIALIZED;

   152     return compMgr->

   153         nsComponentManagerImpl::GetClassObject(aCID, aIID, aResult);

   154 }

   156 nsresult

   157 CallGetClassObject(const char *aContractID, const nsIID &aIID, void **aResult)

   158 {

   159     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;

   160     if (NS_WARN_IF(!compMgr))

   161         return NS_ERROR_NOT_INITIALIZED;

   163     return compMgr->

   164         nsComponentManagerImpl::GetClassObjectByContractID(aContractID, aIID,

   165                                                            aResult);

   166 }

   168 #endif

   170 nsresult

   171 nsCreateInstanceByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const

   172 {

   173     nsresult status = CallCreateInstance(mCID, mOuter, aIID, aInstancePtr);

   174     if ( NS_FAILED(status) )

   175         *aInstancePtr = 0;

   176     if ( mErrorPtr )

   177         *mErrorPtr = status;

   178     return status;

   179 }

   181 nsresult

   182 nsCreateInstanceByContractID::operator()( const nsIID& aIID, void** aInstancePtr ) const

   183 {

   184     nsresult status = CallCreateInstance(mContractID, mOuter, aIID, aInstancePtr);

   185     if (NS_FAILED(status))

   186         *aInstancePtr = 0;

   187     if ( mErrorPtr )

   188         *mErrorPtr = status;

   189     return status;

   190 }

   192 nsresult

   193 nsCreateInstanceFromFactory::operator()( const nsIID& aIID, void** aInstancePtr ) const

   194 {

   195     nsresult status = mFactory->CreateInstance(mOuter, aIID, aInstancePtr);

   196     if ( NS_FAILED(status) )

   197         *aInstancePtr = 0;

   198     if ( mErrorPtr )

   199         *mErrorPtr = status;

   200     return status;

   201 }

   204 nsresult

   205 nsGetClassObjectByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const

   206 {

   207     nsresult status = CallGetClassObject(mCID, aIID, aInstancePtr);

   208     if ( NS_FAILED(status) )

   209         *aInstancePtr = 0;

   210     if ( mErrorPtr )

   211         *mErrorPtr = status;

   212     return status;

   213 }

   215 nsresult

   216 nsGetClassObjectByContractID::operator()( const nsIID& aIID, void** aInstancePtr ) const

   217 {

   218     nsresult status = CallGetClassObject(mContractID, aIID, aInstancePtr);

   219     if ( NS_FAILED(status) )

   220         *aInstancePtr = 0;

   221     if ( mErrorPtr )

   222         *mErrorPtr = status;

   223     return status;

   224 }

   227 nsresult

   228 nsGetServiceByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const

   229 {

   230     nsresult status = CallGetService(mCID, aIID, aInstancePtr);

   231     if ( NS_FAILED(status) )

   232         *aInstancePtr = 0;

   234     return status;

   235 }

   237 nsresult

   238 nsGetServiceByCIDWithError::operator()( const nsIID& aIID, void** aInstancePtr ) const

   239 {

   240     nsresult status = CallGetService(mCID, aIID, aInstancePtr);

   241     if ( NS_FAILED(status) )

   242         *aInstancePtr = 0;

   244     if ( mErrorPtr )

   245         *mErrorPtr = status;

   246     return status;

   247 }

   249 nsresult

   250 nsGetServiceByContractID::operator()( const nsIID& aIID, void** aInstancePtr ) const

   251 {

   252     nsresult status = CallGetService(mContractID, aIID, aInstancePtr);

   253     if ( NS_FAILED(status) )

   254         *aInstancePtr = 0;

   256     return status;

   257 }

   259 nsresult

   260 nsGetServiceByContractIDWithError::operator()( const nsIID& aIID, void** aInstancePtr ) const

   261 {

   262     nsresult status = CallGetService(mContractID, aIID, aInstancePtr);

   263     if ( NS_FAILED(status) )

   264         *aInstancePtr = 0;

   266     if ( mErrorPtr )

   267         *mErrorPtr = status;

   268     return status;

   269 }

The Tor Browser / file revision

xpcom/glue/nsComponentManagerUtils.cpp@129ffea94266

xpcom/glue/nsComponentManagerUtils.cpp