зеркало из https://github.com/mozilla/pjs.git
6087 строки
184 KiB
Plaintext
6087 строки
184 KiB
Plaintext
# ***** 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 types.dat, released
|
|
# Nov 27, 2000.
|
|
#
|
|
# The Initial Developer of the Original Code is
|
|
# Netscape Communications Corporation.
|
|
# Portions created by the Initial Developer are Copyright (C) 2000
|
|
# the Initial Developer. All Rights Reserved.
|
|
#
|
|
# Contributor(s):
|
|
# Chris Waterson <waterson@netscape.com>
|
|
#
|
|
# Alternatively, the contents of this file may be used under the terms of
|
|
# either 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 *****
|
|
|
|
# This file contains type inference information that is intended to be
|
|
# used with TraceMalloc.pm. The format of the file is:
|
|
#
|
|
# <InferredType>
|
|
# Stack1
|
|
# Stack2
|
|
# ...
|
|
# StackN
|
|
#
|
|
# Where Stack1...StackN imply that the object's type is
|
|
# InferredType. Note that in many cases, we'll ``roll up'' storage
|
|
# that's part of an object's implementation into the object itself.
|
|
|
|
# Here's a handy regexp for cleaning up strings copied from the
|
|
# uncategorized file:
|
|
#
|
|
# \(^ *([0-9]+) \|\[.*\]$\)
|
|
#
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsStringRecycler>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsDeque::GrowCapacity(void)
|
|
nsDeque::Push(void *)
|
|
nsStringRecycler::Recycle(nsString *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# AtomImpl
|
|
#
|
|
|
|
# Give AtomImpl objects the memory they allocate for storage
|
|
<AtomImpl>
|
|
__builtin_new
|
|
AtomImpl::operator new(unsigned int, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
# Give AtomImpl objects the memory allocated for their table
|
|
<AtomImpl>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
NS_NewPermanentAtom(char const *)
|
|
NS_NewAtom(nsAString const &)
|
|
|
|
<AtomImpl>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
NS_NewAtom(nsAString const &)
|
|
NS_NewAtom(char const *)
|
|
|
|
<AtomImpl>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
NS_NewAtom(nsAString const &)
|
|
NS_NewAtom(unsigned short const *)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsCSSSelector>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::nsString(nsString const &)
|
|
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
|
|
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)
|
|
|
|
<nsCSSSelector>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::nsString(nsString const &)
|
|
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
|
|
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
|
|
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)
|
|
|
|
<nsCSSRule>
|
|
__builtin_new
|
|
nsCSSRule::operator new(unsigned int)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# CSSLoaderImpl
|
|
#
|
|
|
|
<CSSLoaderImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
CSSLoaderImpl::CSSLoaderImpl(void)
|
|
|
|
<CSSLoaderImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::AppendWithConversion(char const *, int)
|
|
nsString::AssignWithConversion(char const *)
|
|
CSSLoaderImpl::SetCharset(nsString const &)
|
|
|
|
<CSSLoaderImpl>
|
|
PL_strdup
|
|
URLKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
CSSLoaderImpl::SheetComplete(nsICSSStyleSheet *, SheetLoadData *)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<CSSNameSpaceRuleImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
CSSNameSpaceRuleImpl::SetURLSpec(nsString const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsFont
|
|
#
|
|
|
|
<nsFont>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::nsString(nsString const &)
|
|
nsFont::nsFont(nsFont const &)
|
|
|
|
<nsFont>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::AppendWithConversion(char const *, int)
|
|
nsString::AssignWithConversion(char const *)
|
|
nsFont::nsFont(char const *, unsigned char, unsigned char, unsigned short, unsigned char, int, float)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<CSSImportantRule>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
CSSImportRuleImpl::SetURLSpec(nsString const &)
|
|
|
|
<nsClassList>
|
|
__builtin_new
|
|
nsClassList::ParseClasses(nsClassList **, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsLocalFile
|
|
#
|
|
|
|
<nsLocalFile>
|
|
__builtin_new
|
|
nsLocalFile::Clone(nsIFile **)
|
|
|
|
<nsLocalFile>
|
|
PR_Malloc
|
|
_PR_Getfd
|
|
PR_GetConnectStatus
|
|
PR_OpenFile
|
|
PR_Open
|
|
nsLocalFile::OpenNSPRFileDesc(int, int, PRFileDesc **)
|
|
|
|
<nsLocalFile>
|
|
PR_Calloc
|
|
PR_LoadLibrary
|
|
PR_LoadLibraryWithFlags
|
|
PR_LoadLibrary
|
|
nsLocalFile::Load(PRLibrary **)
|
|
|
|
<nsLocalFile>
|
|
__strdup
|
|
PR_LoadLibrary
|
|
PR_LoadLibraryWithFlags
|
|
PR_LoadLibrary
|
|
nsLocalFile::Load(PRLibrary **)
|
|
|
|
<nsLocalFile>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsACString const &)
|
|
nsLocalFile::AppendRelativePath(char const *)
|
|
|
|
<nsLocalFile>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Clone(void const *, unsigned int)
|
|
nsLocalFile::InitWithPath(char const *)
|
|
|
|
<nsLocalFile>
|
|
PL_strdup
|
|
nsLocalFile::ParseURL(char const *, char **, char **, char **, char **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsXULAttribute>
|
|
__builtin_new
|
|
nsXULAttribute::operator new(unsigned int)
|
|
|
|
<nsXULAttribute>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
|
|
ToNewUnicode(nsAString const &)
|
|
nsXULAttributeValue::SetValue(nsAString const &, int)
|
|
|
|
<nsXULAttribute::mValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsXULAttributeValue::SetValue(nsAString const &, int)
|
|
|
|
<nsXULAttributes>
|
|
__builtin_new
|
|
nsXULAttributes::Create(nsIContent *, nsXULAttributes **)
|
|
|
|
<nsXULAttributes>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
NS_NewAtom(nsAString const &)
|
|
NS_NewAtom(unsigned short const *)
|
|
nsClassList::ParseClasses(nsClassList **, nsAString const &)
|
|
nsXULAttributes::UpdateClassList(nsAString const &)
|
|
|
|
<nsXULElement>
|
|
__builtin_new
|
|
nsXULElement::Create(nsINodeInfo *, nsIContent **)
|
|
|
|
<nsXULElement>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsXULElement::EnsureSlots(void)
|
|
|
|
<nsXULElement>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsXULElement::AppendChildTo(nsIContent *, int, int)
|
|
|
|
<nsXULElement>
|
|
__builtin_new
|
|
nsXULElement::EnsureSlots(void)
|
|
|
|
<nsXULElement>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsXULElement::AppendChildTo(nsIContent *, int, int)
|
|
|
|
<nsXULElement>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsXULElement::EnsureSlots(void)
|
|
|
|
<nsXULElement>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsXULElement::AddBroadcastListener(nsAString const &, nsIDOMElement *)
|
|
|
|
<sscanf>
|
|
iconv_close
|
|
|
|
<sscanf>
|
|
tsearch
|
|
|
|
<CSSDeclarationImpl>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)
|
|
|
|
<CSSDeclarationImpl>
|
|
__builtin_new
|
|
CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)
|
|
|
|
<CSSDeclarationImpl>
|
|
__builtin_new
|
|
CSSDeclarationImpl::SetValueImportant(nsCSSProperty)
|
|
|
|
<CSSDeclarationImpl>
|
|
__builtin_new
|
|
CSSDeclarationImpl::operator new(unsigned int)
|
|
|
|
<CSSDeclarationImpl>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)
|
|
|
|
<nsVoidArray>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
|
|
<nsVoidArray>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsVoidArray::nsVoidArray(int)
|
|
|
|
<nsVoidArray>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsVoidArray::Compact(void)
|
|
|
|
<nsVoidArray>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsVoidArray::ReplaceElementAt(void *, int)
|
|
|
|
<nsGenericHTMLContainerElement>
|
|
__builtin_new
|
|
nsCheapVoidArray::SwitchToVector(void)
|
|
nsCheapVoidArray::AppendElement(void *)
|
|
nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int)
|
|
|
|
<nsGenericHTMLContainerElement>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::Compact(void)
|
|
nsAutoVoidArray::Compact(void)
|
|
nsCheapVoidArray::Compact(void)
|
|
nsGenericHTMLContainerElement::Compact(void)
|
|
|
|
<nsGenericHTMLContainerElement>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsCheapVoidArray::AppendElement(void *)
|
|
nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int, int)
|
|
|
|
<nsGenericHTMLContainerElement>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsCheapVoidArray::AppendElement(void *)
|
|
nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int, int)
|
|
|
|
<nsGenericAttribute>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
|
|
nsGenericAttribute::nsGenericAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsSupportsArray>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
|
|
<nsSupportsArray>
|
|
__builtin_new
|
|
nsSupportsArray::Create(nsISupports *, nsID const &, void **)
|
|
|
|
<nsZipArchive>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsZipArchive::BuildFileList(void)
|
|
|
|
<nsZipArchive>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)
|
|
|
|
<InMemoryDataSource>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
InMemoryDataSource::AllocTable(void *, unsigned int)
|
|
|
|
<InMemoryDataSource>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
|
|
<InMemoryDataSource>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
InMemoryDataSource::InMemoryDataSource(nsISupports *)
|
|
|
|
<InMemoryDataSource>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
InMemoryDataSource::AllocEntry(void *, void const *)
|
|
|
|
<InMemoryDataSource>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
Assertion::operator new(unsigned int, nsFixedSizeAllocator &)
|
|
|
|
<InMemoryDataSource>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
InMemoryDataSource::AllocEntry(void *, void const *)
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
InMemoryDataSource::SetReverseArcs(nsIRDFNode *, Assertion *)
|
|
|
|
<InMemoryDataSource>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
InMemoryDataSource::AllocEntry(void *, void const *)
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
InMemoryDataSource::SetForwardArcs(nsIRDFResource *, Assertion *)
|
|
|
|
<InMemoryDataSource>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
InMemoryDataSource::Init(void)
|
|
|
|
<RDFXMLDataSource>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsString::nsString(nsAString const &)
|
|
nsNameSpaceMap::Put(nsAString const &, nsIAtom *)
|
|
RDFXMLDataSourceImpl::AddNameSpace(nsIAtom *, nsString const &)
|
|
|
|
<xptiTypelibGuts>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
xptiTypelibGuts::xptiTypelibGuts(XPTHeader *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsFontMetricsGTK
|
|
#
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)
|
|
nsFontMetricsGTK::Init(nsFont const &, nsIAtom *, nsIDeviceContext *)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
nsCompressedCharMap::NewCCMap(void)
|
|
MapToCCMap(unsigned int *)
|
|
MapperToCCMap(nsICharRepresentable *)
|
|
nsFontMetricsGTK::GetFontHandle(void *&)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
|
|
nsFontMetricsGTK::QueryInterface(nsID const &, void **)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Calloc
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_vec_new
|
|
nsDrawingSurfaceGTK type_info function
|
|
nsFontMetricsGTK::Init(nsFont const &, nsIAtom *, nsIDeviceContext *)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontWeight::operator new(unsigned int)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontNode::operator new(unsigned int)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontStretch::operator new(unsigned int)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontStyle::operator new(unsigned int)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Realloc
|
|
PR_vsxprintf
|
|
PR_WaitForPollableEvent
|
|
PR_vsmprintf
|
|
PR_smprintf
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PR_vsxprintf
|
|
PR_WaitForPollableEvent
|
|
PR_WaitForPollableEvent
|
|
PR_WaitForPollableEvent
|
|
PR_vsmprintf
|
|
PR_smprintf
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Realloc
|
|
PR_vsxprintf
|
|
PR_WaitForPollableEvent
|
|
PR_WaitForPollableEvent
|
|
PR_WaitForPollableEvent
|
|
PR_vsmprintf
|
|
PR_smprintf
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Realloc
|
|
nsFontMetricsGTK::PickASizeAndLoad(nsFontStretch *, nsFontCharSetInfo *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsDrawingSurfaceGTK type_info function
|
|
nsFontMetricsGTK::Init(nsFont const &, nsIAtom *, nsIDeviceContext *)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsDrawingSurfaceGTK type_info function
|
|
nsFontMetricsGTK::Init(nsFont const &, nsIAtom *, nsIDeviceContext *)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontMetricsGTK::SearchNode
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PR_vsxprintf
|
|
PR_WaitForPollableEvent
|
|
PR_WaitForPollableEvent
|
|
PR_vsmprintf
|
|
PR_smprintf
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::TryNodes(nsACString &, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::TryNode(nsCString *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Realloc
|
|
nsFontMetricsGTK::AddToLoadedFontsList(nsFontGTK *)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Realloc
|
|
PR_vsxprintf
|
|
PR_WaitForPollableEvent
|
|
PR_WaitForPollableEvent
|
|
PR_vsmprintf
|
|
PR_smprintf
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::SearchNode(nsFontNode *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)
|
|
nsFontMetricsGTK::Init(nsFont const &, nsIAtom *, nsIDeviceContext *)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::TryNodes(nsACString &, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsFontMetricsGTK::TryNode(nsCString *, unsigned short)
|
|
|
|
<nsFontMetricsGTK>
|
|
__builtin_new
|
|
nsFontMetricsGTK::TryNodes(nsACString &, unsigned short)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsPluginTag
|
|
#
|
|
|
|
<nsPluginTag>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsPluginTag::nsPluginTag(nsPluginInfo *)
|
|
|
|
<nsPluginTag>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
new_str(char const *)
|
|
nsPluginTag::nsPluginTag(nsPluginInfo *)
|
|
|
|
<nsPluginTag>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsPluginTag::nsPluginTag(char const *, char const *, char const *, char const *, char const *const *, char const *const *, char const *const *, int, long long)
|
|
|
|
<nsPluginTag>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsPluginTag::nsPluginTag(nsPluginTag *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsXBLInsertionPoint
|
|
#
|
|
|
|
<nsXBLInsertionPoint>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsXBLInsertionPoint::AddChild(nsIContent *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsXBLBinding
|
|
#
|
|
|
|
<nsXBLBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)
|
|
|
|
<nsXBLBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)
|
|
|
|
<nsXBLBinding>
|
|
__builtin_new
|
|
nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)
|
|
|
|
<nsXBLBinding>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
NS_NewAtom(nsAString const &)
|
|
NS_NewAtom(char const *)
|
|
nsXBLBinding::nsXBLBinding(nsIXBLPrototypeBinding *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsXBLPrototypeBinding
|
|
#
|
|
|
|
<nsXBLPrototypeBinding>
|
|
__builtin_new
|
|
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
__builtin_new
|
|
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
js_LookupProperty
|
|
JS_DefinePropertyWithTinyId
|
|
JS_LookupProperty
|
|
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsCString const &, nsIContent *, nsIXBLDocumentInfo *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsXBLPrototypeBinding::nsXBLPrototypeBinding(basic_nsAReadableString<char> const &, nsIContent *, nsIXBLDocumentInfo *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
__builtin_new
|
|
nsISupportsKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
__builtin_new
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsACString const &, nsIXBLDocumentInfo *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AssignFromReadable(nsACString const &)
|
|
nsACString::AssignFromReadable(nsACString const &)
|
|
nsCString::nsCString(nsACString const &)
|
|
nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsACString const &, nsIXBLDocumentInfo *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsACString const &)
|
|
nsXBLJSClass::nsXBLJSClass(nsCString const &)
|
|
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLPrototypeBinding::ConstructInterfaceTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXBLPrototypeBinding::ConstructInterfaceTable(nsIContent *)
|
|
|
|
<nsXBLPrototypeBinding>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsXBLAttributeEntry::Create(nsIAtom *, nsIAtom *, nsIContent *)
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# <nsXBLPrototypeProperty>
|
|
#
|
|
|
|
<nsXBLPrototypeProperty>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const
|
|
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const
|
|
nsXBLPrototypeProperty::ParseProperty(nsIScriptContext *)
|
|
|
|
<nsXBLPrototypeProperty>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const
|
|
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const
|
|
nsXBLPrototypeProperty::ParseMethod(nsIScriptContext *)
|
|
|
|
<nsXBLPrototypeProperty>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const
|
|
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const
|
|
nsXBLPrototypeProperty::ParseField(nsIScriptContext *)
|
|
|
|
<nsXBLPrototypeProperty>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AppendFromReadable(nsAString const &)
|
|
nsAString::AppendFromReadable(nsAString const &)
|
|
nsXBLPrototypeProperty::ParseField(nsIScriptContext *)
|
|
|
|
<nsXBLPrototypeProperty>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AppendFromReadable(nsACString const &)
|
|
nsACString::do_AppendFromElementPtr(char const *)
|
|
nsXBLPrototypeBinding::GetBindingURI(nsCString &)
|
|
nsXBLPrototypeProperty::ConstructProperty(nsIContent *, nsIContent *)
|
|
|
|
<nsXBLPrototypeProperty>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
js_AddRootRT
|
|
JS_AddNamedRootRT
|
|
NS_NewXBLPrototypeBinding(nsACString const &, nsIContent *, nsIXBLDocumentInfo *, nsIXBLPrototypeBinding **)
|
|
nsXBLPrototypeProperty::ParseMethod(nsIScriptContext *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# The frame arena
|
|
#
|
|
|
|
<FrameArena>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
|
|
<PresShell>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocLeafNode(void)
|
|
nsDST::Insert(void *, void *, void **)
|
|
PresShell::SetSubShellFor(nsIContent *, nsISupports *)
|
|
|
|
<PresShell>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
PresShell::AppendReflowCommandInternal(nsIReflowCommand *, nsVoidArray &)
|
|
|
|
# The anonymous content table in the PresShell
|
|
<PresShell.mAnonymousContentTable>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)
|
|
|
|
<PresShell.mAnonymousContentTable>
|
|
__builtin_new
|
|
nsISupportsKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)
|
|
|
|
<PresShell.mAnonymousContentTable>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)
|
|
|
|
<PresShell.mAnonymousContentTable>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# StackArena
|
|
#
|
|
|
|
<StackArena>
|
|
PR_Malloc
|
|
StackArena::StackArena(void)
|
|
|
|
<StackArena>
|
|
PR_Malloc
|
|
StackArena::Allocate(unsigned int, void **)
|
|
|
|
<StackArena>
|
|
PR_Malloc
|
|
StackBlock::StackBlock(void)
|
|
StackArena::StackArena(void)
|
|
|
|
<StackArena>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
StackArena::StackArena(void)
|
|
|
|
<StackArena>
|
|
PR_Malloc
|
|
StackArena::Allocate(unsigned int, void **)
|
|
|
|
# The following will only show up if you turn off the FrameArena
|
|
<nsBoxLayoutState>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsBoxLayoutState::Allocate(unsigned int, nsIPresShell *)
|
|
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsFrameManager
|
|
#
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocLeafNode(void)
|
|
nsDST::LeafNode::operator new(unsigned int, nsDST::NodeArena *)
|
|
nsDST::Insert(void *, void *, void **)
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocTwoNode(void)
|
|
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
|
|
nsDST::Insert(void *, void *, void **)
|
|
FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocTwoNode(void)
|
|
nsDST::TwoNode::operator new(unsigned int, nsDST::NodeArena *)
|
|
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
|
|
nsDST::Insert(void *, void *, void **)
|
|
FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocTwoNode(void)
|
|
nsDST::TwoNode::operator new(unsigned int, nsDST::NodeArena *)
|
|
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
|
|
nsDST::Insert(void *, void *, void **)
|
|
FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
FrameHashTable::Put(void *, void *)
|
|
FrameManager::SetPlaceholderFrameFor(nsIFrame *, nsIFrame *)
|
|
|
|
<FrameManager>
|
|
__builtin_new
|
|
nsDST::NewMemoryArena(unsigned int)
|
|
FrameManager::Init(nsIPresShell *, nsIStyleSet *)
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocTwoNode(void)
|
|
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
|
|
nsDST::Insert(void *, void *, void **)
|
|
FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocLeafNode(void)
|
|
nsDST::Insert(void *, void *, void **)
|
|
FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))
|
|
|
|
<FrameManager>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsDST::NodeArena::AllocLeafNode(void)
|
|
nsDST::Insert(void *, void *, void **)
|
|
FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)
|
|
|
|
<UndisplayedMap>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
UndisplayedMap::AppendNodeFor(UndisplayedNode *, nsIContent *)
|
|
|
|
<UndisplayedMap>
|
|
__builtin_new
|
|
UndisplayedMap::AddNodeFor(nsIContent *, nsIContent *, nsIStyleContext *)
|
|
|
|
<UndisplayedMap>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_NewHashTable
|
|
UndisplayedMap::UndisplayedMap(unsigned int)
|
|
|
|
<PRLock>
|
|
PR_Calloc
|
|
PR_NewLock
|
|
|
|
<PRMonitor>
|
|
PR_Calloc
|
|
PR_NewMonitor
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# RDFServiceImpl
|
|
#
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_NewHashTable
|
|
RDFServiceImpl::Init(void)
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
nsRDFParserUtils::GetQuotedAttributeValue(nsString const &, nsString const &, nsString &)
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
RDFServiceImpl::RegisterResource(nsIRDFResource *, int)
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
RDFServiceImpl::RegisterLiteral(nsIRDFLiteral *, int)
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **)
|
|
PL_NewHashTable
|
|
RDFServiceImpl::Init(void)
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **)
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)
|
|
|
|
<RDFServiceImpl>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawRemove
|
|
RDFServiceImpl::UnregisterResource(nsIRDFResource *)
|
|
|
|
<RDFServiceImpl>
|
|
PL_strdup
|
|
RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsRDFResource>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsRDFResource::Init(char const *)
|
|
|
|
<nsHTMLImageLoader>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsString::operator=(nsString const &)
|
|
nsHTMLImageLoader::SetURL(nsString const &)
|
|
|
|
<nsHTMLEntities>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsHTMLEntities::AddRefTable(void)
|
|
|
|
<nsHTMLEntities>
|
|
__builtin_new
|
|
nsAVLTree::AddItem(void *)
|
|
nsHTMLEntities::AddRefTable(void)
|
|
|
|
<nsStaticCaseInsensitiveNameTable>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsStaticCaseInsensitiveNameTable::Init(char const **, int)
|
|
|
|
<CNavDTD>
|
|
__builtin_new
|
|
CNavDTD::CNavDTD(void)
|
|
|
|
<CNavDTD>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
InitializeElementTable(void)
|
|
CNavDTD::CNavDTD(void)
|
|
|
|
<CNavDTD>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsDeque::GrowCapacity(void)
|
|
nsDeque::Push(void *)
|
|
CNodeRecycler::RecycleNode(nsCParserNode *)
|
|
CNavDTD::CloseContainersTo(int, nsHTMLTag, int)
|
|
|
|
<COtherDTD>
|
|
__builtin_new
|
|
COtherDTD::COtherDTD(void)
|
|
|
|
<nsScanner>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsScanner::Append(char const *, unsigned int)
|
|
|
|
<nsScanner>
|
|
__builtin_new
|
|
nsSlidingString::AppendBuffer(unsigned short *, unsigned short *, unsigned short *)
|
|
nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *)
|
|
|
|
<nsScanner>
|
|
__builtin_new
|
|
nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *)
|
|
|
|
<nsScanner>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<unsigned short, unsigned short>(basic_nsAReadableString<unsigned short> const &, unsigned short *)
|
|
ToNewUnicode(basic_nsAReadableString<unsigned short> const &)
|
|
nsScanner::Append(basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsScanner>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
CopyUnicodeTo(nsReadingIterator<unsigned short> const &, nsReadingIterator<unsigned short> const &, basic_nsAWritableString<unsigned short> &)
|
|
nsScanner::CopyUnusedData(nsString &)
|
|
|
|
<nsScanner>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::nsString(nsString const &)
|
|
nsScanner::nsScanner(nsString &, int, nsString const &, nsCharsetSource)
|
|
|
|
<nsHTMLTokenizer>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsDeque::GrowCapacity(void)
|
|
nsDeque::Push(void *)
|
|
nsHTMLTokenizer::ScanDocStructure(int)
|
|
|
|
<nsHTMLTokenizer>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsDeque::GrowCapacity(void)
|
|
nsDeque::Push(void *)
|
|
nsHTMLTokenizer::AddToken(CToken *&, unsigned int, nsDeque *, nsTokenAllocator *)
|
|
|
|
<nsTokenAllocator>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
CToken::operator new(unsigned int, nsFixedSizeAllocator &)
|
|
nsTokenAllocator::CreateTokenOfType(eHTMLTokenTypes, nsHTMLTag)
|
|
|
|
<nsNodeAllocator>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsNodeAllocator::nsNodeAllocator(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# xptiWorkingSet
|
|
#
|
|
|
|
<xptiWorkingSet>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
xptiWorkingSet::NewFileArray(unsigned int)
|
|
|
|
<xptiWorkingSet>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
xptiWorkingSet::ExtendFileArray(unsigned int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<HTMLContentSink>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
HTMLContentSink::OnStreamComplete(nsIStreamLoader *, nsISupports *, unsigned int, unsigned int, char const *)
|
|
|
|
<HTMLContentSink>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::nsString(nsString const &)
|
|
HTMLContentSink::SetTitle(nsString const &)
|
|
|
|
<DeviceContextImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
DeviceContextImpl::DeviceContextImpl(void)
|
|
|
|
<DeviceContextImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
DeviceContextImpl::CreateFontAliasTable(void)
|
|
|
|
<DeviceContextImpl>
|
|
__builtin_new
|
|
FontAliasKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
DeviceContextImpl::AliasFont(nsString const &, nsString const &, nsString const &, int)
|
|
|
|
<nsCompressedMap>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsCompressedMap::nsCompressedMap(unsigned short *, unsigned int)
|
|
|
|
<nsHTMLDocument>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsHTMLDocument::nsHTMLDocument(void)
|
|
|
|
<nsHTMLDocument>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsHTMLDocument::nsHTMLDocument(void)
|
|
|
|
<nsHTMLDocument>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsHTMLDocument::InvalidateHashTables(void)
|
|
|
|
<nsHTMLDocument.mReferrer>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
|
|
nsHTMLDocument::SetReferrer(basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsHTMLDocument.mLastModified>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
|
|
nsHTMLDocument::SetLastModified(basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsHTMLDocument.mTitle>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
|
|
nsHTMLDocument::SetTitle(basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsDOMDocumentType>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsString::nsString(nsAString const &)
|
|
nsDOMDocumentType::nsDOMDocumentType(nsAString const &, nsIDOMNamedNodeMap *, nsIDOMNamedNodeMap *, nsAString const &, nsAString const &, nsAString const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# XPC stuff
|
|
#
|
|
|
|
<Native2WrappedNativeMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
Native2WrappedNativeMap::Native2WrappedNativeMap(int)
|
|
|
|
<ClassInfo2WrappedNativeProtoMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int)
|
|
|
|
<IID2NativeInterfaceMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
IID2NativeInterfaceMap::IID2NativeInterfaceMap(int)
|
|
|
|
<IID2WrappedJSClassMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
IID2WrappedJSClassMap::IID2WrappedJSClassMap(int)
|
|
|
|
<IID2ThisTranslatorMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
IID2ThisTranslatorMap::IID2ThisTranslatorMap(int)
|
|
|
|
<XPCNativeScriptableSharedMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int)
|
|
|
|
<XPCNativeScriptableSharedMap>
|
|
__builtin_new
|
|
XPCNativeScriptableSharedMap::GetNewOrUsed(unsigned int, char *, XPCNativeScriptableInfo *)
|
|
|
|
<JSContext2XPCContextMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
JSContext2XPCContextMap::JSContext2XPCContextMap(int)
|
|
|
|
<NativeSetMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
NativeSetMap::NativeSetMap(int)
|
|
|
|
<JSObject2WrappedJSMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
JSObject2WrappedJSMap::JSObject2WrappedJSMap(int)
|
|
|
|
<nsXPCWrappedJS>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
nsXPCWrappedJS::GetNewOrUsed(XPCCallContext &, JSObject *, nsID const &, nsISupports *, nsXPCWrappedJS **)
|
|
|
|
<XPCWrappedNativeProtoMap>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int)
|
|
|
|
<XPCWrappedNativeProto>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)
|
|
|
|
<XPCWrappedNativeProto>
|
|
__builtin_new
|
|
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)
|
|
|
|
<XPCWrappedNativeProto>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
XPCNativeSet::NewInstance(XPCCallContext &, XPCNativeInterface **, unsigned short)
|
|
XPCNativeSet::GetNewOrUsed(XPCCallContext &, nsIClassInfo *)
|
|
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)
|
|
|
|
<XPCWrappedNativeProto>
|
|
__builtin_new
|
|
XPCNativeScriptableInfo::Construct(XPCCallContext &, XPCNativeScriptableCreateInfo const *)
|
|
XPCWrappedNativeProto::Init(XPCCallContext &, XPCNativeScriptableCreateInfo const *)
|
|
|
|
<XPCWrappedNativeProto>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
XPCNativeSet::GetNewOrUsed(XPCCallContext &, nsIClassInfo *)
|
|
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)
|
|
|
|
<XPCWrappedNative>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
XPCWrappedNative::~XPCWrappedNative(void)
|
|
|
|
<XPCWrappedNative>
|
|
__builtin_new
|
|
XPCWrappedNative::FindTearOff(XPCCallContext &, XPCNativeInterface *, int, unsigned int *)
|
|
|
|
<XPCWrappedNative>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
XPCWrappedNative::GetNewOrUsed(XPCCallContext &, nsISupports *, XPCWrappedNativeScope *, XPCNativeInterface *, XPCWrappedNative **)
|
|
|
|
<XPCWrappedNativeScope>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableInit
|
|
JS_NewDHashTable
|
|
js_LookupProperty
|
|
js_GetProperty
|
|
XPCWrappedNativeScope::SetGlobal(XPCCallContext &, JSObject *)
|
|
|
|
<nsXPCWrappedNativeClass>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsXPCWrappedNativeClass::BuildMemberDescriptors(XPCContext *)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsNetModuleMgr>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsNetModRegEntry::nsNetModRegEntry(char const *, nsINetNotify *, unsigned int *)
|
|
nsNetModuleMgr::RegisterModule(char const *, nsINetNotify *)
|
|
|
|
<nsProxyObjectManager>
|
|
__builtin_new
|
|
nsProxyObjectManager::nsProxyObjectManager(void)
|
|
|
|
<nsProxyObjectManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsProxyObjectManager::nsProxyObjectManager(void)
|
|
|
|
<nsProxyEventClass>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)
|
|
|
|
<nsProxyEventClass>
|
|
__builtin_new
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)
|
|
|
|
<nsProxyEventClass>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)
|
|
|
|
<nsProxyEventObject>
|
|
__builtin_new
|
|
nsProxyEventKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &)
|
|
|
|
<nsProxyEventObject>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsComponentManagerImpl
|
|
#
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::Init(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::GetServiceByContractID(char const *, nsID const &, void **)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::GetService(nsID const &, nsID const &, void **)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsComponentManagerImpl::Init(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_vec_new
|
|
nsComponentManagerImpl::Init(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::HashContractID(char const *, nsID const &)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsComponentManagerImpl::Init(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsComponentManagerImpl::GetLoaderForType(char const *, nsIComponentLoader **)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)
|
|
|
|
<nsComponentManagerImpl>
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
bufio_SetBufferSize
|
|
nsXPTCStubBase::Sentinel9(void)
|
|
NR_RegSetBufferSize
|
|
nsRegistry::SetBufferSize(int)
|
|
nsComponentManagerImpl::AutoRegister(int, nsIFile *)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::HashContractID(char const *, nsID const &)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::HashContractID(char const *, nsID const &)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::GetService(char const *, nsID const &, nsISupports **, nsIShutdownListener *)
|
|
|
|
<nsComponentManagerImpl>
|
|
__builtin_new
|
|
nsComponentManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)
|
|
|
|
<nsComponentManagerImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AssignFromReadable(nsACString const &)
|
|
nsACString::do_AssignFromElementPtr(char const *)
|
|
nsCString::nsCString(char const *)
|
|
nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int)
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
PL_strdup
|
|
nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)
|
|
|
|
<nsComponentManagerImpl>
|
|
PL_strdup
|
|
nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int)
|
|
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)
|
|
|
|
<nsComponentManagerImpl>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
nsComponentManagerImpl::Init(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsZipArchive>
|
|
__builtin_new
|
|
nsZipArchive::BuildFileList(void)
|
|
|
|
<nsStaticCaseInsensitiveNameTable>
|
|
__builtin_new
|
|
nsStaticCaseInsensitiveNameTable::Init(char const **, int)
|
|
|
|
<nsStaticCaseInsensitiveNameTable>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsStaticCaseInsensitiveNameTable::Init(char const **, int)
|
|
|
|
<nsStaticCaseInsensitiveNameTable>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsStaticCaseInsensitiveNameTable::Init(char const **, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsDrawingSurfaceGTK
|
|
#
|
|
|
|
<nsDrawingSurfaceGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)
|
|
|
|
<nsDrawingSurfaceGTK>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)
|
|
|
|
<nsDrawingSurfaceGTK>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsDrawingSurfaceGTK type_info function
|
|
|
|
<nsDrawingSurfaceGTK>
|
|
PR_Malloc
|
|
nsCompressedCharMap::NewCCMap(void)
|
|
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsNativeComponentLoader
|
|
#
|
|
|
|
<nsNativeComponentLoader>
|
|
__builtin_new
|
|
nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *)
|
|
|
|
<nsNativeComponentLoader>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *)
|
|
|
|
<nsNativeComponentLoader>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsNativeComponentLoader::CreateDll
|
|
|
|
<nsNativeComponentLoader>
|
|
__builtin_new
|
|
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)
|
|
|
|
<nsNativeComponentLoader>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)
|
|
|
|
<nsNativeComponentLoader>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)
|
|
|
|
<nsNativeComponentLoader>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)
|
|
|
|
<nsNativeComponentLoader>
|
|
PL_strdup
|
|
nsDll::nsDll(nsIFile *, char const *, long long *, long long *)
|
|
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsDirectoryService>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsDirectoryService::Set(char const *, nsISupports *)
|
|
|
|
<nsDirectoryService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsDirectoryService::Init(void)
|
|
|
|
<nsDirectoryService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsDirectoryService::Set(char const *, nsISupports *)
|
|
|
|
<nsDirectoryService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsDirectoryService::Init(char const *)
|
|
|
|
<nsDirectoryService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsDirectoryService::Init(void)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsResProtocolHandler
|
|
#
|
|
|
|
<nsResProtocolHandler>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsResProtocolHandler::AppendSubstitution(char const *, char const *)
|
|
|
|
<nsResProtocolHandler>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsResProtocolHandler::nsResProtocolHandler(void)
|
|
|
|
<nsResProtocolHandler>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsResProtocolHandler::AppendSubstitution(char const *, char const *)
|
|
|
|
<nsResProtocolHandler>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsResProtocolHandler::SetSubstitution(char const *, nsIURI *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsChromeRegistry
|
|
#
|
|
|
|
<nsChromeRegistry>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)
|
|
|
|
<nsChromeRegistry>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)
|
|
|
|
<nsChromeRegistry>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)
|
|
|
|
<nsChromeRegistry>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsACString const &)
|
|
nsStdURL::GetSpec(char **)
|
|
RDFXMLDataSourceImpl::Init(char const *)
|
|
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)
|
|
|
|
<nsChromeRegistry>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsZipReaderCache>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)
|
|
|
|
<nsZipReaderCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)
|
|
|
|
<nsZipReaderCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsZipReaderCache::nsZipReaderCache(void)
|
|
|
|
<nsZipReaderCache>
|
|
__builtin_new
|
|
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsXBLDocumentInfo
|
|
#
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
__builtin_new
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
__builtin_new
|
|
nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<char>::Assign(char const *)
|
|
nsCString::operator=(char const *)
|
|
nsXBLDocumentInfo::nsXBLDocumentInfo(char const *, nsIDocument *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AssignFromReadable(nsACString const &)
|
|
nsACString::do_AssignFromElementPtr(char const *)
|
|
nsXBLDocumentInfo::nsXBLDocumentInfo(char const *, nsIDocument *)
|
|
|
|
<nsXBLDocumentInfo>
|
|
__builtin_new
|
|
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsXULPrototypeCache
|
|
#
|
|
|
|
<nsXULPrototypeCache>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULPrototypeCache::PutXBLDocumentInfo(nsIXBLDocumentInfo *)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULPrototypeCache::PutPrototype(nsIXULPrototypeDocument *)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXULPrototypeCache::nsXULPrototypeCache(void)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULPrototypeCache::PutXBLDocumentInfo(nsIXBLDocumentInfo *)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULPrototypeCache::PutStyleSheet(nsICSSStyleSheet *)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsXULPrototypeCache::nsXULPrototypeCache(void)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULPrototypeCache::PutXBLDocumentInfo(nsIXBLDocumentInfo *)
|
|
|
|
<nsXULPrototypeCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsXULPrototypeCache::PutScript(nsIURI *, void *)
|
|
|
|
# nsXULPrototypeElement
|
|
<nsXULPrototypeCache>
|
|
__builtin_new
|
|
XULContentSinkImpl::CreateElement(nsINodeInfo *, nsXULPrototypeElement **)
|
|
|
|
# nsXULPrototypeNode
|
|
<nsXULPrototypeCache>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
XULContentSinkImpl::CloseContainer(nsIParserNode const &)
|
|
|
|
# nsXULPrototypeScript
|
|
<nsXULPrototypeCache>
|
|
__builtin_new
|
|
XULContentSinkImpl::OpenScript(nsIParserNode const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsExternalHelperAppService
|
|
#
|
|
|
|
<nsExternalHelperAppService>
|
|
__builtin_new
|
|
nsExternalHelperAppService::nsExternalHelperAppService(void)
|
|
|
|
<nsExternalHelperAppService>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)
|
|
|
|
<nsExternalHelperAppService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)
|
|
|
|
<nsExternalHelperAppService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)
|
|
|
|
<nsExternalHelperAppService>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)
|
|
|
|
<nsExternalHelperAppService>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
|
|
nsMIMEInfoImpl::SetFileExtensions(char const *)
|
|
nsExternalHelperAppService::AddDefaultMimeTypesToCache(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsCategoryManager
|
|
#
|
|
|
|
<nsCategoryManager>
|
|
__builtin_new
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
|
|
CategoryNode::CategoryNode(void)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
|
|
nsCategoryManager::nsCategoryManager(void)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
|
|
CategoryNode::CategoryNode(void)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
|
|
nsCategoryManager::nsCategoryManager(void)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
<nsCategoryManager>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AssignFromReadable(nsACString const &)
|
|
nsACString::do_AssignFromElementPtr(char const *)
|
|
nsCString::nsCString(char const *)
|
|
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsScriptNameSpaceManager
|
|
#
|
|
|
|
<nsScriptNameSpaceManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsScriptNameSpaceManager::RegisterClassName(char const *, int)
|
|
|
|
<nsScriptNameSpaceManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsScriptNameSpaceManager::FillHashWithDOMInterfaces(void)
|
|
|
|
<nsScriptNameSpaceManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsScriptNameSpaceManager::FillHash(nsICategoryManager *, char const *, nsGlobalNameStruct::nametype)
|
|
|
|
<nsScriptNameSpaceManager>
|
|
__builtin_new
|
|
nsScriptNameSpaceManager::RegisterClassName(char const *, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsScriptSecurityManager
|
|
#
|
|
|
|
<nsScriptSecurityManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsScriptSecurityManager::InitPolicies(unsigned int, char const **, nsISecurityPref *)
|
|
|
|
<nsScriptSecurityManager>
|
|
__builtin_new
|
|
nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)
|
|
|
|
<nsScriptSecurityManager>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)
|
|
|
|
<nsScriptSecurityManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsScriptSecurityManager::InitPrefs(void)
|
|
|
|
<nsScriptSecurityManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
|
|
nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)
|
|
|
|
<nsScriptSecurityManager>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsScriptSecurityManager::InitPolicies(unsigned int, char const **, nsISecurityPref *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsStringBundleService
|
|
#
|
|
|
|
<nsStringBundleService>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)
|
|
|
|
<nsStringBundleService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)
|
|
|
|
<nsStringBundleService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsStringBundleService::nsStringBundleService(void)
|
|
|
|
<nsStringBundleService>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)
|
|
|
|
<nsStringBundleService>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<CSSStyleSheetImpl>
|
|
__builtin_new
|
|
CSSStyleSheetImpl::CSSStyleSheetImpl(void)
|
|
|
|
<CSSStyleSheetImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
CSSStyleSheetImpl::AppendStyleRule(nsICSSRule *)
|
|
|
|
<CSSStyleSheetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)
|
|
|
|
<CSSStyleSheetImpl>
|
|
__builtin_new
|
|
AtomKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)
|
|
|
|
<CSSStyleSheetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)
|
|
|
|
<CSSStyleSheetInner>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
CSSStyleSheetInner::CSSStyleSheetInner(nsICSSStyleSheet *)
|
|
|
|
<HTMLStyleSheetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
HTMLStyleSheetImpl::HTMLStyleSheetImpl(void)
|
|
|
|
<HTMLStyleSheetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawRemove
|
|
nsHashtable::Remove(nsHashKey *)
|
|
HTMLStyleSheetImpl::DropMappedAttributes(nsIHTMLMappedAttributes *)
|
|
|
|
<HTMLStyleSheetImpl>
|
|
__builtin_new
|
|
AttributeKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&)
|
|
|
|
<HTMLStyleSheetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&)
|
|
|
|
<nsStyleContextData>
|
|
__builtin_new
|
|
nsStyleContextData::Create(nsIPresContext *)
|
|
|
|
<nsStyleContent>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsStyleContent::AllocateCounterResets(unsigned int)
|
|
|
|
<nsStyleContent>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsStyleContent::AllocateContents(unsigned int)
|
|
|
|
<xptiManifest>
|
|
__builtin_new
|
|
xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *)
|
|
|
|
<xptiManifest>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *)
|
|
|
|
<CSSParserImpl>
|
|
__builtin_new
|
|
SelectorList::AddSelector(nsCSSSelector const &)
|
|
CSSParserImpl::ParseSelectorGroup(int &, SelectorList *&)
|
|
|
|
<CSSParserImpl>
|
|
__builtin_new
|
|
CSSParserImpl::ParseContent(int &, nsICSSDeclaration *, int &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# RuleHash
|
|
#
|
|
|
|
<RuleHash>
|
|
__builtin_new
|
|
RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *)
|
|
|
|
<RuleHash>
|
|
__builtin_new
|
|
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)
|
|
|
|
<RuleHash>
|
|
__builtin_new
|
|
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int)
|
|
|
|
<RuleHash>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *)
|
|
|
|
<RuleHash>
|
|
__builtin_new
|
|
AtomKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)
|
|
|
|
<RuleHash>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
RuleHash::RuleHash(void)
|
|
|
|
<RuleHash>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)
|
|
|
|
<RuleHash>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
RuleHash::EnumerateAllRules(nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *)
|
|
|
|
<RuleHash>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsCSSSelector
|
|
#
|
|
|
|
<nsCSSSelector>
|
|
__builtin_new
|
|
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)
|
|
|
|
<nsCSSSelector>
|
|
__builtin_new
|
|
nsAtomList::nsAtomList(nsAtomList const &)
|
|
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)
|
|
|
|
<nsCSSSelector>
|
|
__builtin_new
|
|
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
|
|
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)
|
|
|
|
<nsCSSSelector>
|
|
__builtin_new
|
|
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
|
|
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
|
|
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# StyleSetImpl
|
|
#
|
|
|
|
<StyleSetImpl>
|
|
__builtin_new
|
|
CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *)
|
|
StyleSetImpl::ClearOverrideRuleProcessors(void)
|
|
|
|
<StyleSetImpl>
|
|
__builtin_new
|
|
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
|
|
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)
|
|
StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)
|
|
|
|
<StyleSetImpl>
|
|
__builtin_new
|
|
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
|
|
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)
|
|
StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)
|
|
|
|
<StyleSetImpl>
|
|
__builtin_new
|
|
nsSupportsArray::Create(nsISupports *, nsID const &, void **)
|
|
NS_NewISupportsArray(nsISupportsArray **)
|
|
StyleSetImpl::EnsureArray(nsISupportsArray **)
|
|
|
|
<StyleSetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
|
|
nsRuleWalker::Forward(nsIStyleRule *)
|
|
StyleSetImpl::AddImportantRules(nsIRuleNode *)
|
|
|
|
<StyleSetImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
|
|
nsRuleWalker::Forward(nsIStyleRule *)
|
|
nsHTMLBodyElement::WalkInlineStyleRules(nsIRuleWalker *)
|
|
HTMLCSSStyleSheetImpl::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)
|
|
StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)
|
|
|
|
<StyleSetImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
|
|
nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)
|
|
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
|
|
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
|
|
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)
|
|
StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)
|
|
|
|
<StyleSetImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
CSSRuleProcessor::AppendStyleSheet(nsICSSStyleSheet *)
|
|
CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *)
|
|
StyleSetImpl::ClearOverrideRuleProcessors(void)
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
<StyleListImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsString::operator=(nsString const &)
|
|
StyleListImpl::ResetFrom(nsStyleList const *, nsIPresContext *)
|
|
|
|
<StyleListImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
|
|
nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)
|
|
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
|
|
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
|
|
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)
|
|
StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)
|
|
|
|
<StyleListImpl>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
CSSRuleProcessor::ClearRuleCascades(void)
|
|
nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)
|
|
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
|
|
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)
|
|
StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<StyleContextCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
StyleContextCache::VerifyList(unsigned int)
|
|
|
|
<StyleContextCache>
|
|
__builtin_new
|
|
StyleContextCache::AllocateList(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsPersistentProperties
|
|
#
|
|
|
|
<nsPersistentProperties>
|
|
__builtin_new
|
|
nsPersistentProperties::Create(nsISupports *, nsID const &, void **)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)
|
|
nsPersistentProperties::Load(nsIInputStream *)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCppSharedAllocator<unsigned short>::allocate(unsigned int, void const *)
|
|
nsCRT::strndup(unsigned short const *, unsigned int)
|
|
nsCRT::strdup(unsigned short const *)
|
|
nsString::ToNewUnicode(void) const
|
|
nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_NewHashTable
|
|
nsPersistentProperties::nsPersistentProperties(void)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
|
|
ToNewUnicode(nsAString const &)
|
|
nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsCSSValue
|
|
#
|
|
|
|
<nsCSSValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCppSharedAllocator<unsigned short>::allocate(unsigned int, void const *)
|
|
nsCRT::strndup(unsigned short const *, unsigned int)
|
|
nsCRT::strdup(unsigned short const *)
|
|
nsString::ToNewUnicode(void) const
|
|
nsCSSValue::operator=(nsCSSValue const &)
|
|
|
|
<nsCSSValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsCSSValue::SetStringValue(nsAString const &, nsCSSUnit)
|
|
|
|
<nsCSSValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
|
|
ToNewUnicode(nsAString const &)
|
|
nsCSSValue::SetStringValue(nsAString const &, nsCSSUnit)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsStringKey>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStringKey::Clone(void) const
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsTextFragment
|
|
#
|
|
|
|
<nsTextFragment>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsTextFragment::SetTo(unsigned short const *, int)
|
|
|
|
<nsTextFragment>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsAString const &)
|
|
nsTextFragment::operator=(nsAString const &)
|
|
|
|
<nsTextFragment>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
char * AllocateStringCopy<unsigned short, char>(basic_nsAReadableString<unsigned short> const &, char *)
|
|
ToNewCString(basic_nsAReadableString<unsigned short> const &)
|
|
nsTextFragment::operator=(basic_nsAReadableString<unsigned short> const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsTextBoxFrame
|
|
#
|
|
|
|
<nsTextBoxFrame>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsTextBoxFrame::UpdateAttributes(nsIPresContext *, nsIAtom *, int &, int &)
|
|
|
|
<nsTextBoxFrame>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsTextBoxFrame::CalculateTitleForWidth(nsIPresContext *, nsIRenderingContext &, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsPopupSetFrame
|
|
#
|
|
|
|
<nsPopupSetFrame>
|
|
__builtin_new
|
|
nsPopupSetFrame::AddPopupFrame(nsIFrame *)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsStdURL>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsACString const &)
|
|
nsStdURL::GetSpec(char **)
|
|
|
|
<nsSimpleURI>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsString::ToNewCString(void) const
|
|
nsSimpleURI::SetSpec(char const *)
|
|
|
|
<nsSimpleURI>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsAString const &)
|
|
nsSimpleURI::SetSpec(char const *)
|
|
|
|
<nsNodeInfoManager>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
nsNodeInfoManager::GetNodeInfo(nsIAtom *, nsIAtom *, int, nsINodeInfo *&)
|
|
|
|
<nsNodeInfoManager>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_NewHashTable
|
|
nsNodeInfoManager::nsNodeInfoManager(void)
|
|
|
|
<nsNodeInfoManager>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawRemove
|
|
PL_HashTableRemove
|
|
nsNodeInfoManager::RemoveNodeInfo(nsNodeInfo *)
|
|
|
|
<xptiInterfaceInfo>
|
|
XPT_ArenaMalloc
|
|
xptiInterfaceInfo::CopyName(char const *, xptiWorkingSet *)
|
|
|
|
<xptiInterfaceInfo>
|
|
__builtin_new
|
|
xptiInterfaceInfo::PartiallyResolveLocked(XPTInterfaceDescriptor *, xptiWorkingSet *)
|
|
|
|
<xpti-unclassified>
|
|
XPT_ArenaMalloc
|
|
|
|
<pthread-unclassified>
|
|
siglongjmp
|
|
pthread_create
|
|
|
|
<X-unclassified>
|
|
XkbAllocClientMap
|
|
|
|
<X-unclassified>
|
|
_XiCheckExtInit
|
|
|
|
<X-unclassified>
|
|
_XAllocScratch
|
|
|
|
<X-unclassified>
|
|
XUnlockDisplay
|
|
|
|
<X-unclassified>
|
|
_XlcCreateLC
|
|
|
|
<X-unclassified>
|
|
XkbUseExtension
|
|
|
|
<X-unclassified>
|
|
_XimServerDestroy
|
|
|
|
<X-unclassified>
|
|
_XlcAddCharSet
|
|
|
|
<X-unclassified>
|
|
XInitExtension
|
|
|
|
<X-unclassified>
|
|
_XlcGenericLoader
|
|
|
|
<X-unclassified>
|
|
_XwcDefaultDrawImageString
|
|
|
|
<X-unclassified>
|
|
_XlcAddCT
|
|
|
|
<X-unclassified>
|
|
XShmCreateImage
|
|
|
|
<X-unclassified>
|
|
_XFreeAtomTable
|
|
|
|
<X-unclassified>
|
|
XCreateRegion
|
|
|
|
<X-unclassified>
|
|
XIntersectRegion
|
|
|
|
<X-unclassified>
|
|
_XlcCreateLocaleDataBase
|
|
|
|
<X-unclassified>
|
|
_XUpdateAtomCache
|
|
|
|
<X-unclassified>
|
|
XrmMergeDatabases
|
|
|
|
<X-unclassified>
|
|
XrmParseCommand
|
|
|
|
<X-unclassified>
|
|
XOpenDisplay
|
|
|
|
<X-unclassified>
|
|
XCreateGC
|
|
|
|
<X-unclassified>
|
|
_XlcResetConverter
|
|
|
|
<X-unclassified>
|
|
_XEnq
|
|
|
|
<X-unclassified>
|
|
_XimLcctstowcs
|
|
|
|
<X-unclassified>
|
|
XtMalloc
|
|
|
|
<X-unclassified>
|
|
XtCalloc
|
|
|
|
<X-unclassified>
|
|
Xpermalloc
|
|
|
|
<X-unclassified>
|
|
_XlcCreateDefaultCharSet
|
|
|
|
<X-unclassified>
|
|
_XimLocalSetICValues
|
|
|
|
<X-unclassified>
|
|
_XimLocalCreateIC
|
|
|
|
<X-unclassified>
|
|
_XlcSetConverter
|
|
|
|
<X-unclassified>
|
|
_XkbGetCharset
|
|
|
|
<gtk-unclassified>
|
|
g_malloc
|
|
|
|
<gtk-unclassified>
|
|
g_realloc
|
|
|
|
<gtk-unclassified>
|
|
g_malloc0
|
|
|
|
<gtk-unclassified>
|
|
_XimLcctstoutf8
|
|
|
|
<gdk_imlib_load_image>
|
|
loader_png
|
|
gdk_imlib_load_image
|
|
|
|
<gdk_imlib_save_image>
|
|
loader_png
|
|
gdk_imlib_save_image
|
|
|
|
<dl-unclassified>
|
|
_dl_lookup_versioned_symbol_skip
|
|
|
|
<dl-unclassified>
|
|
_dl_dst_substitute
|
|
|
|
<dl-unclassified>
|
|
_dl_map_object_deps
|
|
|
|
<dl-unclassified>
|
|
_dl_map_object
|
|
|
|
<dl-unclassified>
|
|
_dl_debug_message
|
|
|
|
<nsRegistry>
|
|
PR_Malloc
|
|
bufio_SetBufferSize
|
|
nsXPTCStubBase::Sentinel9(void)
|
|
NR_RegSetBufferSize
|
|
nsRegistry::SetBufferSize(int)
|
|
|
|
<nsXBLService>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsXBLService::nsXBLService(void)
|
|
|
|
<nsXBLService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsXBLService::nsXBLService(void)
|
|
|
|
<InMemoryDataSource>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
InMemoryAssertionEnumeratorImpl::operator new(unsigned int, nsFixedSizeAllocator &)
|
|
|
|
<nsGenericModule>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, unsigned int (*)(nsIModule *), void (*)(nsIModule *))
|
|
|
|
<nsGenericModule>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsGenericModule::GetClassObject(nsIComponentManager *, nsID const &, nsID const &, void **)
|
|
|
|
<nsGenericModule>
|
|
__builtin_new
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsGenericModule::GetClassObject(nsIComponentManager *, nsID const &, nsID const &, void **)
|
|
|
|
<nsGenericModule>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, void (*)(nsIModule *))
|
|
|
|
<nsGenericModule>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, unsigned int (*)(nsIModule *), void (*)(nsIModule *))
|
|
|
|
<nsUNIXCharset>
|
|
gettext
|
|
gettext
|
|
setlocale
|
|
setlocale
|
|
nsUNIXCharset::nsUNIXCharset(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsLocaleService
|
|
#
|
|
|
|
<nsLocaleService>
|
|
textdomain
|
|
textdomain
|
|
setlocale
|
|
setlocale
|
|
nsLocaleService::nsLocaleService(void)
|
|
|
|
<nsLocaleService>
|
|
setlocale
|
|
setlocale
|
|
setlocale
|
|
nsLocaleService::nsLocaleService(void)
|
|
|
|
<nsLocaleService>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_NewHashTable
|
|
nsLocale::nsLocale(void)
|
|
|
|
<nsLocaleServie>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
nsLocale::AddCategory(unsigned short const *, unsigned short const *)
|
|
|
|
<nsLocaleService>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::do_AssignFromElementPtr(unsigned short const *)
|
|
nsString::nsString(unsigned short const *)
|
|
nsLocale::AddCategory(unsigned short const *, unsigned short const *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsServiceManagerImpl (obsolete?)
|
|
#
|
|
|
|
<nsServiceManagerImpl>
|
|
__builtin_new
|
|
nsServiceManagerImpl::nsServiceManagerImpl(void)
|
|
NS_NewServiceManager(nsIServiceManager **)
|
|
|
|
<nsServiceManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsServiceManagerImpl::nsServiceManagerImpl(void)
|
|
|
|
<nsServiceManagerImpl>
|
|
__builtin_new
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)
|
|
|
|
<nsServiceManagerImpl>
|
|
__builtin_new
|
|
nsServiceManagerImpl::nsServiceManagerImpl(void)
|
|
NS_NewServiceManager(nsIServiceManager **)
|
|
|
|
<nsServiceManagerImpl>
|
|
__builtin_new
|
|
nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)
|
|
|
|
<nsServiceManagerImpl>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsXMLElement
|
|
#
|
|
|
|
<nsXMLElement>
|
|
__builtin_new
|
|
nsGenericContainerElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)
|
|
nsGenericXMLElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)
|
|
|
|
<nsXMLElement>
|
|
__builtin_new
|
|
nsGenericContainerElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)
|
|
nsXMLElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)
|
|
|
|
<nsXMLElement>
|
|
__builtin_new
|
|
nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int)
|
|
nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int)
|
|
|
|
<nsXMLElement>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsString::nsString(nsAString const &)
|
|
nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int)
|
|
nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int)
|
|
|
|
<nsXMLElement>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsCheapVoidArray::AppendElement(void *)
|
|
nsGenericContainerElement::AppendChildTo(nsIContent *, int, int)
|
|
nsXMLContentSink::AddContentAsLeaf(nsIContent *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsXMLDocument
|
|
#
|
|
|
|
<nsXMLDocument>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsDocument::nsDocument(void)
|
|
nsMarkupDocument::nsMarkupDocument(void)
|
|
nsXMLDocument::nsXMLDocument(void)
|
|
|
|
<nsXMLDocument>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::AppendWithConversion(char const *, int)
|
|
nsString::AssignWithConversion(char const *)
|
|
nsDocument::StartDocumentLoad(char const *, nsIChannel *, nsILoadGroup *, nsISupports *, nsIStreamListener **, int)
|
|
nsXMLDocument::StartDocumentLoad(char const *, nsIChannel *, nsILoadGroup *, nsISupports *, nsIStreamListener **, int)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsGCCache>
|
|
__builtin_new
|
|
nsGCCache::nsGCCache(void)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# prefs
|
|
#
|
|
|
|
<nsPref>
|
|
_init
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
pref_HashPref
|
|
|
|
<nsPref>
|
|
_init
|
|
PL_NewHashTable
|
|
PREF_Init
|
|
|
|
<nsPref>
|
|
pref_HashPref
|
|
|
|
<nsPref>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsPref::nsPref(void)
|
|
|
|
<nsPref>
|
|
PREF_RegisterCallback
|
|
|
|
<nsPref>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsCString::nsCString(nsCString const &)
|
|
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
|
|
nsPrefBranch::AddObserver(char const *, nsIObserver *)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsThread>
|
|
PR_Calloc
|
|
PR_SetThreadPrivate
|
|
nsThread::RegisterThreadSelf(void)
|
|
|
|
<nsFontGTK>
|
|
XFreeFont
|
|
|
|
<nsFontGTK>
|
|
__builtin_new
|
|
nsFontGTK::operator new(unsigned int)
|
|
|
|
<nsGenericContainerElement>
|
|
__builtin_new
|
|
nsCheapVoidArray::SwitchToVector(void)
|
|
nsCheapVoidArray::AppendElement(void *)
|
|
nsGenericContainerElement::AppendChildTo(nsIContent *, int)
|
|
|
|
<nsGenericContainerElement>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsCheapVoidArray::AppendElement(void *)
|
|
nsGenericContainerElement::AppendChildTo(nsIContent *, int, int)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsObserverService
|
|
#
|
|
|
|
<nsObserverService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
__builtin_new
|
|
NS_NewObserverList(nsIObserverList **)
|
|
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
__builtin_new
|
|
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)
|
|
|
|
<nsObserverService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsObserverService::GetObserverList(char const *, nsObserverList **)
|
|
|
|
<nsObserverService>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsObserverList::AddObserver(nsIObserver *, int)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsViewManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsViewManager::nsViewManager(void)
|
|
|
|
<nsViewManager2>
|
|
__builtin_new
|
|
nsViewManager2::AddToDisplayList(int *, nsIView *, nsRect &, nsRect &, unsigned int, int, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsBindingManager
|
|
#
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsBindingManager::SetContentListFor(nsIContent *, nsISupportsArray *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsBindingManager::SetAnonymousNodesFor(nsIContent *, nsISupportsArray *)
|
|
|
|
<nsBindingManager>
|
|
__builtin_new
|
|
nsISupportsKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)
|
|
|
|
<nsBindingManager>
|
|
__builtin_new
|
|
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)
|
|
|
|
<nsBindingManager>
|
|
__builtin_new
|
|
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)
|
|
|
|
<nsBindingManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsBindingManager::SetWrappedJS(nsIContent *, nsIXPConnectWrappedJS *)
|
|
|
|
<nsBindingManager>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsBindingManager::AddToAttachedQueue(nsIXBLBinding *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<NameSpaceManagerImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsString::nsString(nsAString const &)
|
|
NameSpaceManagerImpl::RegisterNameSpace(nsAString const &, int &)
|
|
|
|
<NameSpaceManagerImpl>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **)
|
|
NameSpaceManagerImpl::NameSpaceManagerImpl(void)
|
|
|
|
<NameSpaceManagerImpl>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
NameSpaceManagerImpl::RegisterNameSpace(basic_nsAReadableString<unsigned short> const &, int &)
|
|
|
|
<NameSpaceManagerImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
|
|
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
|
|
nsString::nsString(nsString const &)
|
|
nsLayoutUtils::CopyNewlineNormalizedUnicodeTo(nsReadingIterator<unsigned short> &, nsReadingIterator<unsigned short> const &, basic_nsAWritableString<unsigned short> &)
|
|
NameSpaceManagerImpl::NameSpaceManagerImpl(void)
|
|
|
|
<nsErrorService>
|
|
__builtin_new
|
|
nsErrorService::Create(nsISupports *, nsID const &, void **)
|
|
|
|
<nsErrorService>
|
|
__builtin_new
|
|
nsVoidKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsInt2StrHashtable::Put(unsigned int, char const *)
|
|
nsErrorService::RegisterErrorStringBundleKey(unsigned int, char const *)
|
|
|
|
<nsErrorService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsInt2StrHashtable::Put(unsigned int, char const *)
|
|
nsErrorService::RegisterErrorStringBundleKey(unsigned int, char const *)
|
|
|
|
<nsDocument>
|
|
__builtin_new
|
|
ArenaImpl::Create(nsISupports *, nsID const &, void **)
|
|
NS_NewHeapArena(nsIArena **, unsigned int)
|
|
nsDocument::Init(void)
|
|
|
|
<nsDocument>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsDocument::nsDocument(void)
|
|
|
|
<nsDocument>
|
|
__builtin_new
|
|
nsDocument::SetHeaderData(nsIAtom *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsDocument::mContentWrapperHash>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsDocument::AddReference(void *, nsISupports *)
|
|
|
|
<nsDocHeaderData>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
|
|
nsDocHeaderData::nsDocHeaderData(nsIAtom *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<XPCContext>
|
|
__builtin_new
|
|
XPCContext::newXPCContext(XPCJSRuntime *, JSContext *)
|
|
|
|
<nsEventQueueService>
|
|
__builtin_new
|
|
nsEventQueueServiceImpl::Create(nsISupports *, nsID const &, void **)
|
|
|
|
<nsEventQueueService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsEventQueueServiceImpl::nsEventQueueServiceImpl(void)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Malloc
|
|
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
|
|
nsEventListenerManager::SetJSEventListener(nsIScriptContext *, nsISupports *, nsIAtom *, int)
|
|
nsEventListenerManager::AddScriptEventListener(nsIScriptContext *, nsISupports *, nsIAtom *, nsAString const &, int)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Malloc
|
|
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
|
|
nsEventListenerManager::AddEventListenerByType(nsIDOMEventListener *, nsAString const &, int)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Malloc
|
|
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
|
|
nsEventListenerManager::AddEventListenerByIID(nsIDOMEventListener *, nsID const &, int)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::ReplaceElementAt(void *, int)
|
|
nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::ReplaceElementAt(void *, int)
|
|
nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)
|
|
|
|
<nsEventListenerManager>
|
|
__builtin_new
|
|
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int)
|
|
|
|
<nsEventListenerManager>
|
|
PR_Malloc
|
|
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int)
|
|
|
|
<nsCParserNode>
|
|
__builtin_new
|
|
nsCParserNode::AddAttribute(CToken *)
|
|
|
|
<nsCParserNode>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsDeque::GrowCapacity(void)
|
|
nsDeque::Push(void *)
|
|
nsCParserNode::AddAttribute(CToken *)
|
|
|
|
<nsSocketTransportService>
|
|
PR_Malloc
|
|
nsSocketTransportService::Init(void)
|
|
|
|
<nsSocketTransport>
|
|
PR_Malloc
|
|
nsSocketTransport::AsyncWrite(nsIInputStream *, nsIStreamObserver *, nsISupports *)
|
|
|
|
<nsSocketTransport>
|
|
PR_Malloc
|
|
_PR_Getfd
|
|
PR_GetConnectStatus
|
|
PR_Socket
|
|
PR_OpenTCPSocket
|
|
nsSocketTransport::doConnection(short)
|
|
|
|
<CompositeDataSourceImpl>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
CompositeDataSourceImpl::CompositeDataSourceImpl(void)
|
|
|
|
<CompositeDataSourceImpl>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
CompositeDataSourceImpl::GetTargets(nsIRDFResource *, nsIRDFResource *, int, nsISimpleEnumerator **)
|
|
|
|
<CompositeDataSourceImpl>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
CompositeDataSourceImpl::ArcLabelsIn(nsIRDFNode *, nsISimpleEnumerator **)
|
|
|
|
<CompositeDataSourceImpl>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
CompositeDataSourceImpl::ArcLabelsOut(nsIRDFResource *, nsISimpleEnumerator **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsHTMLValue
|
|
#
|
|
|
|
<nsHTMLValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<unsigned short, unsigned short>(basic_nsAReadableString<unsigned short> const &, unsigned short *)
|
|
ToNewUnicode(basic_nsAReadableString<unsigned short> const &)
|
|
nsHTMLValue::nsHTMLValue(basic_nsAReadableString<unsigned short> const &, nsHTMLUnit)
|
|
|
|
<nsHTMLValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsHTMLValue::SetStringValue(nsAString const &, nsHTMLUnit)
|
|
|
|
<nsHTMLValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
|
|
ToNewUnicode(nsAString const &)
|
|
nsHTMLValue::nsHTMLValue(nsAString const &, nsHTMLUnit)
|
|
|
|
<nsHTMLValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
|
|
ToNewUnicode(nsAString const &)
|
|
nsHTMLValue::SetStringValue(nsAString const &, nsHTMLUnit)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsMemCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)
|
|
|
|
<nsMemCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsMemCache::Init(void)
|
|
|
|
<nsMemCache>
|
|
__builtin_new
|
|
nsOpaqueKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)
|
|
|
|
<nsMemCache>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsOpaqueKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)
|
|
|
|
<nsMemCache>
|
|
__builtin_new
|
|
nsOpaqueKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)
|
|
|
|
<nsMemCache>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsOpaqueKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)
|
|
|
|
<nsMemCacheRecord>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsMemCacheRecord::SetMetaData(unsigned int, char const *)
|
|
|
|
<nsMemCacheRecord>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsMemCacheRecord::Init(char const *, unsigned int, unsigned int, nsMemCache *)
|
|
|
|
<nsTextFormatter>
|
|
PR_Realloc
|
|
nsXPIDLString type_info function
|
|
nsXPIDLString type_info function
|
|
nsTextFormatter::vsmprintf(unsigned short const *, void *)
|
|
nsTextFormatter::smprintf(unsigned short const *,...)
|
|
|
|
<nsTextFormatter>
|
|
PR_Malloc
|
|
nsXPIDLString type_info function
|
|
nsXPIDLString type_info function
|
|
nsTextFormatter::vsmprintf(unsigned short const *, void *)
|
|
|
|
<nsTextFormatter>
|
|
PR_Realloc
|
|
nsXPIDLString type_info function
|
|
nsXPIDLString type_info function
|
|
nsTextFormatter::vsmprintf(unsigned short const *, void *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsPresContext
|
|
#
|
|
|
|
<nsPresContext>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsPresContext::nsPresContext(void)
|
|
|
|
<nsPresContext>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresContext::LoadImage(nsString const &, nsIFrame *, imgIRequest **)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsPresState
|
|
#
|
|
|
|
<nsPresState>
|
|
__builtin_new
|
|
nsPresState::SetStateProperty(nsAString const &, nsAString const &)
|
|
|
|
<nsPresState>
|
|
__builtin_new
|
|
nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsSupportsWStringImpl::SetDataWithLength(unsigned int, unsigned short const *)
|
|
nsSupportsWStringImpl::SetData(unsigned short const *)
|
|
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsPresState>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)
|
|
|
|
<nsPresState>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsSupportsWStringImpl::SetDataWithLength(unsigned int, unsigned short const *)
|
|
nsSupportsWStringImpl::SetData(unsigned short const *)
|
|
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsPresState::SetStateProperty(nsAString const &, nsAString const &)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresState::SetStateProperty(nsAString const &, nsAString const &)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)
|
|
|
|
<nsPresState>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsSupportsStringImpl::SetDataWithLength(unsigned int, char const *)
|
|
nsSupportsStringImpl::SetData(char const *)
|
|
nsPresState::SetStateProperty(nsAString const &, nsAString const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# Prefs stuff
|
|
#
|
|
|
|
<prefs-unclassified>
|
|
PL_strdup
|
|
pref_HashPref
|
|
|
|
<prefs-unclassified>
|
|
PL_strdup
|
|
PREF_LockPref
|
|
|
|
<prefs-unclassified>
|
|
PL_strdup
|
|
PREF_RegisterCallback
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# Imagelib Stuff
|
|
#
|
|
|
|
<imgRequest>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
imgRequest::AddProxy(imgRequestProxy *)
|
|
|
|
<ImageRequestImpl>
|
|
__builtin_new
|
|
ImageRequestImpl::AddObserver(nsIImageRequestObserver *)
|
|
|
|
<ImageRequestImpl>
|
|
PR_Malloc
|
|
XP_AddObserver
|
|
ImageRequestImpl::Init(void *, char const *, nsIImageRequestObserver *, unsigned int const *, unsigned int, unsigned int, unsigned int, ilINetContext *)
|
|
|
|
<imglib-unclassified>
|
|
__builtin_new
|
|
ImageNetContextImpl::GetURL(ilIURL *, ImgCachePolicy, ilINetReader *, int)
|
|
|
|
# il_group_notify() is really a call to a static rounting il_init_scaling()
|
|
<imglib-scaling>
|
|
PR_Malloc
|
|
il_group_notify(_IL_GroupContext *, long)
|
|
il_size(il_container_struct *)
|
|
ImgDCallbk::ImgDCBImageSize(void)
|
|
|
|
<imglib-gifdecode>
|
|
PR_Calloc
|
|
il_gif_write(il_container_struct *, unsigned char const *, int)
|
|
|
|
<imglib-gifdecode>
|
|
PR_Malloc
|
|
il_gif_write(il_container_struct *, unsigned char const *, int)
|
|
|
|
<gif_struct>
|
|
PR_Calloc
|
|
il_gif_init(il_container_struct *)
|
|
|
|
<IL_ImageReq>
|
|
PR_Calloc
|
|
IL_GetImage
|
|
|
|
<imglib-container-stuff>
|
|
PR_Calloc
|
|
il_get_container(_IL_GroupContext *, ImgCachePolicy, char const *, _NI_IRGB *, IL_DitherMode, int, int, int)
|
|
|
|
<IL_ColorSpace>
|
|
PR_Calloc
|
|
IL_CreateTrueColorSpace
|
|
|
|
<IL_Pixmap>
|
|
PR_Calloc
|
|
il_size(il_container_struct *)
|
|
ImgDCallbk::ImgDCBImageSize(void)
|
|
|
|
<IL_ColorSpace>
|
|
PR_Calloc
|
|
IL_CreateGreyScaleColorSpace
|
|
|
|
<imglib-gifcompat>
|
|
PR_Malloc
|
|
il_BACat(char **, unsigned int, char const *, unsigned int)
|
|
|
|
<imglib-gifcompat>
|
|
PR_Realloc
|
|
il_BACat(char **, unsigned int, char const *, unsigned int)
|
|
|
|
<ImageConsumer>
|
|
PR_Malloc
|
|
ImageConsumer::OnStartRequest(nsIChannel *, nsISupports *)
|
|
|
|
# These are really called from `static' routines in ilclient.cpp,
|
|
# *not* ImgDCallbk::CreateInstance()
|
|
<imglib-list>
|
|
PR_Calloc
|
|
ImgDCallbk::CreateInstance(nsID const &, il_container_struct *, nsID const &, void **)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsImageGTK>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsImageGTK::Init(int, int, int, nsMaskRequirements)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsLayoutHistoryState
|
|
#
|
|
|
|
<nsLayoutHistoryState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsLayoutHistoryState::nsLayoutHistoryState(void)
|
|
|
|
<nsLayoutHistoryState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsLayoutHistoryState::nsLayoutHistoryState(void)
|
|
|
|
<nsLayoutHistoryState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsLayoutHistoryState::AddState(unsigned int, nsIPresState *, nsIStatefulFrame::StateType)
|
|
|
|
<nsLayoutHistoryState>
|
|
__builtin_new
|
|
nsVoidKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsLayoutHistoryState::AddState(unsigned int, nsIPresState *, nsIStatefulFrame::StateType)
|
|
|
|
<nsLayoutHistoryState>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsLayoutHistoryState::AddState(nsCString const &, nsIPresState *)
|
|
|
|
<nsLayoutHistoryState>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsLayoutHistoryState::AddState(nsCString const &, nsIPresState *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsCookieService
|
|
#
|
|
|
|
<nsCookieService>
|
|
PR_Realloc
|
|
Local_SACat(char **, char const *)
|
|
COOKIE_GetCookie(char *)
|
|
|
|
<nsCookieService>
|
|
PR_Malloc
|
|
cookie_IsFromHost(_cookie_CookieStruct *, char *)
|
|
|
|
<nsCookieService>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsAString const &)
|
|
COOKIE_Read(void)
|
|
nsCookieService::Init(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsReplacementPolicy>
|
|
PR_Realloc
|
|
nsMemoryImpl::Realloc(void *, unsigned int)
|
|
nsMemory::Realloc(void *, unsigned int)
|
|
nsReplacementPolicy::AssociateCacheEntryWithRecord(nsINetDataCacheRecord *, nsINetDataCache *, nsCachedNetData **)
|
|
|
|
<nsReplacementPolicy>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsReplacementPolicy::Init(unsigned int)
|
|
|
|
<nsHTTPHeaderArray>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AssignFromReadable(nsACString const &)
|
|
nsACString::do_AssignFromElementPtr(char const *)
|
|
nsHttpHeaderArray::SetHeader(nsHttpAtom, char const *)
|
|
|
|
<nsHTTPHandler>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int)
|
|
|
|
<nsHTTPHandler>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsHTTPHandler::nsHTTPHandler(void)
|
|
|
|
<nsHTTPHandler>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int)
|
|
|
|
<nsCachedNetData>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
ArenaImpl::Alloc(unsigned int)
|
|
nsCachedNetData::operator new(unsigned int, nsIArena *)
|
|
|
|
<ns4xPluginStreamListener>
|
|
PR_Malloc
|
|
ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo *, nsIInputStream *, unsigned int)
|
|
|
|
<nsSegmentedBuffer>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsSegmentedBuffer::AppendNewSegment(void)
|
|
|
|
<nsAuthURLParser>
|
|
PL_strndup
|
|
ExtractString
|
|
|
|
<nsJAR>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
|
|
nsJAR::nsJAR(void)
|
|
|
|
<nsJAR>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsJAR::nsJAR(void)
|
|
|
|
<nsJARURI>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewCString(nsACString const &)
|
|
nsIOService::ResolveRelativePath(char const *, char const *, char **)
|
|
nsJARURI::SetSpec(char const *)
|
|
|
|
<nsStreamConverterService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsStreamConverterService::Init(void)
|
|
|
|
<nsLayoutUtils>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **)
|
|
|
|
<nsDNSService>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)
|
|
|
|
<nsDNSService>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
nsDNSService::Init(void)
|
|
|
|
<nsDNSService>
|
|
__builtin_new
|
|
nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)
|
|
|
|
<nsDNSService>
|
|
__builtin_new
|
|
nsDNSService::Lookup(char const *, nsIDNSListener *, nsISupports *, nsIRequest **)
|
|
|
|
<nsDNSService>
|
|
__builtin_new
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)
|
|
|
|
<nsDNSLookup>
|
|
gethostbyname2
|
|
PR_GetIPNodeByName
|
|
nsDNSLookup::InitiateLookup(void)
|
|
|
|
<nsDNSLookup>
|
|
__builtin_new
|
|
nsSupportsArray::Create(nsISupports *, nsID const &, void **)
|
|
NS_NewISupportsArray(nsISupportsArray **)
|
|
nsDNSLookup::Init(char const *)
|
|
|
|
<nsDNSLookup>
|
|
__builtin_new
|
|
nsDNSLookup::Create(char const *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsFormControlList
|
|
#
|
|
|
|
<nsFormControlList>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsFormControlList>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsFormControlList::nsFormControlList(nsIDOMHTMLFormElement *)
|
|
|
|
<nsFormControlList>
|
|
__builtin_new
|
|
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsFormControlList>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsFormControlList>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<nsFormControlList>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsFormControlList::AddElementToTable(nsIFormControl *, nsAString const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsControllerCommandManager
|
|
#
|
|
|
|
<nsControllerCommandManager>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
NS_NewControllerCommandManager(nsIControllerCommandManager **)
|
|
|
|
<nsControllerCommandManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsControllerCommandManager::nsControllerCommandManager(void)
|
|
|
|
<nsControllerCommandManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsControllerCommandManager::RegisterCommand(nsAString const &, nsIControllerCommand *)
|
|
|
|
<nsControllerCommandManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsControllerCommandManager::RegisterCommand(unsigned short const *, nsIControllerCommand *)
|
|
|
|
<nsControllerCommandManager>
|
|
__builtin_new
|
|
nsStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsControllerCommandManager::RegisterCommand(unsigned short const *, nsIControllerCommand *)
|
|
|
|
<nsControllerCommandManager>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
|
|
nsControllerCommandManager::nsControllerCommandManager(void)
|
|
|
|
<nsConsoleService>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsConsoleService::nsConsoleService(void)
|
|
|
|
<nsGenericElement>
|
|
__builtin_new
|
|
nsGenericElement::GetDOMSlots(void)
|
|
|
|
<HTMLAttribute>
|
|
__builtin_new
|
|
HTMLAttribute::CopyHTMLAttributes(HTMLAttribute *, HTMLAttribute **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# HTMLAttributesImpl
|
|
#
|
|
|
|
<HTMLAttributesImpl>
|
|
__builtin_new
|
|
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsAString const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *)
|
|
|
|
<HTMLAttributesImpl>
|
|
__builtin_new
|
|
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)
|
|
|
|
<HTMLAttributesImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
HTMLAttributesImpl::SetAttributeName(nsIAtom *, int &)
|
|
|
|
<HTMLAttributesImpl>
|
|
__builtin_new
|
|
nsHTMLMappedAttributes::SetAttribute(nsIAtom *, nsHTMLValue const &)
|
|
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)
|
|
|
|
<HTMLAttributesImpl>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCRT::strndup(unsigned short const *, unsigned int)
|
|
nsCRT::strdup(unsigned short const *)
|
|
nsHTMLValue::nsHTMLValue(nsHTMLValue const &)
|
|
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)
|
|
|
|
<HTMLAttributesImpl>
|
|
__builtin_new
|
|
nsHTMLMappedAttributes::nsHTMLMappedAttributes(nsHTMLMappedAttributes const &)
|
|
nsHTMLMappedAttributes::Clone(nsHTMLMappedAttributes **) const
|
|
HTMLAttributesImpl::EnsureSingleMappedFor(nsIHTMLContent *, nsIHTMLStyleSheet *, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsEntityConverter>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsEntityConverter::LoadVersionPropertyFile(void)
|
|
|
|
<nsTableFrame>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsTableFrame::nsTableFrame(void)
|
|
|
|
<nsTableFrame>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsTableFrame::BalanceColumnWidths(nsIPresContext *, nsHTMLReflowState const &, nsSize const &, nsSize *)
|
|
|
|
<nsTableFrame>
|
|
__builtin_new
|
|
nsTableFrame::Init(nsIPresContext *, nsIContent *, nsIFrame *, nsIStyleContext *, nsIFrame *)
|
|
|
|
<nsTableCellFrame>
|
|
__builtin_new
|
|
nsTableCellFrame::GetFrameName(nsString &) const
|
|
|
|
<nsCellMap>
|
|
__builtin_new
|
|
nsCellMap::AppendCell(nsTableCellMap &, nsTableCellFrame &, int, int)
|
|
|
|
<nsCellMap>
|
|
__builtin_new
|
|
nsCellMap::Grow(nsTableCellMap &, int, int)
|
|
|
|
<nsCellMap>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::nsVoidArray(int)
|
|
nsCellMap::Grow(nsTableCellMap &, int, int)
|
|
|
|
<nsTableCellMap>
|
|
__builtin_new
|
|
nsTableCellMap::InsertGroupCellMap(nsTableRowGroupFrame &, nsTableRowGroupFrame *&)
|
|
|
|
<nsTableCellMap>
|
|
__builtin_new
|
|
nsTableCellMap::AddColsAtEnd(unsigned int)
|
|
|
|
<nsEncoderSupport>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsEncoderSupport::nsEncoderSupport(void)
|
|
|
|
<nsFrameImageLoader>
|
|
__builtin_new
|
|
Init__18nsFrameImageLoaderP14nsIPresContextP13nsIImageGroupRC8nsStringPCUiPC6nsSizeP8nsIFrame16nsImageAnimationPFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT9
|
|
|
|
<nsFrameImageLoader>
|
|
__builtin_new
|
|
AddFrame__18nsFrameImageLoaderP8nsIFramePFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT3
|
|
|
|
|
|
<nsFloaterCacheFreeList>
|
|
__builtin_new
|
|
nsFloaterCacheFreeList::Alloc(void)
|
|
|
|
<nsDocLoaderImpl>
|
|
__builtin_new
|
|
nsDocLoaderImpl::AddChannelInfo(nsIChannel *)
|
|
|
|
<nsDocLoaderImpl>
|
|
__builtin_new
|
|
nsDocLoaderImpl::AddRequestInfo(nsIRequest *)
|
|
|
|
<nsTokenAllocator>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsTokenAllocator::nsTokenAllocator(void)
|
|
|
|
<SinkContext>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
SinkContext::AddText(basic_nsAReadableString<unsigned short> const &)
|
|
|
|
<SinkContext>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
SinkContext::GrowStack(void)
|
|
|
|
<nsScanner>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsScanner::Append(char const *, unsigned int)
|
|
|
|
<nsParser>
|
|
__builtin_new
|
|
nsParser::Parse(nsIURI *, nsIStreamObserver *, int, void *, nsDTDMode)
|
|
|
|
<nsParser>
|
|
__builtin_new
|
|
nsParser::Parse(basic_nsAReadableString<unsigned short> const &, void *, nsString const &, int, int, nsDTDMode)
|
|
|
|
<nsParser>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsParser::OnDataAvailable(nsIChannel *, nsISupports *, nsIInputStream *, unsigned int, unsigned int)
|
|
|
|
<nsParserModule>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
InitializeElementTable(void)
|
|
|
|
<nsStorageStream>
|
|
__builtin_new
|
|
nsStorageStream::Init(unsigned int, unsigned int, nsIMemory *)
|
|
|
|
<nsEntryStack>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsEntryStack::EnsureCapacityFor(int, int)
|
|
|
|
<nsCacheManager>
|
|
__builtin_new
|
|
nsCacheManager::Init(void)
|
|
|
|
<nsScriptError>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<unsigned short>::Assign(unsigned short const *)
|
|
nsScriptError::Init(unsigned short const *, unsigned short const *, unsigned short const *, unsigned int, unsigned int, unsigned int, char const *)
|
|
|
|
<nsScriptError>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
~.*
|
|
~.*
|
|
basic_nsAWritableString<char>::Assign(char const *)
|
|
nsScriptError::Init(unsigned short const *, unsigned short const *, unsigned short const *, unsigned int, unsigned int, unsigned int, char const *)
|
|
|
|
<registry-Buffer>
|
|
PR_Malloc
|
|
bufio_SetBufferSize
|
|
|
|
<nsString::PRUnichar*>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc
|
|
nsMemory::Alloc
|
|
ToNewUnicode
|
|
|
|
<nsString::char*>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc
|
|
nsMemory::Alloc
|
|
nsStr::Alloc
|
|
|
|
<nsDiskCacheMap>
|
|
__builtin_new
|
|
nsDiskCacheDevice::Init(void)
|
|
|
|
<nsXULPrototypeAttribute>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
XULContentSinkImpl::AddAttributes(nsIParserNode const &, nsXULPrototypeElement *)
|
|
|
|
#
|
|
# XPCNativeInterface::NewInstance allocates an array of XPCNativeMember
|
|
# objects, and it also allocates an array of bytes to use for
|
|
# XPCNativeInterface objects. Trace would be the same for each.
|
|
#
|
|
<XPCNativeInterface>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
XPCNativeInterface::NewInstance(XPCCallContext &, nsIInterfaceInfo *)
|
|
|
|
<XPCNativeInterface>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
XPCNativeInterface::GetNewOrUsed(XPCCallContext &, nsID const *)
|
|
|
|
<nsDiskCacheBlockFile::mBitmap>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsDiskCacheBlockFile::Open(nsILocalFile *, unsigned int)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsConflictSet
|
|
#
|
|
|
|
<nsConflictSet::mBindingDependencies>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsConflictSet::AllocBindingTable(void *, unsigned int)
|
|
|
|
<nsConflictSet::mBindingDependencies>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsConflictSet::AllocBindingEntry(void *, void const *)
|
|
|
|
<nsConflictSet::mClusters>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsConflictSet::AllocClusterTable(void *, unsigned int)
|
|
|
|
<nsConflictSet::mClusters>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsConflictSet::AllocClusterEntry(void *, void const *)
|
|
|
|
<nsConflictSet::mSupport>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsConflictSet::AllocSupportTable(void *, unsigned int)
|
|
|
|
<nsConflictSet::mSupport>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsConflictSet::AllocSupportEntry(void *, void const *)
|
|
|
|
<nsConflictSet::mSupport>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsRDFConMemberTestNode::Element::Clone(void *) const
|
|
|
|
<nsConflictSet::mSupport>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsRDFConInstanceTestNode::Element::Clone(void *) const
|
|
|
|
<nsConflictSet::mSupport>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsRDFConInstanceTestNode::FilterInstantiations(InstantiationSet &, void *) const
|
|
|
|
<nsConflictSet::mSupport>
|
|
__builtin_new
|
|
MemoryElementSet::Add(MemoryElement *)
|
|
|
|
<nsConflictSet>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsTemplateMatchRefSet::AddToTable(nsTemplateMatch *)
|
|
nsTemplateMatchRefSet::Add(nsTemplateMatch const *)
|
|
nsConflictSet::Add(nsTemplateMatch *)
|
|
|
|
<nsConflictSet>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsConflictSet::Init(void)
|
|
|
|
<nsConflictSet>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsConflictSet::SupportEntry::Create(nsFixedSizeAllocator &)
|
|
|
|
<nsConflictSet>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsConflictSet::ClusterEntry::Create(nsFixedSizeAllocator &)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsAssignmentSet>
|
|
__builtin_new
|
|
nsAssignmentSet::Add(nsAssignment const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsXULTemplateBuilder
|
|
#
|
|
|
|
<nsXULTemplateBuilder>
|
|
__builtin_new
|
|
nsXULTemplateBuilder::CompileSimpleRule(nsIContent *, int, InnerNode *)
|
|
|
|
<nsXULTemplateBuilder>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
nsXULContentBuilder::nsXULContentBuilder(void)
|
|
|
|
<nsXULTemplateBuilder>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
nsContentSupportMap::Init(void)
|
|
|
|
<nsXULTemplateBuilder>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsXULContentBuilder::BuildContentFromTemplate(nsIContent *, nsIContent *, nsIContent *, int, nsIRDFResource *, int, nsTemplateMatch *, nsIContent **, int *)
|
|
|
|
<nsXULTemplateBuilder>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCRT::strndup(unsigned short const *, unsigned int)
|
|
nsCRT::strdup(unsigned short const *)
|
|
nsXULTemplateBuilder::AddBindingsFor(nsXULTemplateBuilder *, nsAString const &, void *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsRuleNetwork
|
|
#
|
|
|
|
<nsRuleNetwork>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
nsRuleNetwork::Init(void)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsTemplateRule
|
|
#
|
|
|
|
<nsTemplateRule>
|
|
__builtin_new
|
|
nsTemplateRule::AddBinding(int, nsIRDFResource *, int)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsTemplateMatch
|
|
#
|
|
|
|
<nsTemplateMatch>
|
|
__builtin_new
|
|
nsAssignmentSet::Add(nsAssignment const &)
|
|
nsTemplateRule::ComputeAssignmentFor(nsConflictSet &, nsTemplateMatch *, int, Value *) const
|
|
nsTemplateMatch::GetAssignmentFor(nsConflictSet &, int, Value *)
|
|
|
|
<nsTemplateMatch>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsInstantiationNode::Propagate(InstantiationSet const &, void *)
|
|
|
|
<nsTemplateMatch>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsRDFConMemberTestNode::FilterInstantiations(InstantiationSet &, void *) const
|
|
|
|
<nsTemplateMatch>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsTemplateMatch::Create(nsFixedSizeAllocator &, nsTemplateRule const *, Instantiation const &, nsAssignmentSet const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<ReteNodeSet::mNodes>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
ReteNodeSet::Add(ReteNode *)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<StaticModuleInfo>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsStaticComponentLoader::GetModuleInfo(void)
|
|
|
|
<RuleValue*>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
RuleHash::EnumerateAllRules(int, nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *)
|
|
|
|
<XPCNativeSet>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
XPCNativeSet::NewInstance(XPCCallContext &, nsIInterfaceInfo *)
|
|
|
|
<XPCNativeSet>
|
|
JS_DHashAllocTable
|
|
JS_DHashTableFinish
|
|
JS_DHashTableOperate
|
|
XPCNativeSet::ClearCacheEntryForClassInfo(nsIClassInfo *)
|
|
|
|
<XPCNativeSet>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
XPCNativeSet::NewInstanceMutate(XPCNativeSet *, XPCNativeInterface *, unsigned short)
|
|
|
|
<nsIRDFResource*>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsResourceSet::Add(nsIRDFResource *)
|
|
|
|
<nsXPCWrappedJSClass::mDescriptors>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsXPCWrappedJSClass::nsXPCWrappedJSClass(XPCCallContext &, nsID const &, nsIInterfaceInfo *)
|
|
|
|
<orkin-unclassified>
|
|
__builtin_new
|
|
orkinHeap::Alloc(nsIMdbEnv *, unsigned int, void **)
|
|
|
|
<nsGenericAttribute>
|
|
__builtin_new
|
|
nsGenericContainerElement::SetAttribute(nsINodeInfo *, nsAString const &, int)
|
|
|
|
#
|
|
# Space for LiteralImpl is allocated using global operator new so
|
|
# that extra space can be allocated for its string value.
|
|
#
|
|
<LiteralImpl>
|
|
__builtin_new
|
|
LiteralImpl::Create
|
|
|
|
<nsXULContentSinkImpl::mText>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
XULContentSinkImpl::FlushText(int)
|
|
|
|
<nsPersistentProperties>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCRT::strndup(unsigned short const *, unsigned int)
|
|
nsCRT::strdup(unsigned short const *)
|
|
nsString::ToNewUnicode(void) const
|
|
nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)
|
|
|
|
<nsCSSValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCRT::strndup(unsigned short const *, unsigned int)
|
|
nsCRT::strdup(unsigned short const *)
|
|
nsCSSValue::operator=(nsCSSValue const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsXULDocument
|
|
#
|
|
|
|
<nsXULDocument>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsAutoVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsXULDocument::AddObserver(nsIDocumentObserver *)
|
|
|
|
<nsXULDocument::mBoxObjectTable>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULDocument::SetBoxObjectFor(nsIDOMElement *, nsIBoxObject *)
|
|
|
|
<nsXULDocument::mTemplateBuilderTable>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULDocument::SetTemplateBuilderFor(nsIContent *, nsIXULTemplateBuilder *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsElementMap::Add(nsAString const &, nsIContent *)
|
|
nsXULDocument::AddElementToMap(nsIContent *)
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsElementMap::Add(nsAString const &, nsIContent *)
|
|
nsXULDocument::AddElementForID(nsAString const &, nsIContent *)
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsXULTreeElement::SelectCallback(nsITimer *, void *)
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
nsElementMap::Add(nsAString const &, nsIContent *)
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
NS_NewControllerCommandManager(nsIControllerCommandManager **)
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
nsElementMap::Add(nsAString const &, nsIContent *)
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsElementMap::Add(nsAString const &, nsIContent *)
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::AddBucket(unsigned int)
|
|
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
|
|
nsElementMap::nsElementMap(void)
|
|
|
|
<nsXULDocument::mElementMap>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
|
|
ToNewUnicode(nsAString const &)
|
|
nsElementMap::Add(nsAString const &, nsIContent *)
|
|
|
|
<nsXULDocument::mContentWrapperHash>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsXULDocument::AddReference(void *, nsISupports *)
|
|
|
|
<nsXULDocument>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsXULDocument::PrepareToWalk(void)
|
|
|
|
<nsXULDocument>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
PL_NewDHashTable
|
|
nsXULDocument::AddBroadcastListenerFor(nsIDOMElement *, nsIDOMElement *, nsAString const &)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsHTMLValue::mValue.mString>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ToNewUnicode(nsAString const &)
|
|
nsHTMLValue::nsHTMLValue(nsAString const &, nsHTMLUnit)
|
|
|
|
<nsCSSValue>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ExtractURLScheme
|
|
nsStdURL::Resolve(char const *, char **)
|
|
CSSParserImpl::ParseURL(int &, nsCSSValue &)
|
|
|
|
<url-unclassified>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
ExtractURLScheme
|
|
nsStdURL::Resolve(char const *, char **)
|
|
|
|
<css-unclassified>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
|
|
nsRuleWalker::Forward(nsIStyleRule *)
|
|
|
|
#
|
|
# Doesn't inherit nsISupports
|
|
#
|
|
<nsSupportsHashtable>
|
|
__builtin_new
|
|
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
|
|
|
|
#
|
|
# No vtable.
|
|
#
|
|
<nsClassList>
|
|
__builtin_new
|
|
nsClassList::ParseClasses(nsClassList **, nsAString const &)
|
|
|
|
#
|
|
# Doesn't inherit nsISupports
|
|
#
|
|
<nsVoidArray>
|
|
__builtin_new
|
|
nsCheapVoidArray::SwitchToVector(void)
|
|
|
|
<nsEventListenerManager>
|
|
__builtin_new
|
|
nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
<nsServiceModule::mServices>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
|
|
nsHashtable::nsHashtable(unsigned int, int)
|
|
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
|
|
nsServiceManagerImpl::nsServiceManagerImpl(void)
|
|
|
|
<nsImportedStringHandle>
|
|
__builtin_new
|
|
nsXPIDLCString::PrepareForUseAsOutParam(void)
|
|
|
|
<nsXBLJSClass>
|
|
__builtin_new
|
|
nsXBLBinding::InitClass
|
|
|
|
<Assertion>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
|
|
<nsXBLAttributeEntry>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsRuleNode
|
|
#
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
|
|
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AppendFromReadable(nsAString const &)
|
|
nsAString::do_AppendFromElementPtr(unsigned short const *)
|
|
nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AppendFromReadable(nsAString const &)
|
|
nsAString::do_AppendFromElementPtr(unsigned short const *)
|
|
nsRuleNode::ComputeBackgroundData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AppendFromReadable(nsAString const &)
|
|
nsAString::do_AppendFromElementPtr(unsigned short const *)
|
|
nsRuleNode::ComputeListData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
# This stuff will only show off if you've turned off the FrameArena
|
|
# in nsPresShell.cpp
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeOutlineData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeContentData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeTableData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeUIResetData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeXULData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::SetDefaultOnRoot(nsStyleStructID, nsIStyleContext *)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeListData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeTextData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeTextResetData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputePaddingData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeFontData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeVisibilityData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsRuleNode>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeColorData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsBookmarksService
|
|
#
|
|
|
|
<nsBookmarksService>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
InMemoryDataSource::Assert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
BookmarkParser::updateAtom(nsIRDFDataSource *, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int *)
|
|
|
|
<nsBookmarksService>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nsFixedSizeAllocator::Alloc(unsigned int)
|
|
Assertion::Create(nsFixedSizeAllocator &, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
InMemoryDataSource::Assert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
|
|
BookmarkParser::updateAtom(nsIRDFDataSource *, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# The following types will only be visible if nsPresShell.cpp is compiled
|
|
# with the DEBUG_TRACEMALLOC_FRAMEARENA defined.
|
|
#
|
|
|
|
<nsStyleContext>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStyleContext::SetStyle(nsStyleStructID, nsStyleStruct const &)
|
|
|
|
<nsStyleBorder>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStyleBorder::operator new(unsigned int, nsIPresContext *)
|
|
|
|
# XXX This one is a bit sloppy, and may include some of the other
|
|
# style data structs.
|
|
<nsResetStyleData>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsResetStyleData>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStyleContext::SetStyle(nsStyleStructID, nsStyleStruct const &)
|
|
|
|
<nsResetStyleData>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeBorderData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsStyleUserInterface>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeUIData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsStylePosition>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputePositionData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsStylePadding>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStylePadding::operator new(unsigned int, nsIPresContext *)
|
|
|
|
<nsStyleMargin>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStyleMargin::operator new(unsigned int, nsIPresContext *)
|
|
|
|
<nsStyleBackground>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeBackgroundData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsStyleBackground>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsStyleBackground::nsStyleBackground(nsStyleBackground const &)
|
|
|
|
# XXX this'll may be subsumed as nsResetStyleData
|
|
<nsStyleDisplay>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)
|
|
|
|
<nsStyleDisplay>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
nsStyleDisplay::nsStyleDisplay(nsStyleDisplay const &)
|
|
|
|
# ----------------------------------------------------------------------
|
|
# The following will only show up if you turn off the FrameArena
|
|
# in nsPresShell.cpp
|
|
<nsStyleContext>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStyleContext::GetUniqueStyleData(nsIPresContext *, nsStyleStructID const &)
|
|
|
|
<nsStyleFont>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsPresContext::AllocateFromShell(unsigned int, void **)
|
|
nsStyleFont::operator new(unsigned int, nsIPresContext *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# Frames
|
|
#
|
|
|
|
<nsLineBox>
|
|
__builtin_new
|
|
nsLineBox::SetCombinedArea(nsRect const &)
|
|
|
|
# This will only appear when the FrameArena is off.
|
|
<nsLineBox>
|
|
PR_Malloc
|
|
FrameArena::AllocateFrame(unsigned int, void **)
|
|
PresShell::AllocateFrame(unsigned int, void **)
|
|
nsLineBox::operator new(unsigned int, nsIPresShell *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsCacheService
|
|
#
|
|
|
|
<nsCacheService>
|
|
__builtin_new
|
|
nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **)
|
|
|
|
<nsCacheService>
|
|
__builtin_new
|
|
nsCacheEntry::CreateDescriptor(nsCacheRequest *, int, nsICacheEntryDescriptor **)
|
|
nsCacheService::ProcessRequest(nsCacheRequest *, int, nsICacheEntryDescriptor **)
|
|
|
|
<nsCacheService>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsCString::SetCapacity(unsigned int)
|
|
nsCString::SetLength(unsigned int)
|
|
nsACString::do_AppendFromReadable(nsACString const &)
|
|
nsACString::do_AppendFromElementPtr(char const *)
|
|
nsCacheService::CreateRequest(nsCacheSession *, char const *, int, int, nsICacheListener *, nsCacheRequest **)
|
|
|
|
<nsCacheService>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsCacheEntryHashTable::AddEntry(nsCacheEntry *)
|
|
nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **)
|
|
|
|
<nsCacheService>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsCacheMetaData>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableInit
|
|
nsCacheMetaData::Init(void)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsXMLMIMEDataSource
|
|
#
|
|
|
|
<nsXMLMIMEDataSource>
|
|
PR_Malloc
|
|
PL_ArenaFinish
|
|
PL_HashTableRawAdd
|
|
PL_HashTableAdd
|
|
nsXMLMIMEDataSource::InitFromFile(nsIFile *)
|
|
|
|
<nsXMLMIMEDataSource>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)
|
|
|
|
<nsXMLMIMEDataSource>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
|
|
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)
|
|
|
|
<nsXMLMIMEDataSource>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)
|
|
|
|
<nsXMLMIMEDataSource>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsCStringKey::Clone(void) const
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsRegion
|
|
#
|
|
|
|
<nsRegion>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
RgnRectMemoryAllocator::RgnRectMemoryAllocator(unsigned int)
|
|
nsRegion::Offset(int, int)
|
|
|
|
<nsRegion>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
RgnRectMemoryAllocator::Alloc(void)
|
|
nsRegion::Or(nsRegion const &, nsRectFast const &)
|
|
|
|
<nsRegion>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
RgnRectMemoryAllocator::Alloc(void)
|
|
nsRegion::SetToElements(unsigned int)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsCharsetMenu
|
|
#
|
|
|
|
<nsCharsetMenu>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsCharsetConverterManager::GetRegistryEnumeration2(char *, int, nsISupportsArray **)
|
|
nsCharsetConverterManager::GetEncoderList(nsISupportsArray **)
|
|
nsCharsetMenu::InitResources(void)
|
|
|
|
<nsCharsetMenu>
|
|
__builtin_new
|
|
nsCharsetMenu::AddCharsetToItemArray(nsVoidArray *, nsIAtom *, nsMenuEntry **, int)
|
|
|
|
<nsCharsetMenu>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsCharsetConverterManager::GetRegistryEnumeration2(char *, int, nsISupportsArray **)
|
|
nsCharsetConverterManager::GetDecoderList(nsISupportsArray **)
|
|
nsCharsetMenu::InitResources(void)
|
|
|
|
<nsCharsetMenu>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
InMemoryDataSource::AddObserver(nsIRDFObserver *)
|
|
nsCharsetMenu::AddObserver(nsIRDFObserver *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsLoadGroup
|
|
#
|
|
|
|
<nsLoadGroup>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsLoadGroup::AddRequest(nsIRequest *, nsISupports *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# Wallet
|
|
#
|
|
|
|
<Wallet>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
Wallet_Decrypt2
|
|
|
|
<Wallet>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::AssignFromReadable(nsAString const &)
|
|
Wallet_RandomName
|
|
|
|
<Wallet>
|
|
PR_Malloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
Wallet_RandomName
|
|
|
|
<Wallet>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
Wallet_Decrypt2
|
|
|
|
<Wallet>
|
|
__builtin_new
|
|
Wallet_RandomName
|
|
|
|
<Wallet>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
Wallet_Decrypt2
|
|
|
|
<Wallet>
|
|
PR_Realloc
|
|
nsVoidArray::SizeTo(int)
|
|
nsVoidArray::GrowArrayBy(int)
|
|
nsVoidArray::InsertElementAt(void *, int)
|
|
Wallet_RandomName
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsMemoryCacheDevice
|
|
#
|
|
|
|
<nsMemCacheRecord>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *)
|
|
nsMemoryCacheDevice::EvictEntry(nsCacheEntry *)
|
|
|
|
#----------------------------------------------------------------------
|
|
#
|
|
# nsSHEntry
|
|
#
|
|
|
|
<nsSHEntry>
|
|
PR_Malloc
|
|
nsMemoryImpl::Alloc(unsigned int)
|
|
nsMemory::Alloc(unsigned int)
|
|
nsStr::Alloc(nsStr &, unsigned int)
|
|
nsStr::Realloc(nsStr &, unsigned int)
|
|
nsStr::EnsureCapacity(nsStr &, unsigned int)
|
|
nsStr::GrowCapacity(nsStr &, unsigned int)
|
|
nsString::SetCapacity(unsigned int)
|
|
nsString::SetLength(unsigned int)
|
|
nsAString::do_AssignFromReadable(nsAString const &)
|
|
nsAString::do_AssignFromElementPtr(unsigned short const *)
|
|
nsSHEntry::SetTitle(unsigned short const *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
|
|
<nsOutlinerStyleCache>
|
|
PR_Malloc
|
|
PL_HashTableFinalize(PLHashTable *)
|
|
PL_HashTableRawAdd
|
|
nsHashtable::Put(nsHashKey *, void *)
|
|
nsOutlinerStyleCache::GetStyleContext(nsICSSPseudoComparator *, nsIPresContext *, nsIContent *, nsIStyleContext *, nsIAtom *, nsISupportsArray *, nsIStyleContext **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsMsgDatabase
|
|
#
|
|
|
|
<nsMsgDatabase>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsMsgDatabase::AddHdrToCache(nsIMsgDBHdr *, unsigned int)
|
|
|
|
<nsMsgDatabase>
|
|
PL_DHashAllocTable
|
|
PL_DHashTableFinish
|
|
PL_DHashTableOperate
|
|
nsMsgDatabase::AddHdrToUseCache(nsIMsgDBHdr *, unsigned int)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# nsMsgFolderDataSource
|
|
#
|
|
|
|
<nsMsgFolderDataSource>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
nsMsgFolderDataSource::getFolderArcLabelsOut(nsISupportsArray **)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# singsign
|
|
#
|
|
|
|
<SINGSIGN>
|
|
__builtin_new
|
|
SI_DeletePersistentUserData
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# LocalStoreImpl
|
|
#
|
|
|
|
<LocalStoreImpl>
|
|
__builtin_new
|
|
__builtin_vec_new
|
|
nsSupportsArray::GrowArrayBy(int)
|
|
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
|
|
nsSupportsArray::AppendElement(nsISupports *)
|
|
LocalStoreImpl::AddObserver(nsIRDFObserver *)
|
|
|
|
# ----------------------------------------------------------------------
|
|
#
|
|
# NSS
|
|
#
|
|
|
|
<NSS>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
PORT_ArenaAlloc
|
|
|
|
<NSS>
|
|
PR_Malloc
|
|
PL_ArenaAllocate
|
|
nss_ZAlloc
|