From 16f504a9dca3fe3b70568f67b7d41241ae485288 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 18:49:04 +0200 Subject: Adding upstream version 7.0.6-dfsg. Signed-off-by: Daniel Baumann --- src/libs/xpcom18a4/xpcom/glue/nsWeakReference.cpp | 169 ++++++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 src/libs/xpcom18a4/xpcom/glue/nsWeakReference.cpp (limited to 'src/libs/xpcom18a4/xpcom/glue/nsWeakReference.cpp') diff --git a/src/libs/xpcom18a4/xpcom/glue/nsWeakReference.cpp b/src/libs/xpcom18a4/xpcom/glue/nsWeakReference.cpp new file mode 100644 index 00000000..76d9f593 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/glue/nsWeakReference.cpp @@ -0,0 +1,169 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Mozilla browser. + * + * The Initial Developer of the Original Code is + * Netscape Communications, Inc. + * Portions created by the Initial Developer are Copyright (C) 1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Scott Collins + * Pierre Phaneuf + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +// nsWeakReference.cpp + +#include "nsWeakReference.h" +#include "nsCOMPtr.h" + +nsresult +nsQueryReferent::operator()( const nsIID& aIID, void** answer ) const + { + nsresult status; + if ( mWeakPtr ) + { + if ( NS_FAILED(status = mWeakPtr->QueryReferent(aIID, answer)) ) + *answer = 0; + } + else + status = NS_ERROR_NULL_POINTER; + + if ( mErrorPtr ) + *mErrorPtr = status; + return status; + } + +nsresult +nsGetWeakReference::operator()( const nsIID&, void** aResult ) const + { + nsresult status; + // nsIWeakReference** result = &NS_STATIC_CAST(nsIWeakReference*, *aResult); + *aResult = 0; + + if ( mRawPtr ) + { + nsCOMPtr factoryPtr = do_QueryInterface(mRawPtr, &status); + NS_ASSERTION(factoryPtr, "Oops! You're asking for a weak reference to an object that doesn't support that."); + if ( factoryPtr ) + { + nsIWeakReference* temp; + status = factoryPtr->GetWeakReference(&temp); + *aResult = temp; + } + // else, |status| has already been set by |do_QueryInterface| + } + else + status = NS_ERROR_NULL_POINTER; + + if ( mErrorPtr ) + *mErrorPtr = status; + return status; + } + + +NS_COM nsIWeakReference* // or else |already_AddRefed| +NS_GetWeakReference( nsISupports* aInstancePtr, nsresult* aErrorPtr ) + { + void* result = 0; + nsGetWeakReference(aInstancePtr, aErrorPtr)(NS_GET_IID(nsIWeakReference), &result); + return NS_STATIC_CAST(nsIWeakReference*, result); + } + +NS_COM nsresult +nsSupportsWeakReference::GetWeakReference( nsIWeakReference** aInstancePtr ) + { + if ( !aInstancePtr ) + return NS_ERROR_NULL_POINTER; + + if ( !mProxy ) + mProxy = new nsWeakReference(this); + *aInstancePtr = mProxy; + + nsresult status; + if ( !*aInstancePtr ) + status = NS_ERROR_OUT_OF_MEMORY; + else + { + NS_ADDREF(*aInstancePtr); + status = NS_OK; + } + + return status; + } + +NS_IMETHODIMP_(nsrefcnt) +nsWeakReference::AddRef() + { + return ++mRefCount; + } + +NS_IMETHODIMP_(nsrefcnt) +nsWeakReference::Release() + { + nsrefcnt temp = --mRefCount; + if ( !mRefCount ) + delete this; + return temp; + } + +NS_IMETHODIMP +nsWeakReference::QueryInterface( const nsIID& aIID, void** aInstancePtr ) + { + NS_ASSERTION(aInstancePtr, "QueryInterface requires a non-NULL destination!"); + + if ( !aInstancePtr ) + return NS_ERROR_NULL_POINTER; + + nsISupports* foundInterface; + if ( aIID.Equals(NS_GET_IID(nsIWeakReference)) ) + foundInterface = NS_STATIC_CAST(nsIWeakReference*, this); + else if ( aIID.Equals(NS_GET_IID(nsISupports)) ) + foundInterface = NS_STATIC_CAST(nsISupports*, this); + else + foundInterface = 0; + + nsresult status; + if ( !foundInterface ) + status = NS_NOINTERFACE; + else + { + NS_ADDREF(foundInterface); + status = NS_OK; + } + + *aInstancePtr = foundInterface; + return status; + } + +NS_IMETHODIMP +nsWeakReference::QueryReferent( const nsIID& aIID, void** aInstancePtr ) + { + return mReferent ? mReferent->QueryInterface(aIID, aInstancePtr) : NS_ERROR_NULL_POINTER; + } -- cgit v1.2.3