--- a/accessible/base/DocManager.cpp
+++ b/accessible/base/DocManager.cpp
@@ -32,17 +32,17 @@ using namespace mozilla;
using namespace mozilla::a11y;
using namespace mozilla::dom;
////////////////////////////////////////////////////////////////////////////////
// DocManager
////////////////////////////////////////////////////////////////////////////////
DocManager::DocManager()
- : mDocAccessibleCache(4)
+ : mDocAccessibleCache(2)
{
}
////////////////////////////////////////////////////////////////////////////////
// DocManager public
DocAccessible*
DocManager::GetDocAccessible(nsIDocument* aDocument)
--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -73,18 +73,18 @@ static const uint32_t kRelationAttrsLen
////////////////////////////////////////////////////////////////////////////////
// Constructor/desctructor
DocAccessible::
DocAccessible(nsIDocument* aDocument, nsIContent* aRootContent,
nsIPresShell* aPresShell) :
HyperTextAccessibleWrap(aRootContent, this),
// XXX aaronl should we use an algorithm for the initial cache size?
- mAccessibleCache(kDefaultCacheSize),
- mNodeToAccessibleMap(kDefaultCacheSize),
+ mAccessibleCache(kDefaultCacheLength),
+ mNodeToAccessibleMap(kDefaultCacheLength),
mDocumentNode(aDocument),
mScrollPositionChangedTicks(0),
mLoadState(eTreeConstructionPending), mDocFlags(0), mLoadEventType(0),
mVirtualCursor(nullptr),
mPresShell(aPresShell)
{
mGenericTypes |= eDocument;
mStateFlags |= eNotNodeMapEntry;
--- a/accessible/generic/DocAccessible.h
+++ b/accessible/generic/DocAccessible.h
@@ -21,17 +21,17 @@
#include "nsIScrollPositionListener.h"
#include "nsITimer.h"
#include "nsIWeakReference.h"
class nsAccessiblePivot;
class nsIScrollableView;
-const uint32_t kDefaultCacheSize = 256;
+const uint32_t kDefaultCacheLength = 128;
namespace mozilla {
namespace a11y {
class DocManager;
class NotificationController;
class RelatedAccIterator;
template<class Class, class Arg>
--- a/accessible/windows/msaa/nsWinUtils.cpp
+++ b/accessible/windows/msaa/nsWinUtils.cpp
@@ -56,17 +56,17 @@ bool
nsWinUtils::MaybeStartWindowEmulation()
{
// Register window class that'll be used for document accessibles associated
// with tabs.
if (Compatibility::IsJAWS() || Compatibility::IsWE() ||
Compatibility::IsDolphin() ||
XRE_GetProcessType() == GeckoProcessType_Content) {
RegisterNativeWindow(kClassNameTabContent);
- sHWNDCache = new nsRefPtrHashtable<nsPtrHashKey<void>, DocAccessible>(4);
+ sHWNDCache = new nsRefPtrHashtable<nsPtrHashKey<void>, DocAccessible>(2);
return true;
}
return false;
}
void
nsWinUtils::ShutdownWindowEmulation()
--- a/accessible/xul/XULTreeAccessible.cpp
+++ b/accessible/xul/XULTreeAccessible.cpp
@@ -37,17 +37,17 @@ using namespace mozilla::a11y;
////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible
////////////////////////////////////////////////////////////////////////////////
XULTreeAccessible::
XULTreeAccessible(nsIContent* aContent, DocAccessible* aDoc,
nsTreeBodyFrame* aTreeFrame) :
AccessibleWrap(aContent, aDoc),
- mAccessibleCache(kDefaultTreeCacheSize)
+ mAccessibleCache(kDefaultTreeCacheLength)
{
mType = eXULTreeType;
mGenericTypes |= eSelect;
nsCOMPtr<nsITreeView> view = aTreeFrame->GetExistingView();
mTreeView = view;
mTree = nsCoreUtils::GetTreeBoxObject(aContent);
--- a/accessible/xul/XULTreeAccessible.h
+++ b/accessible/xul/XULTreeAccessible.h
@@ -15,17 +15,17 @@ class nsTreeBodyFrame;
namespace mozilla {
namespace a11y {
/*
* A class the represents the XUL Tree widget.
*/
const uint32_t kMaxTreeColumns = 100;
-const uint32_t kDefaultTreeCacheSize = 256;
+const uint32_t kDefaultTreeCacheLength = 128;
/**
* Accessible class for XUL tree element.
*/
class XULTreeAccessible : public AccessibleWrap
{
public:
--- a/accessible/xul/XULTreeGridAccessible.cpp
+++ b/accessible/xul/XULTreeGridAccessible.cpp
@@ -256,17 +256,17 @@ XULTreeGridAccessible::CreateTreeItemAcc
// XULTreeGridRowAccessible
////////////////////////////////////////////////////////////////////////////////
XULTreeGridRowAccessible::
XULTreeGridRowAccessible(nsIContent* aContent, DocAccessible* aDoc,
Accessible* aTreeAcc, nsITreeBoxObject* aTree,
nsITreeView* aTreeView, int32_t aRow) :
XULTreeItemAccessibleBase(aContent, aDoc, aTreeAcc, aTree, aTreeView, aRow),
- mAccessibleCache(kDefaultTreeCacheSize)
+ mAccessibleCache(kDefaultTreeCacheLength)
{
mGenericTypes |= eTableRow;
}
XULTreeGridRowAccessible::~XULTreeGridRowAccessible()
{
}
--- a/chrome/nsChromeRegistryChrome.cpp
+++ b/chrome/nsChromeRegistryChrome.cpp
@@ -119,18 +119,17 @@ nsChromeRegistryChrome::Init()
{
nsresult rv = nsChromeRegistry::Init();
if (NS_FAILED(rv))
return rv;
mSelectedLocale = NS_LITERAL_CSTRING("en-US");
mSelectedSkin = NS_LITERAL_CSTRING("classic/1.0");
- PL_DHashTableInit(&mPackagesHash, &kTableOps,
- nullptr, sizeof(PackageEntry), 16);
+ PL_DHashTableInit(&mPackagesHash, &kTableOps, nullptr, sizeof(PackageEntry));
bool safeMode = false;
nsCOMPtr<nsIXULRuntime> xulrun (do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
if (xulrun)
xulrun->GetInSafeMode(&safeMode);
nsCOMPtr<nsIPrefService> prefserv (do_GetService(NS_PREFSERVICE_CONTRACTID));
nsCOMPtr<nsIPrefBranch> prefs;
--- a/content/base/src/nsContentList.cpp
+++ b/content/base/src/nsContentList.cpp
@@ -214,20 +214,18 @@ NS_GetContentList(nsINode* aRootNode,
ContentListHashtableMatchEntry,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// Initialize the hashtable if needed.
if (!gContentListHashTable.ops) {
- PL_DHashTableInit(&gContentListHashTable,
- &hash_table_ops, nullptr,
- sizeof(ContentListHashEntry),
- 16);
+ PL_DHashTableInit(&gContentListHashTable, &hash_table_ops, nullptr,
+ sizeof(ContentListHashEntry));
}
ContentListHashEntry *entry = nullptr;
// First we look in our hashtable. Then we create a content list if needed
if (gContentListHashTable.ops) {
// A PL_DHASH_ADD is equivalent to a PL_DHASH_LOOKUP for cases
// when the entry is already in the hashtable.
@@ -331,20 +329,18 @@ GetFuncStringContentList(nsINode* aRootN
FuncStringContentListHashtableMatchEntry,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// Initialize the hashtable if needed.
if (!gFuncStringContentListHashTable.ops) {
- PL_DHashTableInit(&gFuncStringContentListHashTable,
- &hash_table_ops, nullptr,
- sizeof(FuncStringContentListHashEntry),
- 16);
+ PL_DHashTableInit(&gFuncStringContentListHashTable, &hash_table_ops,
+ nullptr, sizeof(FuncStringContentListHashEntry));
}
FuncStringContentListHashEntry *entry = nullptr;
// First we look in our hashtable. Then we create a content list if needed
if (gFuncStringContentListHashTable.ops) {
nsFuncStringCacheKey hashKey(aRootNode, aFunc, aString);
// A PL_DHASH_ADD is equivalent to a PL_DHASH_LOOKUP for cases
--- a/content/base/src/nsContentUtils.cpp
+++ b/content/base/src/nsContentUtils.cpp
@@ -481,17 +481,17 @@ nsContentUtils::Init()
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
EventListenerManagerHashClearEntry,
PL_DHashFinalizeStub,
EventListenerManagerHashInitEntry
};
PL_DHashTableInit(&sEventListenerManagersHash, &hash_table_ops,
- nullptr, sizeof(EventListenerManagerMapEntry), 16);
+ nullptr, sizeof(EventListenerManagerMapEntry));
RegisterStrongMemoryReporter(new DOMEventListenerManagersHashReporter());
}
sBlockedScriptRunners = new nsTArray< nsCOMPtr<nsIRunnable> >;
Preferences::AddBoolVarCache(&sAllowXULXBL_for_file,
"dom.allow_XUL_XBL_for_file");
@@ -632,19 +632,19 @@ nsContentUtils::InitializeEventTable() {
#define NON_IDL_EVENT EVENT
#include "mozilla/EventNameList.h"
#undef WINDOW_ONLY_EVENT
#undef EVENT
{ nullptr }
};
sAtomEventTable = new nsDataHashtable<nsISupportsHashKey, EventNameMapping>(
- int(ArrayLength(eventArray) / 0.75) + 1);
+ ArrayLength(eventArray));
sStringEventTable = new nsDataHashtable<nsStringHashKey, EventNameMapping>(
- int(ArrayLength(eventArray) / 0.75) + 1);
+ ArrayLength(eventArray));
sUserDefinedEvents = new nsCOMArray<nsIAtom>(64);
// Subtract one from the length because of the trailing null
for (uint32_t i = 0; i < ArrayLength(eventArray) - 1; ++i) {
sAtomEventTable->Put(eventArray[i].mAtom, eventArray[i]);
sStringEventTable->Put(Substring(nsDependentAtomString(eventArray[i].mAtom), 2),
eventArray[i]);
}
--- a/content/base/src/nsDocument.cpp
+++ b/content/base/src/nsDocument.cpp
@@ -3736,17 +3736,17 @@ nsDocument::SetSubDocumentFor(Element* a
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
SubDocClearEntry,
PL_DHashFinalizeStub,
SubDocInitEntry
};
mSubDocuments = PL_NewDHashTable(&hash_table_ops, nullptr,
- sizeof(SubDocMapEntry), 16);
+ sizeof(SubDocMapEntry));
if (!mSubDocuments) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
// Add a mapping to the hash table
SubDocMapEntry *entry =
static_cast<SubDocMapEntry*>
@@ -6813,17 +6813,17 @@ nsDocument::GetBoxObjectFor(Element* aEl
mHasWarnedAboutBoxObjects = true;
nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
NS_LITERAL_CSTRING("BoxObjects"), this,
nsContentUtils::eDOM_PROPERTIES,
"UseOfGetBoxObjectForWarning");
}
if (!mBoxObjectTable) {
- mBoxObjectTable = new nsInterfaceHashtable<nsPtrHashKey<nsIContent>, nsPIBoxObject>(12);
+ mBoxObjectTable = new nsInterfaceHashtable<nsPtrHashKey<nsIContent>, nsPIBoxObject>(6);
} else {
nsCOMPtr<nsPIBoxObject> boxObject = mBoxObjectTable->Get(aElement);
if (boxObject) {
return boxObject.forget();
}
}
int32_t namespaceID;
--- a/content/base/src/nsPropertyTable.cpp
+++ b/content/base/src/nsPropertyTable.cpp
@@ -289,17 +289,17 @@ nsPropertyTable::PropertyList::PropertyL
bool aTransfer)
: mName(aName),
mDtorFunc(aDtorFunc),
mDtorData(aDtorData),
mTransfer(aTransfer),
mNext(nullptr)
{
PL_DHashTableInit(&mObjectValueMap, PL_DHashGetStubOps(), this,
- sizeof(PropertyListMapEntry), 16);
+ sizeof(PropertyListMapEntry));
}
nsPropertyTable::PropertyList::~PropertyList()
{
PL_DHashTableFinish(&mObjectValueMap);
}
--- a/content/html/content/src/HTMLFormControlsCollection.cpp
+++ b/content/html/content/src/HTMLFormControlsCollection.cpp
@@ -69,17 +69,17 @@ HTMLFormControlsCollection::ShouldBeInEl
return false;
}
HTMLFormControlsCollection::HTMLFormControlsCollection(HTMLFormElement* aForm)
: mForm(aForm)
// Initialize the elements list to have an initial capacity
// of 8 to reduce allocations on small forms.
, mElements(8)
- , mNameLookupTable(HTMLFormElement::FORM_CONTROL_LIST_HASHTABLE_SIZE)
+ , mNameLookupTable(HTMLFormElement::FORM_CONTROL_LIST_HASHTABLE_LENGTH)
{
SetIsDOMBinding();
}
HTMLFormControlsCollection::~HTMLFormControlsCollection()
{
mForm = nullptr;
Clear();
--- a/content/html/content/src/HTMLFormElement.cpp
+++ b/content/html/content/src/HTMLFormElement.cpp
@@ -81,34 +81,34 @@ static const nsAttrValue::EnumTable kFor
static const nsAttrValue::EnumTable* kFormDefaultAutocomplete = &kFormAutocompleteTable[0];
bool HTMLFormElement::gFirstFormSubmitted = false;
bool HTMLFormElement::gPasswordManagerInitialized = false;
HTMLFormElement::HTMLFormElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: nsGenericHTMLElement(aNodeInfo),
mControls(new HTMLFormControlsCollection(MOZ_THIS_IN_INITIALIZER_LIST())),
- mSelectedRadioButtons(4),
- mRequiredRadioButtonCounts(4),
- mValueMissingRadioGroups(4),
+ mSelectedRadioButtons(2),
+ mRequiredRadioButtonCounts(2),
+ mValueMissingRadioGroups(2),
mGeneratingSubmit(false),
mGeneratingReset(false),
mIsSubmitting(false),
mDeferSubmission(false),
mNotifiedObservers(false),
mNotifiedObserversResult(false),
mSubmitPopupState(openAbused),
mSubmitInitiatedFromUserInput(false),
mPendingSubmission(nullptr),
mSubmittingRequest(nullptr),
mDefaultSubmitElement(nullptr),
mFirstSubmitInElements(nullptr),
mFirstSubmitNotInElements(nullptr),
- mImageNameLookupTable(FORM_CONTROL_LIST_HASHTABLE_SIZE),
- mPastNameLookupTable(FORM_CONTROL_LIST_HASHTABLE_SIZE),
+ mImageNameLookupTable(FORM_CONTROL_LIST_HASHTABLE_LENGTH),
+ mPastNameLookupTable(FORM_CONTROL_LIST_HASHTABLE_LENGTH),
mInvalidElementsCount(0),
mEverTriedInvalidSubmit(false)
{
}
HTMLFormElement::~HTMLFormElement()
{
if (mControls) {
--- a/content/html/content/src/HTMLFormElement.h
+++ b/content/html/content/src/HTMLFormElement.h
@@ -40,17 +40,17 @@ class HTMLFormElement MOZ_FINAL : public
public nsIRadioGroupContainer
{
friend class HTMLFormControlsCollection;
public:
HTMLFormElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
enum {
- FORM_CONTROL_LIST_HASHTABLE_SIZE = 16
+ FORM_CONTROL_LIST_HASHTABLE_LENGTH = 8
};
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
// nsIDOMHTMLFormElement
NS_DECL_NSIDOMHTMLFORMELEMENT
--- a/content/xul/document/src/XULDocument.cpp
+++ b/content/xul/document/src/XULDocument.cpp
@@ -792,18 +792,17 @@ XULDocument::AddBroadcastListenerFor(Ele
PL_DHashMoveEntryStub,
ClearBroadcasterMapEntry,
PL_DHashFinalizeStub,
nullptr
};
if (! mBroadcasterMap) {
mBroadcasterMap =
- PL_NewDHashTable(&gOps, nullptr, sizeof(BroadcasterMapEntry),
- PL_DHASH_MIN_SIZE);
+ PL_NewDHashTable(&gOps, nullptr, sizeof(BroadcasterMapEntry));
if (! mBroadcasterMap) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
}
BroadcasterMapEntry* entry =
--- a/content/xul/templates/src/nsContentSupportMap.cpp
+++ b/content/xul/templates/src/nsContentSupportMap.cpp
@@ -4,34 +4,33 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsContentSupportMap.h"
#include "nsXULElement.h"
void
nsContentSupportMap::Init()
{
- PL_DHashTableInit(&mMap, PL_DHashGetStubOps(), nullptr,
- sizeof(Entry), PL_DHASH_MIN_SIZE);
+ PL_DHashTableInit(&mMap, PL_DHashGetStubOps(), nullptr, sizeof(Entry));
}
void
nsContentSupportMap::Finish()
{
if (mMap.ops)
PL_DHashTableFinish(&mMap);
}
nsresult
nsContentSupportMap::Remove(nsIContent* aElement)
{
if (!mMap.ops)
return NS_ERROR_NOT_INITIALIZED;
- nsIContent* child = aElement;
+ nsIContent* child = aElement;
do {
PL_DHashTableOperate(&mMap, child, PL_DHASH_REMOVE);
child = child->GetNextNode(aElement);
} while(child);
return NS_OK;
}
--- a/content/xul/templates/src/nsTemplateMap.h
+++ b/content/xul/templates/src/nsTemplateMap.h
@@ -15,17 +15,21 @@ protected:
PLDHashEntryHdr mHdr;
nsIContent* mContent;
nsIContent* mTemplate;
};
PLDHashTable mTable;
void
- Init() { PL_DHashTableInit(&mTable, PL_DHashGetStubOps(), nullptr, sizeof(Entry), PL_DHASH_MIN_SIZE); }
+ Init()
+ {
+ PL_DHashTableInit(&mTable, PL_DHashGetStubOps(), nullptr,
+ sizeof(Entry));
+ }
void
Finish() { PL_DHashTableFinish(&mTable); }
public:
nsTemplateMap() { Init(); }
~nsTemplateMap() { Finish(); }
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -1607,17 +1607,17 @@ nsDOMWindowUtils::GetTranslationNodes(ns
NS_ENSURE_STATE(root);
nsCOMPtr<nsIDocument> doc = GetDocument();
NS_ENSURE_STATE(doc);
if (root->OwnerDoc() != doc) {
return NS_ERROR_DOM_WRONG_DOCUMENT_ERR;
}
- nsTHashtable<nsPtrHashKey<nsIContent>> translationNodesHash(1000);
+ nsTHashtable<nsPtrHashKey<nsIContent>> translationNodesHash(500);
nsRefPtr<nsTranslationNodeList> list = new nsTranslationNodeList;
uint32_t limit = 15000;
// We begin iteration with content->GetNextNode because we want to explictly
// skip the root tag from being a translation node.
nsIContent* content = root;
while ((limit > 0) && (content = content->GetNextNode(root))) {
--- a/dom/base/nsScriptNameSpaceManager.cpp
+++ b/dom/base/nsScriptNameSpaceManager.cpp
@@ -309,17 +309,17 @@ nsScriptNameSpaceManager::RegisterInterf
}
s->mType = nsGlobalNameStruct::eTypeInterface;
s->mIID = *aIfIID;
return NS_OK;
}
-#define GLOBALNAME_HASHTABLE_INITIAL_SIZE 1024
+#define GLOBALNAME_HASHTABLE_INITIAL_LENGTH 512
nsresult
nsScriptNameSpaceManager::Init()
{
static const PLDHashTableOps hash_table_ops =
{
PL_DHashAllocTable,
PL_DHashFreeTable,
@@ -328,24 +328,24 @@ nsScriptNameSpaceManager::Init()
PL_DHashMoveEntryStub,
GlobalNameHashClearEntry,
PL_DHashFinalizeStub,
GlobalNameHashInitEntry
};
mIsInitialized = PL_DHashTableInit(&mGlobalNames, &hash_table_ops,
nullptr, sizeof(GlobalNameMapEntry),
- GLOBALNAME_HASHTABLE_INITIAL_SIZE,
- fallible_t());
+ fallible_t(),
+ GLOBALNAME_HASHTABLE_INITIAL_LENGTH);
NS_ENSURE_TRUE(mIsInitialized, NS_ERROR_OUT_OF_MEMORY);
mIsInitialized = PL_DHashTableInit(&mNavigatorNames, &hash_table_ops,
nullptr, sizeof(GlobalNameMapEntry),
- GLOBALNAME_HASHTABLE_INITIAL_SIZE,
- fallible_t());
+ fallible_t(),
+ GLOBALNAME_HASHTABLE_INITIAL_LENGTH);
if (!mIsInitialized) {
PL_DHashTableFinish(&mGlobalNames);
return NS_ERROR_OUT_OF_MEMORY;
}
RegisterWeakMemoryReporter(this);
--- a/dom/indexedDB/Client.cpp
+++ b/dom/indexedDB/Client.cpp
@@ -56,17 +56,17 @@ Client::InitOrigin(PersistenceType aPers
GetDirectory(aPersistenceType, aOrigin, getter_AddRefs(directory));
NS_ENSURE_SUCCESS(rv, rv);
// We need to see if there are any files in the directory already. If they
// are database files then we need to cleanup stored files (if it's needed)
// and also get the usage.
nsAutoTArray<nsString, 20> subdirsToProcess;
- nsAutoTArray<nsCOMPtr<nsIFile> , 20> unknownFiles;
+ nsAutoTArray<nsCOMPtr<nsIFile>, 20> unknownFiles;
nsTHashtable<nsStringHashKey> validSubdirs(20);
nsCOMPtr<nsISimpleEnumerator> entries;
rv = directory->GetDirectoryEntries(getter_AddRefs(entries));
NS_ENSURE_SUCCESS(rv, rv);
bool hasMore;
while (NS_SUCCEEDED((rv = entries->HasMoreElements(&hasMore))) &&
--- a/dom/plugins/base/nsJSNPRuntime.cpp
+++ b/dom/plugins/base/nsJSNPRuntime.cpp
@@ -1720,17 +1720,17 @@ nsNPObjWrapper::GetNewOrUsed(NPP npp, JS
NS_ERROR("No npp passed to nsNPObjWrapper::GetNewOrUsed()!");
return nullptr;
}
if (!sNPObjWrappers.ops) {
// No hash yet (or any more), initialize it.
PL_DHashTableInit(&sNPObjWrappers, PL_DHashGetStubOps(), nullptr,
- sizeof(NPObjWrapperHashEntry), 16);
+ sizeof(NPObjWrapperHashEntry));
}
NPObjWrapperHashEntry *entry = static_cast<NPObjWrapperHashEntry *>
(PL_DHashTableOperate(&sNPObjWrappers, npobj, PL_DHASH_ADD));
if (!entry) {
// Out of memory
JS_ReportOutOfMemory(cx);
--- a/dom/src/storage/DOMStorageManager.cpp
+++ b/dom/src/storage/DOMStorageManager.cpp
@@ -93,17 +93,17 @@ PrincipalsEqual(nsIPrincipal* aObjectPri
return aSubjectPrincipal->Equals(aObjectPrincipal);
}
NS_IMPL_ISUPPORTS(DOMStorageManager,
nsIDOMStorageManager)
DOMStorageManager::DOMStorageManager(DOMStorage::StorageType aType)
- : mCaches(10)
+ : mCaches(8)
, mType(aType)
, mLowDiskSpace(false)
{
DOMStorageObserver* observer = DOMStorageObserver::Self();
NS_ASSERTION(observer, "No DOMStorageObserver, cannot observe private data delete notifications!");
if (observer) {
observer->AddSink(this);
--- a/dom/xbl/nsBindingManager.cpp
+++ b/dom/xbl/nsBindingManager.cpp
@@ -485,17 +485,17 @@ nsBindingManager::ExecuteDetachedHandler
}
nsresult
nsBindingManager::PutXBLDocumentInfo(nsXBLDocumentInfo* aDocumentInfo)
{
NS_PRECONDITION(aDocumentInfo, "Must have a non-null documentinfo!");
if (!mDocumentTable) {
- mDocumentTable = new nsRefPtrHashtable<nsURIHashKey,nsXBLDocumentInfo>(16);
+ mDocumentTable = new nsRefPtrHashtable<nsURIHashKey,nsXBLDocumentInfo>();
}
mDocumentTable->Put(aDocumentInfo->DocumentURI(), aDocumentInfo);
return NS_OK;
}
void
@@ -516,17 +516,18 @@ nsBindingManager::GetXBLDocumentInfo(nsI
}
nsresult
nsBindingManager::PutLoadingDocListener(nsIURI* aURL, nsIStreamListener* aListener)
{
NS_PRECONDITION(aListener, "Must have a non-null listener!");
if (!mLoadingDocTable) {
- mLoadingDocTable = new nsInterfaceHashtable<nsURIHashKey,nsIStreamListener>(16);
+ mLoadingDocTable =
+ new nsInterfaceHashtable<nsURIHashKey,nsIStreamListener>();
}
mLoadingDocTable->Put(aURL, aListener);
return NS_OK;
}
nsIStreamListener*
nsBindingManager::GetLoadingDocListener(nsIURI* aURL)
--- a/dom/xbl/nsXBLPrototypeBinding.cpp
+++ b/dom/xbl/nsXBLPrototypeBinding.cpp
@@ -593,28 +593,29 @@ nsXBLPrototypeBinding::GetRuleProcessor(
return nullptr;
}
void
nsXBLPrototypeBinding::EnsureAttributeTable()
{
if (!mAttributeTable) {
- mAttributeTable = new nsClassHashtable<nsUint32HashKey, InnerAttributeTable>(4);
+ mAttributeTable =
+ new nsClassHashtable<nsUint32HashKey, InnerAttributeTable>(2);
}
}
void
nsXBLPrototypeBinding::AddToAttributeTable(int32_t aSourceNamespaceID, nsIAtom* aSourceTag,
int32_t aDestNamespaceID, nsIAtom* aDestTag,
nsIContent* aContent)
{
InnerAttributeTable* attributesNS = mAttributeTable->Get(aSourceNamespaceID);
if (!attributesNS) {
- attributesNS = new InnerAttributeTable(4);
+ attributesNS = new InnerAttributeTable(2);
mAttributeTable->Put(aSourceNamespaceID, attributesNS);
}
nsXBLAttributeEntry* xblAttr =
new nsXBLAttributeEntry(aSourceTag, aDestTag, aDestNamespaceID, aContent);
nsXBLAttributeEntry* entry = attributesNS->Get(aSourceTag);
if (!entry) {
--- a/dom/xslt/xslt/txExecutionState.h
+++ b/dom/xslt/xslt/txExecutionState.h
@@ -52,17 +52,17 @@ public:
nsAutoPtr<txXPathNode> mDocument;
nsresult mLoadResult;
};
class txLoadedDocumentsHash : public nsTHashtable<txLoadedDocumentEntry>
{
public:
txLoadedDocumentsHash()
- : nsTHashtable<txLoadedDocumentEntry>(8),
+ : nsTHashtable<txLoadedDocumentEntry>(4),
mSourceDocument(nullptr)
{
}
~txLoadedDocumentsHash();
void init(txXPathNode* aSourceDocument);
private:
friend class txExecutionState;
--- a/dom/xslt/xslt/txKey.h
+++ b/dom/xslt/xslt/txKey.h
@@ -174,17 +174,17 @@ private:
txExpandedName mName;
};
class txKeyHash
{
public:
txKeyHash(const txOwningExpandedNameMap<txXSLKey>& aKeys)
- : mKeyValues(8)
+ : mKeyValues(4)
, mIndexedKeys(1)
, mKeys(aKeys)
{
}
nsresult init();
nsresult getKeyNodes(const txExpandedName& aKeyName,
--- a/embedding/components/commandhandler/src/nsCommandParams.cpp
+++ b/embedding/components/commandhandler/src/nsCommandParams.cpp
@@ -37,18 +37,18 @@ nsCommandParams::nsCommandParams()
nsCommandParams::~nsCommandParams()
{
PL_DHashTableFinish(&mValuesHash);
}
nsresult
nsCommandParams::Init()
{
- PL_DHashTableInit(&mValuesHash, &sHashOps, (void *)this, sizeof(HashEntry), 4);
-
+ PL_DHashTableInit(&mValuesHash, &sHashOps, (void *)this,
+ sizeof(HashEntry), 2);
return NS_OK;
}
#if 0
#pragma mark -
#endif
/* short getValueType (in string name); */
@@ -258,43 +258,41 @@ nsCommandParams::GetNamedEntry(const cha
return nullptr;
}
nsCommandParams::HashEntry*
nsCommandParams::GetIndexedEntry(int32_t index)
{
HashEntry* entry = reinterpret_cast<HashEntry*>(mValuesHash.entryStore);
- HashEntry* limit = entry + PL_DHASH_TABLE_SIZE(&mValuesHash);
+ HashEntry* limit = entry + PL_DHASH_TABLE_CAPACITY(&mValuesHash);
uint32_t entryCount = 0;
-
- do
- {
+
+ do {
if (!PL_DHASH_ENTRY_IS_LIVE(entry))
continue;
if ((int32_t)entryCount == index)
return entry;
-
+
entryCount ++;
} while (++entry < limit);
return nullptr;
}
uint32_t
nsCommandParams::GetNumEntries()
{
HashEntry* entry = reinterpret_cast<HashEntry*>(mValuesHash.entryStore);
- HashEntry* limit = entry + PL_DHASH_TABLE_SIZE(&mValuesHash);
+ HashEntry* limit = entry + PL_DHASH_TABLE_CAPACITY(&mValuesHash);
uint32_t entryCount = 0;
-
- do
- {
+
+ do {
if (PL_DHASH_ENTRY_IS_LIVE(entry))
entryCount ++;
} while (++entry < limit);
return entryCount;
}
nsresult
--- a/embedding/components/commandhandler/src/nsControllerCommandTable.cpp
+++ b/embedding/components/commandhandler/src/nsControllerCommandTable.cpp
@@ -8,21 +8,21 @@
#include "nsControllerCommandTable.h"
// prototype;
nsresult
NS_NewControllerCommandTable(nsIControllerCommandTable** aResult);
// this value is used to size the hash table. Just a sensible upper bound
-#define NUM_COMMANDS_BOUNDS 64
+#define NUM_COMMANDS_LENGTH 32
nsControllerCommandTable::nsControllerCommandTable()
-: mCommandsTable(NUM_COMMANDS_BOUNDS)
+: mCommandsTable(NUM_COMMANDS_LENGTH)
, mMutable(true)
{
}
nsControllerCommandTable::~nsControllerCommandTable()
{
}
--- a/gfx/thebes/gfxDWriteFonts.cpp
+++ b/gfx/thebes/gfxDWriteFonts.cpp
@@ -578,17 +578,17 @@ gfxDWriteFont::ProvidesGlyphWidths() con
return !mUseSubpixelPositions ||
(mFontFace->GetSimulations() & DWRITE_FONT_SIMULATIONS_BOLD);
}
int32_t
gfxDWriteFont::GetGlyphWidth(gfxContext *aCtx, uint16_t aGID)
{
if (!mGlyphWidths) {
- mGlyphWidths = new nsDataHashtable<nsUint32HashKey,int32_t>(200);
+ mGlyphWidths = new nsDataHashtable<nsUint32HashKey,int32_t>(128);
}
int32_t width = -1;
if (mGlyphWidths->Get(aGID, &width)) {
return width;
}
width = NS_lround(MeasureGlyphWidth(aGID) * 65536.0);
--- a/gfx/thebes/gfxFT2Fonts.cpp
+++ b/gfx/thebes/gfxFT2Fonts.cpp
@@ -157,17 +157,17 @@ gfxFT2Font::AddRange(const char16_t *aTe
}
}
gfxFT2Font::gfxFT2Font(cairo_scaled_font_t *aCairoFont,
FT2FontEntry *aFontEntry,
const gfxFontStyle *aFontStyle,
bool aNeedsBold)
: gfxFT2FontBase(aCairoFont, aFontEntry, aFontStyle)
- , mCharGlyphCache(64)
+ , mCharGlyphCache(32)
{
NS_ASSERTION(mFontEntry, "Unable to find font entry for font. Something is whack.");
mApplySyntheticBold = aNeedsBold;
}
gfxFT2Font::~gfxFT2Font()
{
}
--- a/gfx/thebes/gfxFont.cpp
+++ b/gfx/thebes/gfxFont.cpp
@@ -668,17 +668,17 @@ gfxFontEntry::FontTableHashEntry::GetBlo
}
bool
gfxFontEntry::GetExistingFontTable(uint32_t aTag, hb_blob_t **aBlob)
{
if (!mFontTableCache) {
// we do this here rather than on fontEntry construction
// because not all shapers will access the table cache at all
- mFontTableCache = new nsTHashtable<FontTableHashEntry>(10);
+ mFontTableCache = new nsTHashtable<FontTableHashEntry>(8);
}
FontTableHashEntry *entry = mFontTableCache->GetEntry(aTag);
if (!entry) {
return false;
}
*aBlob = entry->GetBlob();
@@ -687,17 +687,17 @@ gfxFontEntry::GetExistingFontTable(uint3
hb_blob_t *
gfxFontEntry::ShareFontTableAndGetBlob(uint32_t aTag,
FallibleTArray<uint8_t>* aBuffer)
{
if (MOZ_UNLIKELY(!mFontTableCache)) {
// we do this here rather than on fontEntry construction
// because not all shapers will access the table cache at all
- mFontTableCache = new nsTHashtable<FontTableHashEntry>(10);
+ mFontTableCache = new nsTHashtable<FontTableHashEntry>(8);
}
FontTableHashEntry *entry = mFontTableCache->PutEntry(aTag);
if (MOZ_UNLIKELY(!entry)) { // OOM
return nullptr;
}
if (!aBuffer) {
--- a/gfx/thebes/gfxFontFeatures.cpp
+++ b/gfx/thebes/gfxFontFeatures.cpp
@@ -5,17 +5,17 @@
#include "gfxFontFeatures.h"
#include "nsUnicharUtils.h"
#include "nsHashKeys.h"
using namespace mozilla;
gfxFontFeatureValueSet::gfxFontFeatureValueSet()
- : mFontFeatureValues(10)
+ : mFontFeatureValues(8)
{
}
bool
gfxFontFeatureValueSet::GetFontFeatureValuesFor(const nsAString& aFamily,
uint32_t aVariantProperty,
const nsAString& aName,
nsTArray<uint32_t>& aValues)
--- a/gfx/thebes/gfxFontconfigUtils.cpp
+++ b/gfx/thebes/gfxFontconfigUtils.cpp
@@ -308,19 +308,19 @@ gfxFontconfigUtils::NewPattern(const nsT
AddWeakString(pattern, FC_FAMILY, family.get());
}
}
return pattern.out();
}
gfxFontconfigUtils::gfxFontconfigUtils()
- : mFontsByFamily(50)
- , mFontsByFullname(50)
- , mLangSupportTable(50)
+ : mFontsByFamily(32)
+ , mFontsByFullname(32)
+ , mLangSupportTable(32)
, mLastConfig(nullptr)
#ifdef MOZ_BUNDLED_FONTS
, mBundledFontsInitialized(false)
#endif
{
UpdateFontListInternal();
}
--- a/gfx/thebes/gfxGDIFont.cpp
+++ b/gfx/thebes/gfxGDIFont.cpp
@@ -426,17 +426,17 @@ gfxGDIFont::GetGlyph(uint32_t aUnicode,
// We don't support variation selector sequences or non-BMP characters
// in the legacy bitmap, vector or postscript fonts that might use
// this code path.
if (aUnicode > 0xffff || aVarSelector) {
return 0;
}
if (!mGlyphIDs) {
- mGlyphIDs = new nsDataHashtable<nsUint32HashKey,uint32_t>(128);
+ mGlyphIDs = new nsDataHashtable<nsUint32HashKey,uint32_t>(64);
}
uint32_t gid;
if (mGlyphIDs->Get(aUnicode, &gid)) {
return gid;
}
wchar_t ch = aUnicode;
@@ -454,17 +454,17 @@ gfxGDIFont::GetGlyph(uint32_t aUnicode,
mGlyphIDs->Put(aUnicode, glyph);
return glyph;
}
int32_t
gfxGDIFont::GetGlyphWidth(gfxContext *aCtx, uint16_t aGID)
{
if (!mGlyphWidths) {
- mGlyphWidths = new nsDataHashtable<nsUint32HashKey,int32_t>(200);
+ mGlyphWidths = new nsDataHashtable<nsUint32HashKey,int32_t>(128);
}
int32_t width;
if (mGlyphWidths->Get(aGID, &width)) {
return width;
}
DCFromContext dc(aCtx);
--- a/gfx/thebes/gfxGDIFontList.cpp
+++ b/gfx/thebes/gfxGDIFontList.cpp
@@ -567,17 +567,17 @@ GDIFontFamily::FindStyleVariations(FontI
/***************************************************************
*
* gfxGDIFontList
*
*/
gfxGDIFontList::gfxGDIFontList()
- : mFontSubstitutes(50)
+ : mFontSubstitutes(32)
{
#ifdef MOZ_BUNDLED_FONTS
ActivateBundledFonts();
#endif
}
static void
RemoveCharsetFromFontSubstitute(nsAString &aName)
--- a/gfx/thebes/gfxPangoFonts.cpp
+++ b/gfx/thebes/gfxPangoFonts.cpp
@@ -910,17 +910,17 @@ gfxFcFontSet::SortPreferredFonts(bool &a
// FcDefaultSubstitute() ensures a slant on mSortPattern, but, if that ever
// doesn't happen, Roman will be used.
int requestedSlant = FC_SLANT_ROMAN;
FcPatternGetInteger(mSortPattern, FC_SLANT, 0, &requestedSlant);
double requestedSize = -1.0;
FcPatternGetDouble(mSortPattern, FC_PIXEL_SIZE, 0, &requestedSize);
- nsTHashtable<gfxFontconfigUtils::DepFcStrEntry> existingFamilies(50);
+ nsTHashtable<gfxFontconfigUtils::DepFcStrEntry> existingFamilies(32);
FcChar8 *family;
for (int v = 0;
FcPatternGetString(mSortPattern,
FC_FAMILY, v, &family) == FcResultMatch; ++v) {
const nsTArray< nsCountedRef<FcPattern> > *familyFonts = nullptr;
// Is this an @font-face family?
bool isUserFont = false;
--- a/gfx/thebes/gfxPlatformFontList.cpp
+++ b/gfx/thebes/gfxPlatformFontList.cpp
@@ -162,18 +162,18 @@ gfxPlatformFontList::MemoryReporter::Col
NS_LITERAL_CSTRING("Memory used for cached font metrics and layout tables."),
aClosure);
}
return NS_OK;
}
gfxPlatformFontList::gfxPlatformFontList(bool aNeedFullnamePostscriptNames)
- : mFontFamilies(100), mOtherFamilyNames(30),
- mPrefFonts(10), mBadUnderlineFamilyNames(10), mSharedCmaps(16),
+ : mFontFamilies(64), mOtherFamilyNames(16),
+ mPrefFonts(8), mBadUnderlineFamilyNames(8), mSharedCmaps(8),
mStartIndex(0), mIncrement(1), mNumFamilies(0)
{
mOtherFamilyNamesInitialized = false;
if (aNeedFullnamePostscriptNames) {
mExtraNames = new ExtraNames();
}
mFaceNameListsInitialized = false;
@@ -392,17 +392,17 @@ gfxPlatformFontList::LookupInFaceNameLis
}
}
// lookup in name lookup tables, return null if not found
if (!(lookup = FindFaceName(aFaceName))) {
// names not completely initialized, so keep track of lookup misses
if (!mFaceNameListsInitialized) {
if (!mFaceNamesMissed) {
- mFaceNamesMissed = new nsTHashtable<nsStringHashKey>(4);
+ mFaceNamesMissed = new nsTHashtable<nsStringHashKey>(2);
}
mFaceNamesMissed->PutEntry(aFaceName);
}
}
return lookup;
}
@@ -411,17 +411,17 @@ gfxPlatformFontList::PreloadNamesList()
{
nsAutoTArray<nsString, 10> preloadFonts;
gfxFontUtils::GetPrefsFontList("font.preload-names-list", preloadFonts);
uint32_t numFonts = preloadFonts.Length();
for (uint32_t i = 0; i < numFonts; i++) {
nsAutoString key;
GenerateFontListKey(preloadFonts[i], key);
-
+
// only search canonical names!
gfxFontFamily *familyEntry = mFontFamilies.GetWeak(key);
if (familyEntry) {
familyEntry->ReadOtherFamilyNames(this);
}
}
}
@@ -755,17 +755,17 @@ gfxPlatformFontList::FindFamily(const ns
if (!mOtherFamilyNamesInitialized && !IsASCII(aFamily)) {
InitOtherFamilyNames();
if ((familyEntry = mOtherFamilyNames.GetWeak(key)) != nullptr) {
return CheckFamily(familyEntry);
} else if (!mOtherFamilyNamesInitialized) {
// localized family names load timed out, add name to list of
// names to check after localized names are loaded
if (!mOtherNamesMissed) {
- mOtherNamesMissed = new nsTHashtable<nsStringHashKey>(4);
+ mOtherNamesMissed = new nsTHashtable<nsStringHashKey>(2);
}
mOtherNamesMissed->PutEntry(key);
}
}
return nullptr;
}
--- a/gfx/thebes/gfxPlatformFontList.h
+++ b/gfx/thebes/gfxPlatformFontList.h
@@ -298,17 +298,17 @@ protected:
// flag set after InitOtherFamilyNames is called upon first name lookup miss
bool mOtherFamilyNamesInitialized;
// flag set after fullname and Postcript name lists are populated
bool mFaceNameListsInitialized;
struct ExtraNames {
- ExtraNames() : mFullnames(100), mPostscriptNames(100) {}
+ ExtraNames() : mFullnames(64), mPostscriptNames(64) {}
// fullname ==> font entry (unique, one name per font entry)
nsRefPtrHashtable<nsStringHashKey, gfxFontEntry> mFullnames;
// Postscript name ==> font entry (unique, one name per font entry)
nsRefPtrHashtable<nsStringHashKey, gfxFontEntry> mPostscriptNames;
};
nsAutoPtr<ExtraNames> mExtraNames;
// face names missed when face name loading takes a long time
--- a/gfx/thebes/gfxUserFontSet.cpp
+++ b/gfx/thebes/gfxUserFontSet.cpp
@@ -560,17 +560,17 @@ gfxProxyFontEntry::LoadFont(gfxMixedFont
// The downloaded data can now be discarded; the font entry is using the
// sanitized copy
NS_Free((void*)aFontData);
return fe;
}
gfxUserFontSet::gfxUserFontSet()
- : mFontFamilies(5), mLocalRulesUsed(false)
+ : mFontFamilies(4), mLocalRulesUsed(false)
{
IncrementGeneration();
gfxPlatformFontList *fp = gfxPlatformFontList::PlatformFontList();
if (fp) {
fp->AddUserFontSet(this);
}
}
--- a/gfx/thebes/gfxWindowsPlatform.cpp
+++ b/gfx/thebes/gfxWindowsPlatform.cpp
@@ -287,17 +287,17 @@ public:
return NS_OK;
}
};
NS_IMPL_ISUPPORTS(GPUAdapterReporter, nsIMemoryReporter)
gfxWindowsPlatform::gfxWindowsPlatform()
: mD3D11DeviceInitialized(false)
- , mPrefFonts(50)
+ , mPrefFonts(32)
{
mUseClearTypeForDownloadableFonts = UNINITIALIZED_VALUE;
mUseClearTypeAlways = UNINITIALIZED_VALUE;
mUsingGDIFonts = false;
/*
* Initialize COM
--- a/js/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/xpconnect/loader/mozJSComponentLoader.cpp
@@ -304,19 +304,19 @@ ReportOnCaller(JSCLContextHelper &helper
helper.reportErrorAfterPop(buf);
return NS_OK;
}
mozJSComponentLoader::mozJSComponentLoader()
: mRuntime(nullptr),
mContext(nullptr),
- mModules(32),
- mImports(32),
- mInProgressImports(32),
+ mModules(16),
+ mImports(16),
+ mInProgressImports(16),
mInitialized(false),
mReuseLoaderGlobal(false)
{
MOZ_ASSERT(!sSelf, "mozJSComponentLoader should be a singleton");
#ifdef PR_LOGGING
if (!gJSCLLog) {
gJSCLLog = PR_NewLogModule("JSComponentLoader");
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/js/xpconnect/src/XPCJSRuntime.cpp
@@ -3109,25 +3109,25 @@ static const JSWrapObjectCallbacks WrapO
XPCJSRuntime::XPCJSRuntime(nsXPConnect* aXPConnect)
: CycleCollectedJSRuntime(nullptr, JS::DefaultHeapMaxBytes, JS::DefaultNurseryBytes),
mJSContextStack(new XPCJSContextStack(MOZ_THIS_IN_INITIALIZER_LIST())),
mCallContext(nullptr),
mAutoRoots(nullptr),
mResolveName(JSID_VOID),
mResolvingWrapper(nullptr),
- mWrappedJSMap(JSObject2WrappedJSMap::newMap(XPC_JS_MAP_SIZE)),
- mWrappedJSClassMap(IID2WrappedJSClassMap::newMap(XPC_JS_CLASS_MAP_SIZE)),
- mIID2NativeInterfaceMap(IID2NativeInterfaceMap::newMap(XPC_NATIVE_INTERFACE_MAP_SIZE)),
- mClassInfo2NativeSetMap(ClassInfo2NativeSetMap::newMap(XPC_NATIVE_SET_MAP_SIZE)),
- mNativeSetMap(NativeSetMap::newMap(XPC_NATIVE_SET_MAP_SIZE)),
- mThisTranslatorMap(IID2ThisTranslatorMap::newMap(XPC_THIS_TRANSLATOR_MAP_SIZE)),
- mNativeScriptableSharedMap(XPCNativeScriptableSharedMap::newMap(XPC_NATIVE_JSCLASS_MAP_SIZE)),
- mDyingWrappedNativeProtoMap(XPCWrappedNativeProtoMap::newMap(XPC_DYING_NATIVE_PROTO_MAP_SIZE)),
- mDetachedWrappedNativeProtoMap(XPCWrappedNativeProtoMap::newMap(XPC_DETACHED_NATIVE_PROTO_MAP_SIZE)),
+ mWrappedJSMap(JSObject2WrappedJSMap::newMap(XPC_JS_MAP_LENGTH)),
+ mWrappedJSClassMap(IID2WrappedJSClassMap::newMap(XPC_JS_CLASS_MAP_LENGTH)),
+ mIID2NativeInterfaceMap(IID2NativeInterfaceMap::newMap(XPC_NATIVE_INTERFACE_MAP_LENGTH)),
+ mClassInfo2NativeSetMap(ClassInfo2NativeSetMap::newMap(XPC_NATIVE_SET_MAP_LENGTH)),
+ mNativeSetMap(NativeSetMap::newMap(XPC_NATIVE_SET_MAP_LENGTH)),
+ mThisTranslatorMap(IID2ThisTranslatorMap::newMap(XPC_THIS_TRANSLATOR_MAP_LENGTH)),
+ mNativeScriptableSharedMap(XPCNativeScriptableSharedMap::newMap(XPC_NATIVE_JSCLASS_MAP_LENGTH)),
+ mDyingWrappedNativeProtoMap(XPCWrappedNativeProtoMap::newMap(XPC_DYING_NATIVE_PROTO_MAP_LENGTH)),
+ mDetachedWrappedNativeProtoMap(XPCWrappedNativeProtoMap::newMap(XPC_DETACHED_NATIVE_PROTO_MAP_LENGTH)),
mGCIsRunning(false),
mWrappedJSToReleaseArray(),
mNativesToReleaseArray(),
mDoingFinalization(false),
mVariantRoots(nullptr),
mWrappedJSRoots(nullptr),
mObjectHolderRoots(nullptr),
mWatchdogManager(new WatchdogManager(MOZ_THIS_IN_INITIALIZER_LIST())),
--- a/js/xpconnect/src/XPCMaps.cpp
+++ b/js/xpconnect/src/XPCMaps.cpp
@@ -111,33 +111,33 @@ JSObject2WrappedJSMap::ShutdownMarker()
}
}
/***************************************************************************/
// implement Native2WrappedNativeMap...
// static
Native2WrappedNativeMap*
-Native2WrappedNativeMap::newMap(int size)
+Native2WrappedNativeMap::newMap(int length)
{
- Native2WrappedNativeMap* map = new Native2WrappedNativeMap(size);
+ Native2WrappedNativeMap* map = new Native2WrappedNativeMap(length);
if (map && map->mTable)
return map;
// Allocation of the map or the creation of its hash table has
// failed. This will cause a nullptr deref later when we attempt
// to use the map, so we abort immediately to provide a more
// useful crash stack.
NS_RUNTIMEABORT("Ran out of memory.");
return nullptr;
}
-Native2WrappedNativeMap::Native2WrappedNativeMap(int size)
+Native2WrappedNativeMap::Native2WrappedNativeMap(int length)
{
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
- sizeof(Entry), size);
+ sizeof(Entry), length);
}
Native2WrappedNativeMap::~Native2WrappedNativeMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -168,28 +168,28 @@ const struct PLDHashTableOps IID2Wrapped
MatchIIDPtrKey,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
IID2WrappedJSClassMap*
-IID2WrappedJSClassMap::newMap(int size)
+IID2WrappedJSClassMap::newMap(int length)
{
- IID2WrappedJSClassMap* map = new IID2WrappedJSClassMap(size);
+ IID2WrappedJSClassMap* map = new IID2WrappedJSClassMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-IID2WrappedJSClassMap::IID2WrappedJSClassMap(int size)
+IID2WrappedJSClassMap::IID2WrappedJSClassMap(int length)
{
- mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
+ mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), length);
}
IID2WrappedJSClassMap::~IID2WrappedJSClassMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -205,28 +205,28 @@ const struct PLDHashTableOps IID2NativeI
MatchIIDPtrKey,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
IID2NativeInterfaceMap*
-IID2NativeInterfaceMap::newMap(int size)
+IID2NativeInterfaceMap::newMap(int length)
{
- IID2NativeInterfaceMap* map = new IID2NativeInterfaceMap(size);
+ IID2NativeInterfaceMap* map = new IID2NativeInterfaceMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-IID2NativeInterfaceMap::IID2NativeInterfaceMap(int size)
+IID2NativeInterfaceMap::IID2NativeInterfaceMap(int length)
{
- mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
+ mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), length);
}
IID2NativeInterfaceMap::~IID2NativeInterfaceMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -247,29 +247,29 @@ IID2NativeInterfaceMap::SizeOfEntryExclu
return iface->SizeOfIncludingThis(mallocSizeOf);
}
/***************************************************************************/
// implement ClassInfo2NativeSetMap...
// static
ClassInfo2NativeSetMap*
-ClassInfo2NativeSetMap::newMap(int size)
+ClassInfo2NativeSetMap::newMap(int length)
{
- ClassInfo2NativeSetMap* map = new ClassInfo2NativeSetMap(size);
+ ClassInfo2NativeSetMap* map = new ClassInfo2NativeSetMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-ClassInfo2NativeSetMap::ClassInfo2NativeSetMap(int size)
+ClassInfo2NativeSetMap::ClassInfo2NativeSetMap(int length)
{
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
- sizeof(Entry), size);
+ sizeof(Entry), length);
}
ClassInfo2NativeSetMap::~ClassInfo2NativeSetMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -283,33 +283,33 @@ ClassInfo2NativeSetMap::ShallowSizeOfInc
return n;
}
/***************************************************************************/
// implement ClassInfo2WrappedNativeProtoMap...
// static
ClassInfo2WrappedNativeProtoMap*
-ClassInfo2WrappedNativeProtoMap::newMap(int size)
+ClassInfo2WrappedNativeProtoMap::newMap(int length)
{
- ClassInfo2WrappedNativeProtoMap* map = new ClassInfo2WrappedNativeProtoMap(size);
+ ClassInfo2WrappedNativeProtoMap* map = new ClassInfo2WrappedNativeProtoMap(length);
if (map && map->mTable)
return map;
// Allocation of the map or the creation of its hash table has
// failed. This will cause a nullptr deref later when we attempt
// to use the map, so we abort immediately to provide a more
// useful crash stack.
NS_RUNTIMEABORT("Ran out of memory.");
return nullptr;
}
-ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int size)
+ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int length)
{
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
- sizeof(Entry), size);
+ sizeof(Entry), length);
}
ClassInfo2WrappedNativeProtoMap::~ClassInfo2WrappedNativeProtoMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -412,28 +412,28 @@ const struct PLDHashTableOps NativeSetMa
Match,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
NativeSetMap*
-NativeSetMap::newMap(int size)
+NativeSetMap::newMap(int length)
{
- NativeSetMap* map = new NativeSetMap(size);
+ NativeSetMap* map = new NativeSetMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-NativeSetMap::NativeSetMap(int size)
+NativeSetMap::NativeSetMap(int length)
{
- mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
+ mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), length);
}
NativeSetMap::~NativeSetMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -479,28 +479,28 @@ const struct PLDHashTableOps IID2ThisTra
Match,
PL_DHashMoveEntryStub,
Clear,
PL_DHashFinalizeStub
};
// static
IID2ThisTranslatorMap*
-IID2ThisTranslatorMap::newMap(int size)
+IID2ThisTranslatorMap::newMap(int length)
{
- IID2ThisTranslatorMap* map = new IID2ThisTranslatorMap(size);
+ IID2ThisTranslatorMap* map = new IID2ThisTranslatorMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-IID2ThisTranslatorMap::IID2ThisTranslatorMap(int size)
+IID2ThisTranslatorMap::IID2ThisTranslatorMap(int length)
{
- mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
+ mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), length);
}
IID2ThisTranslatorMap::~IID2ThisTranslatorMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -559,29 +559,29 @@ const struct PLDHashTableOps XPCNativeSc
Match,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub
};
// static
XPCNativeScriptableSharedMap*
-XPCNativeScriptableSharedMap::newMap(int size)
+XPCNativeScriptableSharedMap::newMap(int length)
{
XPCNativeScriptableSharedMap* map =
- new XPCNativeScriptableSharedMap(size);
+ new XPCNativeScriptableSharedMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int size)
+XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int length)
{
- mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), size);
+ mTable = PL_NewDHashTable(&Entry::sOps, nullptr, sizeof(Entry), length);
}
XPCNativeScriptableSharedMap::~XPCNativeScriptableSharedMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
@@ -614,29 +614,29 @@ XPCNativeScriptableSharedMap::GetNewOrUs
return true;
}
/***************************************************************************/
// implement XPCWrappedNativeProtoMap...
// static
XPCWrappedNativeProtoMap*
-XPCWrappedNativeProtoMap::newMap(int size)
+XPCWrappedNativeProtoMap::newMap(int length)
{
- XPCWrappedNativeProtoMap* map = new XPCWrappedNativeProtoMap(size);
+ XPCWrappedNativeProtoMap* map = new XPCWrappedNativeProtoMap(length);
if (map && map->mTable)
return map;
delete map;
return nullptr;
}
-XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int size)
+XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int length)
{
mTable = PL_NewDHashTable(PL_DHashGetStubOps(), nullptr,
- sizeof(PLDHashEntryStub), size);
+ sizeof(PLDHashEntryStub), length);
}
XPCWrappedNativeProtoMap::~XPCWrappedNativeProtoMap()
{
if (mTable)
PL_DHashTableDestroy(mTable);
}
--- a/js/xpconnect/src/XPCMaps.h
+++ b/js/xpconnect/src/XPCMaps.h
@@ -25,19 +25,19 @@
/*************************/
class JSObject2WrappedJSMap
{
typedef js::HashMap<JSObject*, nsXPCWrappedJS*, js::PointerHasher<JSObject*, 3>,
js::SystemAllocPolicy> Map;
public:
- static JSObject2WrappedJSMap* newMap(int size) {
+ static JSObject2WrappedJSMap* newMap(int length) {
JSObject2WrappedJSMap* map = new JSObject2WrappedJSMap();
- if (map && map->mTable.init(size))
+ if (map && map->mTable.init(length))
return map;
delete map;
return nullptr;
}
inline nsXPCWrappedJS* Find(JSObject* Obj) {
NS_PRECONDITION(Obj,"bad param");
Map::Ptr p = mTable.lookup(Obj);
@@ -101,17 +101,17 @@ class Native2WrappedNativeMap
{
public:
struct Entry : public PLDHashEntryHdr
{
nsISupports* key;
XPCWrappedNative* value;
};
- static Native2WrappedNativeMap* newMap(int size);
+ static Native2WrappedNativeMap* newMap(int length);
inline XPCWrappedNative* Find(nsISupports* Obj)
{
NS_PRECONDITION(Obj,"bad param");
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, Obj, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
@@ -172,17 +172,17 @@ public:
struct Entry : public PLDHashEntryHdr
{
const nsIID* key;
nsXPCWrappedJSClass* value;
static const struct PLDHashTableOps sOps;
};
- static IID2WrappedJSClassMap* newMap(int size);
+ static IID2WrappedJSClassMap* newMap(int length);
inline nsXPCWrappedJSClass* Find(REFNSIID iid)
{
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, &iid, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
@@ -229,17 +229,17 @@ public:
struct Entry : public PLDHashEntryHdr
{
const nsIID* key;
XPCNativeInterface* value;
static const struct PLDHashTableOps sOps;
};
- static IID2NativeInterfaceMap* newMap(int size);
+ static IID2NativeInterfaceMap* newMap(int length);
inline XPCNativeInterface* Find(REFNSIID iid)
{
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, &iid, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
@@ -289,17 +289,17 @@ class ClassInfo2NativeSetMap
{
public:
struct Entry : public PLDHashEntryHdr
{
nsIClassInfo* key;
XPCNativeSet* value;
};
- static ClassInfo2NativeSetMap* newMap(int size);
+ static ClassInfo2NativeSetMap* newMap(int length);
inline XPCNativeSet* Find(nsIClassInfo* info)
{
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, info, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
@@ -349,17 +349,17 @@ class ClassInfo2WrappedNativeProtoMap
{
public:
struct Entry : public PLDHashEntryHdr
{
nsIClassInfo* key;
XPCWrappedNativeProto* value;
};
- static ClassInfo2WrappedNativeProtoMap* newMap(int size);
+ static ClassInfo2WrappedNativeProtoMap* newMap(int length);
inline XPCWrappedNativeProto* Find(nsIClassInfo* info)
{
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, info, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
@@ -414,17 +414,17 @@ public:
static bool
Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
static const struct PLDHashTableOps sOps;
};
- static NativeSetMap* newMap(int size);
+ static NativeSetMap* newMap(int length);
inline XPCNativeSet* Find(XPCNativeSetKey* key)
{
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, key, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->key_value;
@@ -491,17 +491,17 @@ public:
const void *key);
static void
Clear(PLDHashTable *table, PLDHashEntryHdr *entry);
static const struct PLDHashTableOps sOps;
};
- static IID2ThisTranslatorMap* newMap(int size);
+ static IID2ThisTranslatorMap* newMap(int length);
inline nsIXPCFunctionThisTranslator* Find(REFNSIID iid)
{
Entry* entry = (Entry*)
PL_DHashTableOperate(mTable, &iid, PL_DHASH_LOOKUP);
if (PL_DHASH_ENTRY_IS_FREE(entry))
return nullptr;
return entry->value;
@@ -552,17 +552,17 @@ public:
static bool
Match(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
static const struct PLDHashTableOps sOps;
};
- static XPCNativeScriptableSharedMap* newMap(int size);
+ static XPCNativeScriptableSharedMap* newMap(int length);
bool GetNewOrUsed(uint32_t flags, char* name, uint32_t interfacesBitmap,
XPCNativeScriptableInfo* si);
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
@@ -574,17 +574,17 @@ private:
PLDHashTable *mTable;
};
/***************************************************************************/
class XPCWrappedNativeProtoMap
{
public:
- static XPCWrappedNativeProtoMap* newMap(int size);
+ static XPCWrappedNativeProtoMap* newMap(int length);
inline XPCWrappedNativeProto* Add(XPCWrappedNativeProto* proto)
{
NS_PRECONDITION(proto,"bad param");
PLDHashEntryStub* entry = (PLDHashEntryStub*)
PL_DHashTableOperate(mTable, proto, PL_DHASH_ADD);
if (!entry)
return nullptr;
@@ -615,19 +615,19 @@ private:
/***************************************************************************/
class JSObject2JSObjectMap
{
typedef js::HashMap<JSObject *, JS::Heap<JSObject *>, js::PointerHasher<JSObject *, 3>,
js::SystemAllocPolicy> Map;
public:
- static JSObject2JSObjectMap* newMap(int size) {
+ static JSObject2JSObjectMap* newMap(int length) {
JSObject2JSObjectMap* map = new JSObject2JSObjectMap();
- if (map && map->mTable.init(size))
+ if (map && map->mTable.init(length))
return map;
delete map;
return nullptr;
}
inline JSObject* Find(JSObject* key) {
NS_PRECONDITION(key, "bad param");
if (Map::Ptr p = mTable.lookup(key))
--- a/js/xpconnect/src/XPCWrappedNativeScope.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeScope.cpp
@@ -72,18 +72,18 @@ RemoteXULForbidsXBLScope(nsIPrincipal *a
return false;
// Check the pref to determine how we should behave.
return !Preferences::GetBool("dom.use_xbl_scopes_for_remote_xul", false);
}
XPCWrappedNativeScope::XPCWrappedNativeScope(JSContext *cx,
JS::HandleObject aGlobal)
- : mWrappedNativeMap(Native2WrappedNativeMap::newMap(XPC_NATIVE_MAP_SIZE)),
- mWrappedNativeProtoMap(ClassInfo2WrappedNativeProtoMap::newMap(XPC_NATIVE_PROTO_MAP_SIZE)),
+ : mWrappedNativeMap(Native2WrappedNativeMap::newMap(XPC_NATIVE_MAP_LENGTH)),
+ mWrappedNativeProtoMap(ClassInfo2WrappedNativeProtoMap::newMap(XPC_NATIVE_PROTO_MAP_LENGTH)),
mComponents(nullptr),
mNext(nullptr),
mGlobalJSObject(aGlobal),
mIsContentXBLScope(false),
mIsAddonScope(false)
{
// add ourselves to the scopes list
{
--- a/js/xpconnect/src/xpcprivate.h
+++ b/js/xpconnect/src/xpcprivate.h
@@ -170,30 +170,30 @@
#endif
#endif /* XP_WIN */
#include "nsINode.h"
/***************************************************************************/
// default initial sizes for maps (hashtables)
-#define XPC_CONTEXT_MAP_SIZE 16
-#define XPC_JS_MAP_SIZE 64
-#define XPC_JS_CLASS_MAP_SIZE 64
-
-#define XPC_NATIVE_MAP_SIZE 64
-#define XPC_NATIVE_PROTO_MAP_SIZE 16
-#define XPC_DYING_NATIVE_PROTO_MAP_SIZE 16
-#define XPC_DETACHED_NATIVE_PROTO_MAP_SIZE 32
-#define XPC_NATIVE_INTERFACE_MAP_SIZE 64
-#define XPC_NATIVE_SET_MAP_SIZE 64
-#define XPC_NATIVE_JSCLASS_MAP_SIZE 32
-#define XPC_THIS_TRANSLATOR_MAP_SIZE 8
-#define XPC_NATIVE_WRAPPER_MAP_SIZE 16
-#define XPC_WRAPPER_MAP_SIZE 16
+#define XPC_CONTEXT_MAP_LENGTH 8
+#define XPC_JS_MAP_LENGTH 32
+#define XPC_JS_CLASS_MAP_LENGTH 32
+
+#define XPC_NATIVE_MAP_LENGTH 32
+#define XPC_NATIVE_PROTO_MAP_LENGTH 8
+#define XPC_DYING_NATIVE_PROTO_MAP_LENGTH 8
+#define XPC_DETACHED_NATIVE_PROTO_MAP_LENGTH 16
+#define XPC_NATIVE_INTERFACE_MAP_LENGTH 32
+#define XPC_NATIVE_SET_MAP_LENGTH 32
+#define XPC_NATIVE_JSCLASS_MAP_LENGTH 16
+#define XPC_THIS_TRANSLATOR_MAP_LENGTH 4
+#define XPC_NATIVE_WRAPPER_MAP_LENGTH 8
+#define XPC_WRAPPER_MAP_LENGTH 8
/***************************************************************************/
// data declarations...
extern const char XPC_CONTEXT_STACK_CONTRACTID[];
extern const char XPC_RUNTIME_CONTRACTID[];
extern const char XPC_EXCEPTION_CONTRACTID[];
extern const char XPC_CONSOLE_CONTRACTID[];
extern const char XPC_SCRIPT_ERROR_CONTRACTID[];
--- a/js/xpconnect/wrappers/WrapperFactory.cpp
+++ b/js/xpconnect/wrappers/WrapperFactory.cpp
@@ -81,17 +81,17 @@ WrapperFactory::CreateXrayWaiver(JSConte
&XrayWaiver);
if (!waiver)
return nullptr;
// Add the new waiver to the map. It's important that we only ever have
// one waiver for the lifetime of the target object.
if (!scope->mWaiverWrapperMap) {
scope->mWaiverWrapperMap =
- JSObject2JSObjectMap::newMap(XPC_WRAPPER_MAP_SIZE);
+ JSObject2JSObjectMap::newMap(XPC_WRAPPER_MAP_LENGTH);
MOZ_ASSERT(scope->mWaiverWrapperMap);
}
if (!scope->mWaiverWrapperMap->Add(cx, obj, waiver))
return nullptr;
return waiver;
}
JSObject *
--- a/layout/base/nsCounterManager.cpp
+++ b/layout/base/nsCounterManager.cpp
@@ -194,17 +194,17 @@ nsCounterList::RecalcAll()
useNode->GetText(text);
useNode->mText->SetData(text);
}
}
} while ((node = Next(node)) != First());
}
nsCounterManager::nsCounterManager()
- : mNames(16)
+ : mNames()
{
}
bool
nsCounterManager::AddCounterResetsAndIncrements(nsIFrame *aFrame)
{
const nsStyleContent *styleContent = aFrame->StyleContent();
if (!styleContent->CounterIncrementCount() &&
--- a/layout/base/nsFrameManager.cpp
+++ b/layout/base/nsFrameManager.cpp
@@ -166,17 +166,17 @@ nsFrameManager::GetPlaceholderFrameFor(c
nsresult
nsFrameManager::RegisterPlaceholderFrame(nsPlaceholderFrame* aPlaceholderFrame)
{
NS_PRECONDITION(aPlaceholderFrame, "null param unexpected");
NS_PRECONDITION(nsGkAtoms::placeholderFrame == aPlaceholderFrame->GetType(),
"unexpected frame type");
if (!mPlaceholderMap.ops) {
PL_DHashTableInit(&mPlaceholderMap, &PlaceholderMapOps, nullptr,
- sizeof(PlaceholderMapEntry), 16);
+ sizeof(PlaceholderMapEntry));
}
PlaceholderMapEntry *entry = static_cast<PlaceholderMapEntry*>(PL_DHashTableOperate(&mPlaceholderMap,
aPlaceholderFrame->GetOutOfFlowFrame(),
PL_DHASH_ADD));
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;
NS_ASSERTION(!entry->placeholderFrame, "Registering a placeholder for a frame that already has a placeholder!");
--- a/layout/generic/TextOverflow.cpp
+++ b/layout/generic/TextOverflow.cpp
@@ -568,18 +568,18 @@ TextOverflow::ProcessLine(const nsDispla
{
NS_ASSERTION(mLeft.mStyle->mType != NS_STYLE_TEXT_OVERFLOW_CLIP ||
mRight.mStyle->mType != NS_STYLE_TEXT_OVERFLOW_CLIP,
"TextOverflow with 'clip' for both sides");
mLeft.Reset();
mLeft.mActive = mLeft.mStyle->mType != NS_STYLE_TEXT_OVERFLOW_CLIP;
mRight.Reset();
mRight.mActive = mRight.mStyle->mType != NS_STYLE_TEXT_OVERFLOW_CLIP;
-
- FrameHashtable framesToHide(100);
+
+ FrameHashtable framesToHide(64);
AlignmentEdges alignmentEdges;
ExamineLineFrames(aLine, &framesToHide, &alignmentEdges);
bool needLeft = mLeft.IsNeeded();
bool needRight = mRight.IsNeeded();
if (!needLeft && !needRight) {
return;
}
NS_ASSERTION(mLeft.mStyle->mType != NS_STYLE_TEXT_OVERFLOW_CLIP ||
--- a/layout/generic/nsLineBox.h
+++ b/layout/generic/nsLineBox.h
@@ -337,19 +337,19 @@ private:
*/
void NoteFramesMovedFrom(nsLineBox* aFromLine);
void SwitchToHashtable()
{
MOZ_ASSERT(!mFlags.mHasHashedFrames);
uint32_t count = GetChildCount();
mFlags.mHasHashedFrames = 1;
- uint32_t minSize =
- std::max(kMinChildCountForHashtable, uint32_t(PL_DHASH_MIN_SIZE));
- mFrames = new nsTHashtable< nsPtrHashKey<nsIFrame> >(std::max(count, minSize));
+ uint32_t minLength = std::max(kMinChildCountForHashtable,
+ uint32_t(PL_DHASH_DEFAULT_INITIAL_LENGTH));
+ mFrames = new nsTHashtable< nsPtrHashKey<nsIFrame> >(std::max(count, minLength));
for (nsIFrame* f = mFirstChild; count-- > 0; f = f->GetNextSibling()) {
mFrames->PutEntry(f);
}
}
void SwitchToCounter() {
MOZ_ASSERT(mFlags.mHasHashedFrames);
uint32_t count = GetChildCount();
delete mFrames;
--- a/layout/style/nsAnimationManager.cpp
+++ b/layout/style/nsAnimationManager.cpp
@@ -360,17 +360,17 @@ struct KeyframeDataComparator {
}
bool LessThan(const KeyframeData& A, const KeyframeData& B) const {
return A.mKey < B.mKey || (A.mKey == B.mKey && A.mIndex < B.mIndex);
}
};
class ResolvedStyleCache {
public:
- ResolvedStyleCache() : mCache(16) {}
+ ResolvedStyleCache() : mCache() {}
nsStyleContext* Get(nsPresContext *aPresContext,
nsStyleContext *aParentStyleContext,
nsCSSKeyframeRule *aKeyframe);
private:
nsRefPtrHashtable<nsPtrHashKey<nsCSSKeyframeRule>, nsStyleContext> mCache;
};
--- a/layout/style/nsCSSProps.cpp
+++ b/layout/style/nsCSSProps.cpp
@@ -110,33 +110,33 @@ enum {
static nsCSSProperty gAliases[eCSSAliasCount != 0 ? eCSSAliasCount : 1] = {
#define CSS_PROP_ALIAS(aliasname_, propid_, aliasmethod_, pref_) \
eCSSProperty_##propid_ ,
#include "nsCSSPropAliasList.h"
#undef CSS_PROP_ALIAS
};
nsStaticCaseInsensitiveNameTable*
-CreateStaticTable(const char* const aRawTable[], int32_t aSize)
+CreateStaticTable(const char* const aRawTable[], int32_t aLength)
{
auto table = new nsStaticCaseInsensitiveNameTable();
if (table) {
#ifdef DEBUG
// let's verify the table...
- for (int32_t index = 0; index < aSize; ++index) {
+ for (int32_t index = 0; index < aLength; ++index) {
nsAutoCString temp1(aRawTable[index]);
nsAutoCString temp2(aRawTable[index]);
ToLowerCase(temp1);
NS_ABORT_IF_FALSE(temp1.Equals(temp2),
"upper case char in case insensitive name table");
NS_ABORT_IF_FALSE(-1 == temp1.FindChar('_'),
"underscore char in case insensitive name table");
}
#endif
- table->Init(aRawTable, aSize);
+ table->Init(aRawTable, aLength);
}
return table;
}
void
nsCSSProps::AddRefTable(void)
{
if (0 == gPropertyTableRefCount++) {
--- a/layout/style/nsCSSRuleProcessor.cpp
+++ b/layout/style/nsCSSRuleProcessor.cpp
@@ -626,49 +626,49 @@ void RuleHash::AppendRule(const RuleSele
if (selector->IsPseudoElement()) {
selector = selector->mNext;
}
if (nullptr != selector->mIDList) {
if (!mIdTable.ops) {
PL_DHashTableInit(&mIdTable,
mQuirksMode ? &RuleHash_IdTable_CIOps.ops
: &RuleHash_IdTable_CSOps.ops,
- nullptr, sizeof(RuleHashTableEntry), 16);
+ nullptr, sizeof(RuleHashTableEntry));
}
AppendRuleToTable(&mIdTable, selector->mIDList->mAtom, aRuleInfo);
RULE_HASH_STAT_INCREMENT(mIdSelectors);
}
else if (nullptr != selector->mClassList) {
if (!mClassTable.ops) {
PL_DHashTableInit(&mClassTable,
mQuirksMode ? &RuleHash_ClassTable_CIOps.ops
: &RuleHash_ClassTable_CSOps.ops,
- nullptr, sizeof(RuleHashTableEntry), 16);
+ nullptr, sizeof(RuleHashTableEntry));
}
AppendRuleToTable(&mClassTable, selector->mClassList->mAtom, aRuleInfo);
RULE_HASH_STAT_INCREMENT(mClassSelectors);
}
else if (selector->mLowercaseTag) {
RuleValue ruleValue(aRuleInfo, mRuleCount++, mQuirksMode);
if (!mTagTable.ops) {
PL_DHashTableInit(&mTagTable, &RuleHash_TagTable_Ops, nullptr,
- sizeof(RuleHashTagTableEntry), 16);
+ sizeof(RuleHashTagTableEntry));
}
AppendRuleToTagTable(&mTagTable, selector->mLowercaseTag, ruleValue);
RULE_HASH_STAT_INCREMENT(mTagSelectors);
if (selector->mCasedTag &&
selector->mCasedTag != selector->mLowercaseTag) {
AppendRuleToTagTable(&mTagTable, selector->mCasedTag, ruleValue);
RULE_HASH_STAT_INCREMENT(mTagSelectors);
}
}
else if (kNameSpaceID_Unknown != selector->mNameSpace) {
if (!mNameSpaceTable.ops) {
PL_DHashTableInit(&mNameSpaceTable, &RuleHash_NameSpaceTable_Ops, nullptr,
- sizeof(RuleHashTableEntry), 16);
+ sizeof(RuleHashTableEntry));
}
AppendRuleToTable(&mNameSpaceTable,
NS_INT32_TO_PTR(selector->mNameSpace), aRuleInfo);
RULE_HASH_STAT_INCREMENT(mNameSpaceSelectors);
}
else { // universal tag selector
AppendUniversalRule(aRuleInfo);
RULE_HASH_STAT_INCREMENT(mUniversalSelectors);
@@ -920,40 +920,40 @@ static const RuleHashTableOps AtomSelect
//--------------------------------
struct RuleCascadeData {
RuleCascadeData(nsIAtom *aMedium, bool aQuirksMode)
: mRuleHash(aQuirksMode),
mStateSelectors(),
mSelectorDocumentStates(0),
- mKeyframesRuleTable(16),
- mCounterStyleRuleTable(16),
+ mKeyframesRuleTable(),
+ mCounterStyleRuleTable(),
mCacheKey(aMedium),
mNext(nullptr),
mQuirksMode(aQuirksMode)
{
// mAttributeSelectors is matching on the attribute _name_, not the value,
// and we case-fold names at parse-time, so this is a case-sensitive match.
PL_DHashTableInit(&mAttributeSelectors, &AtomSelector_CSOps, nullptr,
- sizeof(AtomSelectorEntry), 16);
+ sizeof(AtomSelectorEntry));
PL_DHashTableInit(&mAnonBoxRules, &RuleHash_TagTable_Ops, nullptr,
- sizeof(RuleHashTagTableEntry), 16);
+ sizeof(RuleHashTagTableEntry));
PL_DHashTableInit(&mIdSelectors,
aQuirksMode ? &AtomSelector_CIOps.ops :
&AtomSelector_CSOps,
- nullptr, sizeof(AtomSelectorEntry), 16);
+ nullptr, sizeof(AtomSelectorEntry));
PL_DHashTableInit(&mClassSelectors,
aQuirksMode ? &AtomSelector_CIOps.ops :
&AtomSelector_CSOps,
- nullptr, sizeof(AtomSelectorEntry), 16);
+ nullptr, sizeof(AtomSelectorEntry));
memset(mPseudoElementRuleHashes, 0, sizeof(mPseudoElementRuleHashes));
#ifdef MOZ_XUL
PL_DHashTableInit(&mXULTreeRules, &RuleHash_TagTable_Ops, nullptr,
- sizeof(RuleHashTagTableEntry), 16);
+ sizeof(RuleHashTagTableEntry));
#endif
}
~RuleCascadeData()
{
PL_DHashTableFinish(&mAttributeSelectors);
PL_DHashTableFinish(&mAnonBoxRules);
PL_DHashTableFinish(&mIdSelectors);
@@ -3275,17 +3275,17 @@ struct CascadeEnumData {
mKeyframesRules(aKeyframesRules),
mFontFeatureValuesRules(aFontFeatureValuesRules),
mPageRules(aPageRules),
mCounterStyleRules(aCounterStyleRules),
mCacheKey(aKey),
mSheetType(aSheetType)
{
if (!PL_DHashTableInit(&mRulesByWeight, &gRulesByWeightOps, nullptr,
- sizeof(RuleByWeightEntry), 64, fallible_t()))
+ sizeof(RuleByWeightEntry), fallible_t(), 32))
mRulesByWeight.ops = nullptr;
// Initialize our arena
PL_INIT_ARENA_POOL(&mArena, "CascadeEnumDataArena",
NS_CASCADEENUMDATA_ARENA_BLOCK_SIZE);
}
~CascadeEnumData()
--- a/layout/style/nsHTMLStyleSheet.cpp
+++ b/layout/style/nsHTMLStyleSheet.cpp
@@ -474,17 +474,17 @@ nsHTMLStyleSheet::SetVisitedLinkColor(ns
return ImplLinkColorSetter(mVisitedRule, aColor);
}
already_AddRefed<nsMappedAttributes>
nsHTMLStyleSheet::UniqueMappedAttributes(nsMappedAttributes* aMapped)
{
if (!mMappedAttrTable.ops) {
PL_DHashTableInit(&mMappedAttrTable, &MappedAttrTable_Ops,
- nullptr, sizeof(MappedAttrTableEntry), 16);
+ nullptr, sizeof(MappedAttrTableEntry));
}
MappedAttrTableEntry *entry = static_cast<MappedAttrTableEntry*>
(PL_DHashTableOperate(&mMappedAttrTable, aMapped, PL_DHASH_ADD));
if (!entry)
return nullptr;
if (!entry->mAttributes) {
// We added a new entry to the hashtable, so we have a new unique set.
entry->mAttributes = aMapped;
@@ -508,17 +508,17 @@ nsHTMLStyleSheet::DropMappedAttributes(n
NS_ASSERTION(entryCount == mMappedAttrTable.entryCount, "not removed");
}
nsIStyleRule*
nsHTMLStyleSheet::LangRuleFor(const nsString& aLanguage)
{
if (!mLangRuleTable.ops) {
PL_DHashTableInit(&mLangRuleTable, &LangRuleTable_Ops,
- nullptr, sizeof(LangRuleTableEntry), 16);
+ nullptr, sizeof(LangRuleTableEntry));
}
LangRuleTableEntry *entry = static_cast<LangRuleTableEntry*>
(PL_DHashTableOperate(&mLangRuleTable, &aLanguage, PL_DHASH_ADD));
if (!entry) {
NS_ASSERTION(false, "out of memory");
return nullptr;
}
return entry->mRule;
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -1506,17 +1506,17 @@ nsRuleNode::Transition(nsIStyleRule* aRu
nsRuleNode* curr = ChildrenList();
while (curr && curr->GetKey() != key) {
curr = curr->mNextSibling;
++numKids;
}
if (curr)
next = curr;
else if (numKids >= kMaxChildrenInList)
- ConvertChildrenToHash();
+ ConvertChildrenToHash(numKids);
}
if (ChildrenAreHashed()) {
ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>
(PL_DHashTableOperate(ChildrenHash(), &key, PL_DHASH_ADD));
if (!entry) {
NS_WARNING("out of memory");
return this;
@@ -1567,23 +1567,23 @@ void nsRuleNode::SetUsedDirectly()
NS_ASSERTION(data, "unexpected null struct");
mStyleData.SetStyleData(sid, mPresContext, data);
}
}
}
}
void
-nsRuleNode::ConvertChildrenToHash()
+nsRuleNode::ConvertChildrenToHash(int32_t aNumKids)
{
NS_ASSERTION(!ChildrenAreHashed() && HaveChildren(),
"must have a non-empty list of children");
PLDHashTable *hash = PL_NewDHashTable(&ChildrenHashOps, nullptr,
sizeof(ChildrenHashEntry),
- kMaxChildrenInList * 4);
+ aNumKids);
if (!hash)
return;
for (nsRuleNode* curr = ChildrenList(); curr; curr = curr->mNextSibling) {
// This will never fail because of the initial size we gave the table.
ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(
PL_DHashTableOperate(hash, curr->mRule, PL_DHASH_ADD));
NS_ASSERTION(!entry->mRuleNode, "duplicate entries in list");
entry->mRuleNode = curr;
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -368,17 +368,17 @@ private:
"pointer not 2-byte aligned");
mChildren.asList = aList;
}
void SetChildrenHash(PLDHashTable *aHashtable) {
NS_ASSERTION(!(intptr_t(aHashtable) & kTypeMask),
"pointer not 2-byte aligned");
mChildren.asHash = (PLDHashTable*)(intptr_t(aHashtable) | kHashType);
}
- void ConvertChildrenToHash();
+ void ConvertChildrenToHash(int32_t aNumKids);
nsCachedStyleData mStyleData; // Any data we cached on the rule node.
uint32_t mDependentBits; // Used to cache the fact that we can look up
// cached data under a parent rule.
uint32_t mNoneBits; // Used to cache the fact that the branch to this
// node specifies no non-inherited data for a
--- a/layout/svg/nsSVGEffects.h
+++ b/layout/svg/nsSVGEffects.h
@@ -274,17 +274,17 @@ protected:
* InvalidateAll must be called before this object is destroyed, i.e.
* before the referenced frame is destroyed. This should normally happen
* via nsSVGContainerFrame::RemoveFrame, since only frames in the frame
* tree should be referenced.
*/
class nsSVGRenderingObserverList {
public:
nsSVGRenderingObserverList()
- : mObservers(5)
+ : mObservers(4)
{
MOZ_COUNT_CTOR(nsSVGRenderingObserverList);
}
~nsSVGRenderingObserverList() {
InvalidateAll();
MOZ_COUNT_DTOR(nsSVGRenderingObserverList);
}
--- a/layout/svg/nsSVGFilterInstance.cpp
+++ b/layout/svg/nsSVGFilterInstance.cpp
@@ -384,17 +384,17 @@ nsSVGFilterInstance::BuildPrimitives(nsT
nsRefPtr<nsSVGFE> primitive;
CallQueryInterface(child, (nsSVGFE**)getter_AddRefs(primitive));
if (primitive) {
primitives.AppendElement(primitive);
}
}
// Maps source image name to source index.
- nsDataHashtable<nsStringHashKey, int32_t> imageTable(10);
+ nsDataHashtable<nsStringHashKey, int32_t> imageTable(8);
// The principal that we check principals of any loaded images against.
nsCOMPtr<nsIPrincipal> principal = mTargetFrame->GetContent()->NodePrincipal();
for (uint32_t primitiveElementIndex = 0;
primitiveElementIndex < primitives.Length();
++primitiveElementIndex) {
nsSVGFE* filter = primitives[primitiveElementIndex];
--- a/layout/tables/SpanningCellSorter.cpp
+++ b/layout/tables/SpanningCellSorter.cpp
@@ -72,17 +72,17 @@ SpanningCellSorter::AddCell(int32_t aCol
if (UseArrayForSpan(aColSpan)) {
int32_t index = SpanToIndex(aColSpan);
i->next = mArray[index];
mArray[index] = i;
} else {
if (!mHashTable.entryCount) {
PL_DHashTableInit(&mHashTable, &HashTableOps, nullptr,
- sizeof(HashTableEntry), PL_DHASH_MIN_SIZE);
+ sizeof(HashTableEntry));
}
HashTableEntry *entry = static_cast<HashTableEntry*>
(PL_DHashTableOperate(&mHashTable, NS_INT32_TO_PTR(aColSpan),
PL_DHASH_ADD));
NS_ENSURE_TRUE(entry, false);
NS_ASSERTION(entry->mColSpan == 0 || entry->mColSpan == aColSpan,
"wrong entry");
--- a/layout/xul/nsBoxObject.cpp
+++ b/layout/xul/nsBoxObject.cpp
@@ -266,31 +266,31 @@ nsBoxObject::GetHeight(int32_t* aResult)
}
NS_IMETHODIMP
nsBoxObject::GetScreenX(int32_t *_retval)
{
nsIntPoint position;
nsresult rv = GetScreenPosition(position);
if (NS_FAILED(rv)) return rv;
-
+
*_retval = position.x;
-
+
return NS_OK;
}
NS_IMETHODIMP
nsBoxObject::GetScreenY(int32_t *_retval)
{
nsIntPoint position;
nsresult rv = GetScreenPosition(position);
if (NS_FAILED(rv)) return rv;
-
+
*_retval = position.y;
-
+
return NS_OK;
}
NS_IMETHODIMP
nsBoxObject::GetPropertyAsSupports(const char16_t* aPropertyName, nsISupports** aResult)
{
NS_ENSURE_ARG(aPropertyName && *aPropertyName);
if (!mPropertyTable) {
@@ -301,19 +301,19 @@ nsBoxObject::GetPropertyAsSupports(const
mPropertyTable->Get(propertyName, aResult); // Addref here.
return NS_OK;
}
NS_IMETHODIMP
nsBoxObject::SetPropertyAsSupports(const char16_t* aPropertyName, nsISupports* aValue)
{
NS_ENSURE_ARG(aPropertyName && *aPropertyName);
-
- if (!mPropertyTable) {
- mPropertyTable = new nsInterfaceHashtable<nsStringHashKey,nsISupports>(8);
+
+ if (!mPropertyTable) {
+ mPropertyTable = new nsInterfaceHashtable<nsStringHashKey,nsISupports>(4);
}
nsDependentString propertyName(aPropertyName);
mPropertyTable->Put(propertyName, aValue);
return NS_OK;
}
NS_IMETHODIMP
@@ -324,35 +324,35 @@ nsBoxObject::GetProperty(const char16_t*
NS_ENSURE_SUCCESS(rv, rv);
if (!data) {
*aResult = nullptr;
return NS_OK;
}
nsCOMPtr<nsISupportsString> supportsStr = do_QueryInterface(data);
- if (!supportsStr)
+ if (!supportsStr)
return NS_ERROR_FAILURE;
-
+
return supportsStr->ToString(aResult);
}
NS_IMETHODIMP
nsBoxObject::SetProperty(const char16_t* aPropertyName, const char16_t* aPropertyValue)
{
NS_ENSURE_ARG(aPropertyName && *aPropertyName);
nsDependentString propertyName(aPropertyName);
nsDependentString propertyValue;
if (aPropertyValue) {
propertyValue.Rebind(aPropertyValue);
} else {
propertyValue.SetIsVoid(true);
}
-
+
nsCOMPtr<nsISupportsString> supportsStr(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID));
NS_ENSURE_TRUE(supportsStr, NS_ERROR_OUT_OF_MEMORY);
supportsStr->SetData(propertyValue);
return SetPropertyAsSupports(aPropertyName,supportsStr);
}
NS_IMETHODIMP
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -106,17 +106,17 @@ NS_QUERYFRAME_HEAD(nsTreeBodyFrame)
NS_QUERYFRAME_ENTRY(nsIScrollbarOwner)
NS_QUERYFRAME_ENTRY(nsTreeBodyFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsLeafBoxFrame)
// Constructor
nsTreeBodyFrame::nsTreeBodyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
:nsLeafBoxFrame(aPresShell, aContext),
mSlots(nullptr),
- mImageCache(16),
+ mImageCache(),
mTopRowIndex(0),
mPageLength(0),
mHorzPosition(0),
mOriginalHorzWidth(-1),
mHorzWidth(0),
mAdjustWidth(0),
mRowHeight(0),
mIndentation(0),
--- a/modules/libjar/nsJAR.cpp
+++ b/modules/libjar/nsJAR.cpp
@@ -72,17 +72,17 @@ nsJARManifestItem::~nsJARManifestItem()
}
//----------------------------------------------
// nsJAR constructor/destructor
//----------------------------------------------
// The following initialization makes a guess of 10 entries per jarfile.
nsJAR::nsJAR(): mZip(new nsZipArchive()),
- mManifestData(10),
+ mManifestData(8),
mParsedManifest(false),
mGlobalStatus(JAR_MANIFEST_NOT_PARSED),
mReleaseTime(PR_INTERVAL_NO_TIMEOUT),
mCache(nullptr),
mLock("nsJAR::mLock"),
mTotalItemsInManifest(0),
mOpened(false)
{
@@ -1023,17 +1023,17 @@ nsJARItem::GetPermissions(uint32_t* aPer
////////////////////////////////////////////////////////////////////////////////
// nsIZipReaderCache
NS_IMPL_ISUPPORTS(nsZipReaderCache, nsIZipReaderCache, nsIObserver, nsISupportsWeakReference)
nsZipReaderCache::nsZipReaderCache()
: mLock("nsZipReaderCache.mLock")
- , mZips(16)
+ , mZips()
, mMustCacheFd(false)
#ifdef ZIP_CACHE_HIT_RATE
,
mZipCacheLookups(0),
mZipCacheHits(0),
mZipCacheFlushes(0),
mZipSyncMisses(0)
#endif
--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -740,17 +740,17 @@ Preferences::GetPreference(PrefSetting*
return;
pref_GetPrefFromEntry(entry, aPref);
}
void
Preferences::GetPreferences(InfallibleTArray<PrefSetting>* aPrefs)
{
- aPrefs->SetCapacity(PL_DHASH_TABLE_SIZE(&gHashTable));
+ aPrefs->SetCapacity(PL_DHASH_TABLE_CAPACITY(&gHashTable));
PL_DHashTableEnumerate(&gHashTable, pref_GetPrefs, aPrefs);
}
NS_IMETHODIMP
Preferences::GetBranch(const char *aPrefRoot, nsIPrefBranch **_retval)
{
nsresult rv;
--- a/modules/libpref/prefapi.cpp
+++ b/modules/libpref/prefapi.cpp
@@ -139,24 +139,24 @@ struct CallbackNode {
static nsresult pref_DoCallback(const char* changed_pref);
enum {
kPrefSetDefault = 1,
kPrefForceSet = 2
};
static nsresult pref_HashPref(const char *key, PrefValue value, PrefType type, uint32_t flags);
-#define PREF_HASHTABLE_INITIAL_SIZE 2048
+#define PREF_HASHTABLE_INITIAL_LENGTH 1024
nsresult PREF_Init()
{
if (!gHashTable.ops) {
if (!PL_DHashTableInit(&gHashTable, &pref_HashTableOps, nullptr,
- sizeof(PrefHashEntry), PREF_HASHTABLE_INITIAL_SIZE,
- fallible_t())) {
+ sizeof(PrefHashEntry), fallible_t(),
+ PREF_HASHTABLE_INITIAL_LENGTH)) {
gHashTable.ops = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
PL_INIT_ARENA_POOL(&gPrefNameArena, "PrefNameArena",
PREFNAME_ARENA_SIZE);
}
return NS_OK;
--- a/netwerk/base/src/RedirectChannelRegistrar.cpp
+++ b/netwerk/base/src/RedirectChannelRegistrar.cpp
@@ -5,18 +5,18 @@
#include "RedirectChannelRegistrar.h"
namespace mozilla {
namespace net {
NS_IMPL_ISUPPORTS(RedirectChannelRegistrar, nsIRedirectChannelRegistrar)
RedirectChannelRegistrar::RedirectChannelRegistrar()
- : mRealChannels(64)
- , mParentChannels(64)
+ : mRealChannels(32)
+ , mParentChannels(32)
, mId(1)
{
}
NS_IMETHODIMP
RedirectChannelRegistrar::RegisterChannel(nsIChannel *channel,
uint32_t *_retval)
{
--- a/netwerk/base/src/nsLoadGroup.cpp
+++ b/netwerk/base/src/nsLoadGroup.cpp
@@ -1166,16 +1166,16 @@ nsresult nsLoadGroup::Init()
RequestHashMatchEntry,
PL_DHashMoveEntryStub,
RequestHashClearEntry,
PL_DHashFinalizeStub,
RequestHashInitEntry
};
PL_DHashTableInit(&mRequests, &hash_table_ops, nullptr,
- sizeof(RequestMapEntry), 16);
+ sizeof(RequestMapEntry));
mConnectionInfo = new nsLoadGroupConnectionInfo();
return NS_OK;
}
#undef LOG
--- a/netwerk/cache/nsCacheEntry.cpp
+++ b/netwerk/cache/nsCacheEntry.cpp
@@ -403,17 +403,17 @@ nsCacheEntryHashTable::~nsCacheEntryHash
nsresult
nsCacheEntryHashTable::Init()
{
nsresult rv = NS_OK;
initialized = PL_DHashTableInit(&table, &ops, nullptr,
sizeof(nsCacheEntryHashTableEntry),
- 512, fallible_t());
+ fallible_t(), 256);
if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
return rv;
}
void
nsCacheEntryHashTable::Shutdown()
--- a/netwerk/cache/nsDiskCacheDeviceSQL.cpp
+++ b/netwerk/cache/nsDiskCacheDeviceSQL.cpp
@@ -888,18 +888,18 @@ private:
NS_IMPL_ISUPPORTS0(nsOfflineCacheDevice)
nsOfflineCacheDevice::nsOfflineCacheDevice()
: mDB(nullptr)
, mCacheCapacity(0)
, mDeltaCounter(0)
, mAutoShutdown(false)
, mLock("nsOfflineCacheDevice.lock")
- , mActiveCaches(5)
- , mLockedEntries(64)
+ , mActiveCaches(4)
+ , mLockedEntries(32)
{
}
nsOfflineCacheDevice::~nsOfflineCacheDevice()
{}
/* static */
bool
--- a/netwerk/dns/nsEffectiveTLDService.cpp
+++ b/netwerk/dns/nsEffectiveTLDService.cpp
@@ -57,20 +57,16 @@ nsDomainEntry::FuncForStaticAsserts(void
#undef ETLD_STR_NUM
#undef ETLD_STR_NUM1
// ----------------------------------------------------------------------
static nsEffectiveTLDService *gService = nullptr;
nsEffectiveTLDService::nsEffectiveTLDService()
- // We'll probably have to rehash at least once, since nsTHashtable doesn't
- // use a perfect hash, but at least we'll save a few rehashes along the way.
- // Next optimization here is to precompute the hash using something like
- // gperf, but one step at a time. :-)
: mHash(ArrayLength(nsDomainEntry::entries))
{
}
nsresult
nsEffectiveTLDService::Init()
{
const ETLDEntry *entries = nsDomainEntry::entries;
--- a/netwerk/protocol/http/SpdyStream3.cpp
+++ b/netwerk/protocol/http/SpdyStream3.cpp
@@ -395,17 +395,17 @@ SpdyStream3::ParseHttpRequestHeaders(con
versionHeader = NS_LITERAL_CSTRING("HTTP/1.1");
else
versionHeader = NS_LITERAL_CSTRING("HTTP/1.0");
// use mRequestHead() to get a sense of how big to make the hash,
// even though we are parsing the actual text stream because
// it is legit to append headers.
nsClassHashtable<nsCStringHashKey, nsCString>
- hdrHash(1 + (mTransaction->RequestHead()->Headers().Count() * 2));
+ hdrHash(mTransaction->RequestHead()->Headers().Count());
const char *beginBuffer = mFlatHttpRequestHeaders.BeginReading();
// need to hash all the headers together to remove duplicates, special
// headers, etc..
int32_t crlfIndex = mFlatHttpRequestHeaders.Find("\r\n");
while (true) {
--- a/netwerk/protocol/http/SpdyStream31.cpp
+++ b/netwerk/protocol/http/SpdyStream31.cpp
@@ -401,17 +401,17 @@ SpdyStream31::ParseHttpRequestHeaders(co
versionHeader = NS_LITERAL_CSTRING("HTTP/1.1");
else
versionHeader = NS_LITERAL_CSTRING("HTTP/1.0");
// use mRequestHead() to get a sense of how big to make the hash,
// even though we are parsing the actual text stream because
// it is legit to append headers.
nsClassHashtable<nsCStringHashKey, nsCString>
- hdrHash(1 + (mTransaction->RequestHead()->Headers().Count() * 2));
+ hdrHash(mTransaction->RequestHead()->Headers().Count());
const char *beginBuffer = mFlatHttpRequestHeaders.BeginReading();
// need to hash all the headers together to remove duplicates, special
// headers, etc..
int32_t crlfIndex = mFlatHttpRequestHeaders.Find("\r\n");
while (true) {
--- a/netwerk/protocol/http/nsHttp.cpp
+++ b/netwerk/protocol/http/nsHttp.cpp
@@ -100,22 +100,22 @@ nsresult
nsHttp::CreateAtomTable()
{
MOZ_ASSERT(!sAtomTable.ops, "atom table already initialized");
if (!sLock) {
sLock = new Mutex("nsHttp.sLock");
}
- // The capacity for this table is initialized to a value greater than the
- // number of known atoms (NUM_HTTP_ATOMS) because we expect to encounter a
- // few random headers right off the bat.
+ // The initial length for this table is a value greater than the number of
+ // known atoms (NUM_HTTP_ATOMS) because we expect to encounter a few random
+ // headers right off the bat.
if (!PL_DHashTableInit(&sAtomTable, &ops, nullptr,
sizeof(PLDHashEntryStub),
- NUM_HTTP_ATOMS + 10, fallible_t())) {
+ fallible_t(), NUM_HTTP_ATOMS + 10)) {
sAtomTable.ops = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
// fill the table with our known atoms
const char *const atoms[] = {
#define HTTP_ATOM(_name, _value) nsHttp::_name._val,
#include "nsHttpAtomList.h"
--- a/netwerk/protocol/res/nsResProtocolHandler.cpp
+++ b/netwerk/protocol/res/nsResProtocolHandler.cpp
@@ -92,17 +92,17 @@ nsResURL::GetClassIDNoAlloc(nsCID *aClas
return NS_OK;
}
//----------------------------------------------------------------------------
// nsResProtocolHandler <public>
//----------------------------------------------------------------------------
nsResProtocolHandler::nsResProtocolHandler()
- : mSubstitutions(32)
+ : mSubstitutions(16)
{
#if defined(PR_LOGGING)
gResLog = PR_NewLogModule("nsResProtocol");
#endif
NS_ASSERTION(!gResHandler, "res handler already created!");
gResHandler = this;
}
--- a/parser/html/nsHtml5TreeOpExecutor.cpp
+++ b/parser/html/nsHtml5TreeOpExecutor.cpp
@@ -28,17 +28,17 @@
#include "nsIScriptError.h"
#include "nsIScriptContext.h"
#include "mozilla/Preferences.h"
#include "nsIHTMLDocument.h"
using namespace mozilla;
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsHtml5TreeOpExecutor)
- NS_INTERFACE_TABLE_INHERITED(nsHtml5TreeOpExecutor,
+ NS_INTERFACE_TABLE_INHERITED(nsHtml5TreeOpExecutor,
nsIContentSink)
NS_INTERFACE_TABLE_TAIL_INHERITING(nsHtml5DocumentBuilder)
NS_IMPL_ADDREF_INHERITED(nsHtml5TreeOpExecutor, nsContentSink)
NS_IMPL_RELEASE_INHERITED(nsHtml5TreeOpExecutor, nsContentSink)
class nsHtml5ExecutorReflusher : public nsRunnable
--- a/parser/htmlparser/src/nsHTMLEntities.cpp
+++ b/parser/htmlparser/src/nsHTMLEntities.cpp
@@ -81,30 +81,28 @@ static nsrefcnt gTableRefCnt = 0;
static const EntityNode gEntityArray[] = {
#include "nsHTMLEntityList.h"
};
#undef HTML_ENTITY
#define NS_HTML_ENTITY_COUNT ((int32_t)ArrayLength(gEntityArray))
nsresult
-nsHTMLEntities::AddRefTable(void)
+nsHTMLEntities::AddRefTable(void)
{
if (!gTableRefCnt) {
if (!PL_DHashTableInit(&gEntityToUnicode, &EntityToUnicodeOps,
nullptr, sizeof(EntityNodeEntry),
- uint32_t(NS_HTML_ENTITY_COUNT / 0.75),
- fallible_t())) {
+ fallible_t(), NS_HTML_ENTITY_COUNT)) {
gEntityToUnicode.ops = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
if (!PL_DHashTableInit(&gUnicodeToEntity, &UnicodeToEntityOps,
nullptr, sizeof(EntityNodeEntry),
- uint32_t(NS_HTML_ENTITY_COUNT / 0.75),
- fallible_t())) {
+ fallible_t(), NS_HTML_ENTITY_COUNT)) {
PL_DHashTableFinish(&gEntityToUnicode);
gEntityToUnicode.ops = gUnicodeToEntity.ops = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
for (const EntityNode *node = gEntityArray,
*node_end = ArrayEnd(gEntityArray);
node < node_end; ++node) {
--- a/rdf/base/nsInMemoryDataSource.cpp
+++ b/rdf/base/nsInMemoryDataSource.cpp
@@ -158,18 +158,18 @@ Assertion::Assertion(nsIRDFResource* aSo
mNext(nullptr),
mRefCnt(0),
mHashEntry(true)
{
MOZ_COUNT_CTOR(RDF_Assertion);
NS_ADDREF(mSource);
- u.hash.mPropertyHash = PL_NewDHashTable(PL_DHashGetStubOps(),
- nullptr, sizeof(Entry), PL_DHASH_MIN_SIZE);
+ u.hash.mPropertyHash =
+ PL_NewDHashTable(PL_DHashGetStubOps(), nullptr, sizeof(Entry));
}
Assertion::Assertion(nsIRDFResource* aSource,
nsIRDFResource* aProperty,
nsIRDFNode* aTarget,
bool aTruthValue)
: mSource(aSource),
mNext(nullptr),
@@ -780,24 +780,22 @@ InMemoryDataSource::InMemoryDataSource(n
nsresult
InMemoryDataSource::Init()
{
PL_DHashTableInit(&mForwardArcs,
PL_DHashGetStubOps(),
nullptr,
- sizeof(Entry),
- PL_DHASH_MIN_SIZE);
+ sizeof(Entry));
PL_DHashTableInit(&mReverseArcs,
PL_DHashGetStubOps(),
nullptr,
- sizeof(Entry),
- PL_DHASH_MIN_SIZE);
+ sizeof(Entry));
#ifdef PR_LOGGING
if (! gLog)
gLog = PR_NewLogModule("InMemoryDataSource");
#endif
return NS_OK;
}
--- a/rdf/base/nsRDFService.cpp
+++ b/rdf/base/nsRDFService.cpp
@@ -756,29 +756,29 @@ RDFServiceImpl::Init()
PL_CompareStrings,
PL_CompareValues,
&dataSourceHashAllocOps, nullptr);
if (! mNamedDataSources)
return NS_ERROR_OUT_OF_MEMORY;
PL_DHashTableInit(&mResources, &gResourceTableOps, nullptr,
- sizeof(ResourceHashEntry), PL_DHASH_MIN_SIZE);
+ sizeof(ResourceHashEntry));
PL_DHashTableInit(&mLiterals, &gLiteralTableOps, nullptr,
- sizeof(LiteralHashEntry), PL_DHASH_MIN_SIZE);
+ sizeof(LiteralHashEntry));
PL_DHashTableInit(&mInts, &gIntTableOps, nullptr,
- sizeof(IntHashEntry), PL_DHASH_MIN_SIZE);
+ sizeof(IntHashEntry));
PL_DHashTableInit(&mDates, &gDateTableOps, nullptr,
- sizeof(DateHashEntry), PL_DHASH_MIN_SIZE);
+ sizeof(DateHashEntry));
PL_DHashTableInit(&mBlobs, &gBlobTableOps, nullptr,
- sizeof(BlobHashEntry), PL_DHASH_MIN_SIZE);
+ sizeof(BlobHashEntry));
mDefaultResourceFactory = do_GetClassObject(kRDFDefaultResourceCID, &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get default resource factory");
if (NS_FAILED(rv)) return rv;
#ifdef PR_LOGGING
if (! gLog)
gLog = PR_NewLogModule("nsRDFService");
--- a/security/manager/boot/src/nsSecureBrowserUIImpl.cpp
+++ b/security/manager/boot/src/nsSecureBrowserUIImpl.cpp
@@ -452,17 +452,17 @@ void nsSecureBrowserUIImpl::ResetStateTr
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
mDocumentRequestsInProgress = 0;
if (mTransferringRequests.ops) {
PL_DHashTableFinish(&mTransferringRequests);
mTransferringRequests.ops = nullptr;
}
PL_DHashTableInit(&mTransferringRequests, &gMapOps, nullptr,
- sizeof(RequestHashEntry), 16);
+ sizeof(RequestHashEntry));
}
nsresult
nsSecureBrowserUIImpl::EvaluateAndUpdateSecurityState(nsIRequest* aRequest,
nsISupports *info,
bool withNewLocation,
bool withNewSink)
{
--- a/security/manager/ssl/src/TransportSecurityInfo.cpp
+++ b/security/manager/ssl/src/TransportSecurityInfo.cpp
@@ -951,17 +951,17 @@ formatOverridableCertErrorMessage(nsISSL
}
// RememberCertErrorsTable
/*static*/ RememberCertErrorsTable*
RememberCertErrorsTable::sInstance = nullptr;
RememberCertErrorsTable::RememberCertErrorsTable()
- : mErrorHosts(16)
+ : mErrorHosts()
, mMutex("RememberCertErrorsTable::mMutex")
{
}
static nsresult
GetHostPortKey(TransportSecurityInfo* infoObject, nsAutoCString &result)
{
nsresult rv;
--- a/security/manager/ssl/src/nsCertTree.cpp
+++ b/security/manager/ssl/src/nsCertTree.cpp
@@ -182,17 +182,17 @@ void nsCertTree::ClearCompareHash()
mCompareCache.ops = nullptr;
}
}
nsresult nsCertTree::InitCompareHash()
{
ClearCompareHash();
if (!PL_DHashTableInit(&mCompareCache, &gMapOps, nullptr,
- sizeof(CompareCacheHashEntryPtr), 128, fallible_t())) {
+ sizeof(CompareCacheHashEntryPtr), fallible_t(), 64)) {
mCompareCache.ops = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
nsCertTree::~nsCertTree()
{
--- a/security/manager/ssl/src/nsNSSIOLayer.cpp
+++ b/security/manager/ssl/src/nsNSSIOLayer.cpp
@@ -1208,17 +1208,17 @@ nsSSLIOLayerPoll(PRFileDesc* fd, int16_t
(void*) fd, (int) result));
return result;
}
nsSSLIOLayerHelpers::nsSSLIOLayerHelpers()
: mRenegoUnrestrictedSites(nullptr)
, mTreatUnsafeNegotiationAsBroken(false)
, mWarnLevelMissingRFC5746(1)
- , mTLSIntoleranceInfo(16)
+ , mTLSIntoleranceInfo()
, mFalseStartRequireNPN(true)
, mFalseStartRequireForwardSecrecy(false)
, mutex("nsSSLIOLayerHelpers.mutex")
{
}
static int
_PSM_InvalidInt(void)
@@ -1513,17 +1513,17 @@ nsSSLIOLayerHelpers::Init()
nsSSLIOLayerMethods.read = nsSSLIOLayerRead;
nsSSLIOLayerMethods.poll = nsSSLIOLayerPoll;
nsSSLPlaintextLayerIdentity = PR_GetUniqueIdentity("Plaintxext PSM layer");
nsSSLPlaintextLayerMethods = *PR_GetDefaultIOMethods();
nsSSLPlaintextLayerMethods.recv = PlaintextRecv;
}
- mRenegoUnrestrictedSites = new nsTHashtable<nsCStringHashKey>(16);
+ mRenegoUnrestrictedSites = new nsTHashtable<nsCStringHashKey>();
nsCString unrestricted_hosts;
Preferences::GetCString("security.ssl.renego_unrestricted_hosts", &unrestricted_hosts);
if (!unrestricted_hosts.IsEmpty()) {
setRenegoUnrestrictedSites(unrestricted_hosts);
}
bool enabled = false;
--- a/security/manager/ssl/src/nsNSSShutDown.cpp
+++ b/security/manager/ssl/src/nsNSSShutDown.cpp
@@ -47,19 +47,19 @@ nsNSSShutDownList *nsNSSShutDownList::si
nsNSSShutDownList::nsNSSShutDownList()
:mListLock("nsNSSShutDownList.mListLock")
{
mActiveSSLSockets = 0;
mPK11LogoutCancelObjects.ops = nullptr;
mObjects.ops = nullptr;
PL_DHashTableInit(&mObjects, &gSetOps, nullptr,
- sizeof(ObjectHashEntry), 16);
+ sizeof(ObjectHashEntry));
PL_DHashTableInit(&mPK11LogoutCancelObjects, &gSetOps, nullptr,
- sizeof(ObjectHashEntry), 16);
+ sizeof(ObjectHashEntry));
}
nsNSSShutDownList::~nsNSSShutDownList()
{
if (mObjects.ops) {
PL_DHashTableFinish(&mObjects);
mObjects.ops = nullptr;
}
--- a/toolkit/components/places/History.cpp
+++ b/toolkit/components/places/History.cpp
@@ -33,20 +33,20 @@
#include "nsContentUtils.h" // for nsAutoScriptBlocker
#include "nsJSUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "nsPrintfCString.h"
#include "nsTHashtable.h"
#include "jsapi.h"
// Initial size for the cache holding visited status observers.
-#define VISIT_OBSERVERS_INITIAL_CACHE_SIZE 128
-
-// Initial size for the visits removal hash.
-#define VISITS_REMOVAL_INITIAL_HASH_SIZE 128
+#define VISIT_OBSERVERS_INITIAL_CACHE_LENGTH 64
+
+// Initial length for the visits removal hash.
+#define VISITS_REMOVAL_INITIAL_HASH_LENGTH 64
using namespace mozilla::dom;
using namespace mozilla::ipc;
using mozilla::unused;
namespace mozilla {
namespace places {
@@ -1581,17 +1581,17 @@ static PLDHashOperator NotifyVisitRemova
/**
* Notify removed visits to observers.
*/
class NotifyRemoveVisits : public nsRunnable
{
public:
NotifyRemoveVisits(nsTHashtable<PlaceHashKey>& aPlaces)
- : mPlaces(VISITS_REMOVAL_INITIAL_HASH_SIZE)
+ : mPlaces(VISITS_REMOVAL_INITIAL_HASH_LENGTH)
, mHistory(History::GetService())
{
MOZ_ASSERT(!NS_IsMainThread(),
"This should not be called on the main thread");
aPlaces.EnumerateEntries(TransferHashEntries, &mPlaces);
}
NS_IMETHOD Run()
@@ -1688,17 +1688,17 @@ public:
MutexAutoLock lockedScope(mHistory->GetShutdownMutex());
if (mHistory->IsShuttingDown()) {
// If we were already shutting down, we cannot remove the visits.
return NS_OK;
}
// Find all the visits relative to the current filters and whether their
// pages will be removed or not.
- nsTHashtable<PlaceHashKey> places(VISITS_REMOVAL_INITIAL_HASH_SIZE);
+ nsTHashtable<PlaceHashKey> places(VISITS_REMOVAL_INITIAL_HASH_LENGTH);
nsresult rv = FindRemovableVisits(places);
NS_ENSURE_SUCCESS(rv, rv);
if (places.Count() == 0)
return NS_OK;
mozStorageTransaction transaction(mDBConn, false,
mozIStorageConnection::TRANSACTION_IMMEDIATE);
@@ -1920,17 +1920,17 @@ StoreAndNotifyEmbedVisit(VisitData& aPla
////////////////////////////////////////////////////////////////////////////////
//// History
History* History::gService = nullptr;
History::History()
: mShuttingDown(false)
, mShutdownMutex("History::mShutdownMutex")
- , mObservers(VISIT_OBSERVERS_INITIAL_CACHE_SIZE)
+ , mObservers(VISIT_OBSERVERS_INITIAL_CACHE_LENGTH)
, mRecentlyVisitedURIsNextIndex(0)
{
NS_ASSERTION(!gService, "Ruh-roh! This service has already been created!");
gService = this;
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
NS_WARN_IF_FALSE(os, "Observer service was not found!");
if (os) {
--- a/toolkit/components/places/nsFaviconService.cpp
+++ b/toolkit/components/places/nsFaviconService.cpp
@@ -30,20 +30,20 @@
// For large favicons optimization.
#include "imgITools.h"
#include "imgIContainer.h"
// Default value for mOptimizedIconDimension
#define OPTIMIZED_FAVICON_DIMENSION 16
-#define MAX_FAVICON_CACHE_SIZE 256
+#define MAX_FAILED_FAVICONS 256
#define FAVICON_CACHE_REDUCE_COUNT 64
-#define MAX_UNASSOCIATED_FAVICONS 64
+#define UNASSOCIATED_FAVICONS_LENGTH 32
// When replaceFaviconData is called, we store the icons in an in-memory cache
// instead of in storage. Icons in the cache are expired according to this
// interval.
#define UNASSOCIATED_ICON_EXPIRY_INTERVAL 60000
// The MIME type of the default favicon and favicons created by
// OptimizeFaviconImage.
@@ -72,18 +72,18 @@ NS_IMPL_ISUPPORTS_CI(
, nsIFaviconService
, mozIAsyncFavicons
, nsITimerCallback
)
nsFaviconService::nsFaviconService()
: mOptimizedIconDimension(OPTIMIZED_FAVICON_DIMENSION)
, mFailedFaviconSerial(0)
- , mFailedFavicons(MAX_FAVICON_CACHE_SIZE)
- , mUnassociatedIcons(MAX_UNASSOCIATED_FAVICONS)
+ , mFailedFavicons(MAX_FAILED_FAVICONS / 2)
+ , mUnassociatedIcons(UNASSOCIATED_FAVICONS_LENGTH)
{
NS_ASSERTION(!gFaviconService,
"Attempting to create two instances of the service!");
gFaviconService = this;
}
nsFaviconService::~nsFaviconService()
@@ -430,21 +430,21 @@ nsFaviconService::AddFailedFavicon(nsIUR
nsAutoCString spec;
nsresult rv = aFaviconURI->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
mFailedFavicons.Put(spec, mFailedFaviconSerial);
mFailedFaviconSerial ++;
- if (mFailedFavicons.Count() > MAX_FAVICON_CACHE_SIZE) {
+ if (mFailedFavicons.Count() > MAX_FAILED_FAVICONS) {
// need to expire some entries, delete the FAVICON_CACHE_REDUCE_COUNT number
// of items that are the oldest
uint32_t threshold = mFailedFaviconSerial -
- MAX_FAVICON_CACHE_SIZE + FAVICON_CACHE_REDUCE_COUNT;
+ MAX_FAILED_FAVICONS + FAVICON_CACHE_REDUCE_COUNT;
mFailedFavicons.Enumerate(ExpireFailedFaviconsCallback, &threshold);
}
return NS_OK;
}
NS_IMETHODIMP
nsFaviconService::RemoveFailedFavicon(nsIURI* aFaviconURI)
--- a/toolkit/components/places/nsNavBookmarks.cpp
+++ b/toolkit/components/places/nsNavBookmarks.cpp
@@ -14,19 +14,19 @@
#include "nsNetUtil.h"
#include "nsUnicharUtils.h"
#include "nsPrintfCString.h"
#include "prprf.h"
#include "mozilla/storage.h"
#include "GeckoProfiler.h"
-#define BOOKMARKS_TO_KEYWORDS_INITIAL_CACHE_SIZE 64
-#define RECENT_BOOKMARKS_INITIAL_CACHE_SIZE 10
-// Threashold to expire old bookmarks if the initial cache size is exceeded.
+#define BOOKMARKS_TO_KEYWORDS_INITIAL_CACHE_LENGTH 32
+#define RECENT_BOOKMARKS_INITIAL_CACHE_LENGTH 10
+// Threshold to expire old bookmarks if the initial cache size is exceeded.
#define RECENT_BOOKMARKS_THRESHOLD PRTime((int64_t)1 * 60 * PR_USEC_PER_SEC)
#define BEGIN_CRITICAL_BOOKMARK_CACHE_SECTION(_itemId_) \
mUncachableBookmarks.PutEntry(_itemId_); \
mRecentBookmarksCache.RemoveEntry(_itemId_)
#define END_CRITICAL_BOOKMARK_CACHE_SECTION(_itemId_) \
MOZ_ASSERT(!mRecentBookmarksCache.GetEntry(_itemId_)); \
@@ -164,17 +164,17 @@ ExpireNonrecentBookmarksCallback(Bookmar
return PL_DHASH_REMOVE;
}
return PL_DHASH_NEXT;
}
static void
ExpireNonrecentBookmarks(nsTHashtable<BookmarkKeyClass>* hashTable)
{
- if (hashTable->Count() > RECENT_BOOKMARKS_INITIAL_CACHE_SIZE) {
+ if (hashTable->Count() > RECENT_BOOKMARKS_INITIAL_CACHE_LENGTH) {
int64_t threshold = PR_Now() - RECENT_BOOKMARKS_THRESHOLD;
(void)hashTable->EnumerateEntries(ExpireNonrecentBookmarksCallback,
reinterpret_cast<void*>(&threshold));
}
}
static PLDHashOperator
ExpireRecentBookmarksByParentCallback(BookmarkKeyClass* aKey,
@@ -203,20 +203,20 @@ nsNavBookmarks::nsNavBookmarks()
, mRoot(0)
, mMenuRoot(0)
, mTagsRoot(0)
, mUnfiledRoot(0)
, mToolbarRoot(0)
, mCanNotify(false)
, mCacheObservers("bookmark-observers")
, mBatching(false)
- , mBookmarkToKeywordHash(BOOKMARKS_TO_KEYWORDS_INITIAL_CACHE_SIZE)
+ , mBookmarkToKeywordHash(BOOKMARKS_TO_KEYWORDS_INITIAL_CACHE_LENGTH)
, mBookmarkToKeywordHashInitialized(false)
- , mRecentBookmarksCache(RECENT_BOOKMARKS_INITIAL_CACHE_SIZE)
- , mUncachableBookmarks(RECENT_BOOKMARKS_INITIAL_CACHE_SIZE)
+ , mRecentBookmarksCache(RECENT_BOOKMARKS_INITIAL_CACHE_LENGTH)
+ , mUncachableBookmarks(RECENT_BOOKMARKS_INITIAL_CACHE_LENGTH)
{
NS_ASSERTION(!gBookmarksService,
"Attempting to create two instances of the service!");
gBookmarksService = this;
}
nsNavBookmarks::~nsNavBookmarks()
--- a/toolkit/components/places/nsNavHistory.cpp
+++ b/toolkit/components/places/nsNavHistory.cpp
@@ -109,23 +109,23 @@ using namespace mozilla::places;
// These are the day containers and catch-all final container.
#define HISTORY_ADDITIONAL_DATE_CONT_NUM 3
// We use a guess of the number of months considering all of them 30 days
// long, but we split only the last 6 months.
#define HISTORY_DATE_CONT_NUM(_daysFromOldestVisit) \
(HISTORY_ADDITIONAL_DATE_CONT_NUM + \
std::min(6, (int32_t)ceilf((float)_daysFromOldestVisit/30)))
// Max number of containers, used to initialize the params hash.
-#define HISTORY_DATE_CONT_MAX 10
-
-// Initial size of the embed visits cache.
-#define EMBED_VISITS_INITIAL_CACHE_SIZE 128
-
-// Initial size of the recent events caches.
-#define RECENT_EVENTS_INITIAL_CACHE_SIZE 128
+#define HISTORY_DATE_CONT_LENGTH 8
+
+// Initial length of the embed visits cache.
+#define EMBED_VISITS_INITIAL_CACHE_LENGTH 64
+
+// Initial length of the recent events cache.
+#define RECENT_EVENTS_INITIAL_CACHE_LENGTH 64
// Observed topics.
#ifdef MOZ_XUL
#define TOPIC_AUTOCOMPLETE_FEEDBACK_INCOMING "autocomplete-will-enter-text"
#endif
#define TOPIC_IDLE_DAILY "idle-daily"
#define TOPIC_PREF_CHANGED "nsPref:changed"
#define TOPIC_PROFILE_TEARDOWN "profile-change-teardown"
@@ -250,20 +250,20 @@ const int32_t nsNavHistory::kGetInfoInde
PLACES_FACTORY_SINGLETON_IMPLEMENTATION(nsNavHistory, gHistoryService)
nsNavHistory::nsNavHistory()
: mBatchLevel(0)
, mBatchDBTransaction(nullptr)
, mCachedNow(0)
- , mRecentTyped(RECENT_EVENTS_INITIAL_CACHE_SIZE)
- , mRecentLink(RECENT_EVENTS_INITIAL_CACHE_SIZE)
- , mRecentBookmark(RECENT_EVENTS_INITIAL_CACHE_SIZE)
- , mEmbedVisits(EMBED_VISITS_INITIAL_CACHE_SIZE)
+ , mRecentTyped(RECENT_EVENTS_INITIAL_CACHE_LENGTH)
+ , mRecentLink(RECENT_EVENTS_INITIAL_CACHE_LENGTH)
+ , mRecentBookmark(RECENT_EVENTS_INITIAL_CACHE_LENGTH)
+ , mEmbedVisits(EMBED_VISITS_INITIAL_CACHE_LENGTH)
, mHistoryEnabled(true)
, mNumVisitsForFrecency(10)
, mTagsFolder(-1)
, mDaysOfHistory(-1)
, mLastCachedStartOfDay(INT64_MAX)
, mLastCachedEndOfDay(0)
, mCanNotify(true)
, mCacheObservers("history-observers")
@@ -2185,18 +2185,18 @@ nsNavHistory::GetQueryResults(nsNavHisto
{
NS_ENSURE_ARG_POINTER(aOptions);
NS_ASSERTION(aResults->Count() == 0, "Initial result array must be empty");
if (! aQueries.Count())
return NS_ERROR_INVALID_ARG;
nsCString queryString;
bool paramsPresent = false;
- nsNavHistory::StringHash addParams(HISTORY_DATE_CONT_MAX);
- nsresult rv = ConstructQueryString(aQueries, aOptions, queryString,
+ nsNavHistory::StringHash addParams(HISTORY_DATE_CONT_LENGTH);
+ nsresult rv = ConstructQueryString(aQueries, aOptions, queryString,
paramsPresent, addParams);
NS_ENSURE_SUCCESS(rv,rv);
// create statement
nsCOMPtr<mozIStorageStatement> statement = mDB->GetStatement(queryString);
#ifdef DEBUG
if (!statement) {
nsAutoCString lastErrorString;
@@ -2962,17 +2962,17 @@ nsNavHistory::AsyncExecuteLegacyQueries(
}
NS_ENSURE_ARG_MIN(queries.Count(), 1);
nsCOMPtr<nsNavHistoryQueryOptions> options = do_QueryInterface(aOptions);
NS_ENSURE_ARG(options);
nsCString queryString;
bool paramsPresent = false;
- nsNavHistory::StringHash addParams(HISTORY_DATE_CONT_MAX);
+ nsNavHistory::StringHash addParams(HISTORY_DATE_CONT_LENGTH);
nsresult rv = ConstructQueryString(queries, options, queryString,
paramsPresent, addParams);
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr<mozIStorageAsyncStatement> statement =
mDB->GetAsyncStatement(queryString);
NS_ENSURE_STATE(statement);
--- a/toolkit/components/places/nsNavHistoryResult.cpp
+++ b/toolkit/components/places/nsNavHistoryResult.cpp
@@ -4014,17 +4014,17 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
NS_INTERFACE_MAP_END
nsNavHistoryResult::nsNavHistoryResult(nsNavHistoryContainerResultNode* aRoot)
: mRootNode(aRoot)
, mNeedsToApplySortingMode(false)
, mIsHistoryObserver(false)
, mIsBookmarkFolderObserver(false)
, mIsAllBookmarksObserver(false)
- , mBookmarkFolderObservers(128)
+ , mBookmarkFolderObservers(64)
, mBatchInProgress(false)
, mSuppressNotifications(false)
{
mRootNode->mResult = this;
}
nsNavHistoryResult::~nsNavHistoryResult()
{
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -72,31 +72,31 @@ namespace {
using namespace base;
using namespace mozilla;
template<class EntryType>
class AutoHashtable : public nsTHashtable<EntryType>
{
public:
- AutoHashtable(uint32_t initSize = PL_DHASH_MIN_SIZE);
+ AutoHashtable(uint32_t initLength = PL_DHASH_DEFAULT_INITIAL_LENGTH);
typedef bool (*ReflectEntryFunc)(EntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj);
bool ReflectIntoJS(ReflectEntryFunc entryFunc, JSContext *cx, JS::Handle<JSObject*> obj);
private:
struct EnumeratorArgs {
JSContext *cx;
JS::Handle<JSObject*> obj;
ReflectEntryFunc entryFunc;
};
static PLDHashOperator ReflectEntryStub(EntryType *entry, void *arg);
};
template<class EntryType>
-AutoHashtable<EntryType>::AutoHashtable(uint32_t initSize)
- : nsTHashtable<EntryType>(initSize)
+AutoHashtable<EntryType>::AutoHashtable(uint32_t initLength)
+ : nsTHashtable<EntryType>(initLength)
{
}
template<typename EntryType>
PLDHashOperator
AutoHashtable<EntryType>::ReflectEntryStub(EntryType *entry, void *arg)
{
EnumeratorArgs *args = static_cast<EnumeratorArgs *>(arg);
--- a/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp
+++ b/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp
@@ -21,17 +21,17 @@
#include "nsIURI.h"
class nsUnixSystemProxySettings MOZ_FINAL : public nsISystemProxySettings {
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISYSTEMPROXYSETTINGS
nsUnixSystemProxySettings()
- : mSchemeProxySettings(5)
+ : mSchemeProxySettings(4)
{
}
nsresult Init();
private:
~nsUnixSystemProxySettings() {}
nsCOMPtr<nsIGConfService> mGConf;
--- a/uriloader/base/nsDocLoader.cpp
+++ b/uriloader/base/nsDocLoader.cpp
@@ -120,17 +120,17 @@ nsDocLoader::nsDocLoader()
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
RequestInfoHashClearEntry,
PL_DHashFinalizeStub,
RequestInfoHashInitEntry
};
PL_DHashTableInit(&mRequestInfoHash, &hash_table_ops, nullptr,
- sizeof(nsRequestInfo), 16);
+ sizeof(nsRequestInfo));
ClearInternalProgress();
PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
("DocLoader:%p: created.\n", this));
}
nsresult
--- a/xpcom/base/CycleCollectedJSRuntime.cpp
+++ b/xpcom/base/CycleCollectedJSRuntime.cpp
@@ -467,17 +467,17 @@ NoteJSChildGrayWrapperShim(void* aData,
static const JSZoneParticipant sJSZoneCycleCollectorGlobal;
CycleCollectedJSRuntime::CycleCollectedJSRuntime(JSRuntime* aParentRuntime,
uint32_t aMaxBytes,
uint32_t aMaxNurseryBytes)
: mGCThingCycleCollectorGlobal(sGCThingCycleCollectorGlobal)
, mJSZoneCycleCollectorGlobal(sJSZoneCycleCollectorGlobal)
, mJSRuntime(nullptr)
- , mJSHolders(512)
+ , mJSHolders(256)
, mOutOfMemoryState(OOMState::OK)
, mLargeAllocationFailureState(OOMState::OK)
{
mozilla::dom::InitScriptSettings();
mJSRuntime = JS_NewRuntime(aMaxBytes, aMaxNurseryBytes, aParentRuntime);
if (!mJSRuntime) {
MOZ_CRASH();
--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -850,17 +850,17 @@ public:
PL_DHashTableFinish(&mPtrToNodeMap);
}
}
void Init()
{
MOZ_ASSERT(IsEmpty(), "Failed to call CCGraph::Clear");
PL_DHashTableInit(&mPtrToNodeMap, &PtrNodeOps, nullptr,
- sizeof(PtrToNodeEntry), 32768);
+ sizeof(PtrToNodeEntry), 16384);
}
void Clear()
{
mNodes.Clear();
mEdges.Clear();
mWeakMaps.Clear();
mRootCount = 0;
--- a/xpcom/base/nsTraceRefcnt.cpp
+++ b/xpcom/base/nsTraceRefcnt.cpp
@@ -209,20 +209,17 @@ static const PLHashAllocOps typesToLogHa
////////////////////////////////////////////////////////////////////////////////
#ifdef STACKWALKING_AVAILABLE
class CodeAddressServiceStringTable MOZ_FINAL
{
public:
- CodeAddressServiceStringTable()
- : mSet(64)
- {
- }
+ CodeAddressServiceStringTable() : mSet(32) {}
const char* Intern(const char* aString)
{
nsCharPtrHashKey* e = mSet.PutEntry(aString);
return e->GetKey();
}
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -301,21 +301,21 @@ nsComponentManagerImpl::Create(nsISuppor
if (!gComponentManager) {
return NS_ERROR_FAILURE;
}
return gComponentManager->QueryInterface(aIID, aResult);
}
-static const int CONTRACTID_HASHTABLE_INITIAL_SIZE = 2048;
+static const int CONTRACTID_HASHTABLE_INITIAL_LENGTH = 1024;
nsComponentManagerImpl::nsComponentManagerImpl()
- : mFactories(CONTRACTID_HASHTABLE_INITIAL_SIZE)
- , mContractIDs(CONTRACTID_HASHTABLE_INITIAL_SIZE)
+ : mFactories(CONTRACTID_HASHTABLE_INITIAL_LENGTH)
+ , mContractIDs(CONTRACTID_HASHTABLE_INITIAL_LENGTH)
, mLock("nsComponentManagerImpl.mLock")
, mStatus(NOT_INITIALIZED)
{
}
nsTArray<const mozilla::Module*>* nsComponentManagerImpl::sStaticModules;
NSMODULE_DEFN(start_kPStaticModules);
--- a/xpcom/ds/nsAtomTable.cpp
+++ b/xpcom/ds/nsAtomTable.cpp
@@ -533,24 +533,24 @@ NS_SizeOfAtomTablesIncludingThis(MallocS
// The atoms in the this table are almost certainly stored in static data, so
// we don't need a SizeOfEntry function.
*aStatic = gStaticAtomTable
? gStaticAtomTable->SizeOfIncludingThis(nullptr, aMallocSizeOf)
: 0;
}
-#define ATOM_HASHTABLE_INITIAL_SIZE 4096
+#define ATOM_HASHTABLE_INITIAL_LENGTH 2048
static inline void
EnsureTableExists()
{
if (!gAtomTable.ops) {
PL_DHashTableInit(&gAtomTable, &AtomTableOps, 0,
- sizeof(AtomTableEntry), ATOM_HASHTABLE_INITIAL_SIZE);
+ sizeof(AtomTableEntry), ATOM_HASHTABLE_INITIAL_LENGTH);
}
}
static inline AtomTableEntry*
GetAtomHashEntry(const char* aString, uint32_t aLength, uint32_t* aHashOut)
{
MOZ_ASSERT(NS_IsMainThread(), "wrong thread");
EnsureTableExists();
--- a/xpcom/ds/nsPersistentProperties.cpp
+++ b/xpcom/ds/nsPersistentProperties.cpp
@@ -461,17 +461,17 @@ nsPropertiesParser::ParseBuffer(const ch
}
nsPersistentProperties::nsPersistentProperties()
: mIn(nullptr)
{
mSubclass = static_cast<nsIPersistentProperties*>(this);
PL_DHashTableInit(&mTable, &property_HashTableOps, nullptr,
- sizeof(PropertyTableEntry), 20);
+ sizeof(PropertyTableEntry), 16);
PL_INIT_ARENA_POOL(&mArena, "PersistentPropertyArena", 2048);
}
nsPersistentProperties::~nsPersistentProperties()
{
PL_FinishArenaPool(&mArena);
if (mTable.ops) {
--- a/xpcom/ds/nsStaticNameTable.cpp
+++ b/xpcom/ds/nsStaticNameTable.cpp
@@ -124,37 +124,37 @@ nsStaticCaseInsensitiveNameTable::~nsSta
if (mNameTable.ops) {
PL_DHashTableFinish(&mNameTable);
}
MOZ_COUNT_DTOR(nsStaticCaseInsensitiveNameTable);
}
bool
nsStaticCaseInsensitiveNameTable::Init(const char* const aNames[],
- int32_t aCount)
+ int32_t aLength)
{
NS_ASSERTION(!mNameArray, "double Init");
NS_ASSERTION(!mNameTable.ops, "double Init");
NS_ASSERTION(aNames, "null name table");
- NS_ASSERTION(aCount, "0 count");
+ NS_ASSERTION(aLength, "0 length");
mNameArray = (nsDependentCString*)
- nsMemory::Alloc(aCount * sizeof(nsDependentCString));
+ nsMemory::Alloc(aLength * sizeof(nsDependentCString));
if (!mNameArray) {
return false;
}
if (!PL_DHashTableInit(&mNameTable, &nametable_CaseInsensitiveHashTableOps,
- nullptr, sizeof(NameTableEntry), aCount,
- fallible_t())) {
+ nullptr, sizeof(NameTableEntry), fallible_t(),
+ aLength)) {
mNameTable.ops = nullptr;
return false;
}
- for (int32_t index = 0; index < aCount; ++index) {
+ for (int32_t index = 0; index < aLength; ++index) {
const char* raw = aNames[index];
#ifdef DEBUG
{
// verify invariants of contents
nsAutoCString temp1(raw);
nsDependentCString temp2(raw);
ToLowerCase(temp1);
NS_ASSERTION(temp1.Equals(temp2), "upper case char in table");
--- a/xpcom/ds/nsStaticNameTable.h
+++ b/xpcom/ds/nsStaticNameTable.h
@@ -28,17 +28,17 @@
* as long as this table object - typically a static string array.
*/
class nsStaticCaseInsensitiveNameTable
{
public:
enum { NOT_FOUND = -1 };
- bool Init(const char* const aNames[], int32_t aCount);
+ bool Init(const char* const aNames[], int32_t aLength);
int32_t Lookup(const nsACString& aName);
int32_t Lookup(const nsAString& aName);
const nsAFlatCString& GetStringValue(int32_t aIndex);
nsStaticCaseInsensitiveNameTable();
~nsStaticCaseInsensitiveNameTable();
private:
--- a/xpcom/glue/DeadlockDetector.h
+++ b/xpcom/glue/DeadlockDetector.h
@@ -499,14 +499,14 @@ public:
private:
DeadlockDetector(const DeadlockDetector& aDD) MOZ_DELETE;
DeadlockDetector& operator=(const DeadlockDetector& aDD) MOZ_DELETE;
};
template<typename T>
// FIXME bug 456272: tune based on average workload
-const uint32_t DeadlockDetector<T>::kDefaultNumBuckets = 64;
+const uint32_t DeadlockDetector<T>::kDefaultNumBuckets = 32;
} // namespace mozilla
#endif // ifndef mozilla_DeadlockDetector_h
--- a/xpcom/glue/nsBaseHashtable.h
+++ b/xpcom/glue/nsBaseHashtable.h
@@ -57,18 +57,18 @@ class nsBaseHashtable
public:
typedef typename KeyClass::KeyType KeyType;
typedef nsBaseHashtableET<KeyClass, DataType> EntryType;
using nsTHashtable<EntryType>::Contains;
nsBaseHashtable() {}
- explicit nsBaseHashtable(uint32_t aInitSize)
- : nsTHashtable<EntryType>(aInitSize)
+ explicit nsBaseHashtable(uint32_t aInitLength)
+ : nsTHashtable<EntryType>(aInitLength)
{
}
/**
* Return the number of entries in the table.
* @return number of entries
*/
uint32_t Count() const { return nsTHashtable<EntryType>::Count(); }
--- a/xpcom/glue/nsClassHashtable.h
+++ b/xpcom/glue/nsClassHashtable.h
@@ -25,18 +25,18 @@ class nsClassHashtable
: public nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef T* UserDataType;
typedef nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*> base_type;
nsClassHashtable() {}
- explicit nsClassHashtable(uint32_t aInitSize)
- : nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>(aInitSize)
+ explicit nsClassHashtable(uint32_t aInitLength)
+ : nsBaseHashtable<KeyClass, nsAutoPtr<T>, T*>(aInitLength)
{
}
/**
* @copydoc nsBaseHashtable::Get
* @param aData if the key doesn't exist, pData will be set to nullptr.
*/
bool Get(KeyType aKey, UserDataType* aData) const;
--- a/xpcom/glue/nsDataHashtable.h
+++ b/xpcom/glue/nsDataHashtable.h
@@ -19,15 +19,15 @@
* @see nsInterfaceHashtable, nsClassHashtable
*/
template<class KeyClass, class DataType>
class nsDataHashtable
: public nsBaseHashtable<KeyClass, DataType, DataType>
{
public:
nsDataHashtable() {}
- explicit nsDataHashtable(uint32_t aInitSize)
- : nsBaseHashtable<KeyClass, DataType, DataType>(aInitSize)
+ explicit nsDataHashtable(uint32_t aInitLength)
+ : nsBaseHashtable<KeyClass, DataType, DataType>(aInitLength)
{
}
};
#endif // nsDataHashtable_h__
--- a/xpcom/glue/nsInterfaceHashtable.h
+++ b/xpcom/glue/nsInterfaceHashtable.h
@@ -24,18 +24,18 @@ class nsInterfaceHashtable
: public nsBaseHashtable<KeyClass, nsCOMPtr<Interface>, Interface*>
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef Interface* UserDataType;
typedef nsBaseHashtable<KeyClass, nsCOMPtr<Interface>, Interface*> base_type;
nsInterfaceHashtable() {}
- explicit nsInterfaceHashtable(uint32_t aInitSize)
- : nsBaseHashtable<KeyClass, nsCOMPtr<Interface>, Interface*>(aInitSize)
+ explicit nsInterfaceHashtable(uint32_t aInitLength)
+ : nsBaseHashtable<KeyClass, nsCOMPtr<Interface>, Interface*>(aInitLength)
{
}
/**
* @copydoc nsBaseHashtable::Get
* @param aData This is an XPCOM getter, so aData is already_addrefed.
* If the key doesn't exist, aData will be set to nullptr.
*/
--- a/xpcom/glue/nsRefPtrHashtable.h
+++ b/xpcom/glue/nsRefPtrHashtable.h
@@ -24,18 +24,18 @@ class nsRefPtrHashtable
: public nsBaseHashtable<KeyClass, nsRefPtr<RefPtr>, RefPtr*>
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef RefPtr* UserDataType;
typedef nsBaseHashtable<KeyClass, nsRefPtr<RefPtr>, RefPtr*> base_type;
nsRefPtrHashtable() {}
- explicit nsRefPtrHashtable(uint32_t aInitSize)
- : nsBaseHashtable<KeyClass, nsRefPtr<RefPtr>, RefPtr*>(aInitSize)
+ explicit nsRefPtrHashtable(uint32_t aInitLength)
+ : nsBaseHashtable<KeyClass, nsRefPtr<RefPtr>, RefPtr*>(aInitLength)
{
}
/**
* @copydoc nsBaseHashtable::Get
* @param aData This is an XPCOM getter, so aData is already_addrefed.
* If the key doesn't exist, aData will be set to nullptr.
*/
--- a/xpcom/glue/nsTHashtable.h
+++ b/xpcom/glue/nsTHashtable.h
@@ -78,20 +78,20 @@ NS_COM_GLUE PLDHashOperator PL_DHashStub
*/
template<class EntryType>
class nsTHashtable
{
typedef mozilla::fallible_t fallible_t;
public:
- // Separate constructors instead of default aInitSize parameter since
+ // Separate constructors instead of default aInitLength parameter since
// otherwise the default no-arg constructor isn't found.
- nsTHashtable() { Init(PL_DHASH_MIN_SIZE); }
- explicit nsTHashtable(uint32_t aInitSize) { Init(aInitSize); }
+ nsTHashtable() { Init(PL_DHASH_DEFAULT_INITIAL_LENGTH); }
+ explicit nsTHashtable(uint32_t aInitLength) { Init(aInitLength); }
/**
* destructor, cleans up and deallocates
*/
~nsTHashtable();
nsTHashtable(nsTHashtable<EntryType>&& aOther);
@@ -357,19 +357,19 @@ protected:
mozilla::MallocSizeOf aMallocSizeOf, void* aArg);
private:
// copy constructor, not implemented
nsTHashtable(nsTHashtable<EntryType>& aToCopy) MOZ_DELETE;
/**
* Initialize the table.
- * @param aInitSize the initial number of buckets in the hashtable
+ * @param aInitLength the initial number of buckets in the hashtable
*/
- void Init(uint32_t aInitSize);
+ void Init(uint32_t aInitLength);
/**
* An implementation of SizeOfEntryExcludingThisFun that calls SizeOfExcludingThis()
* on each entry.
*/
static size_t BasicSizeOfEntryExcludingThisFun(EntryType* aEntry,
mozilla::MallocSizeOf aMallocSizeOf,
void*);
@@ -400,31 +400,31 @@ nsTHashtable<EntryType>::~nsTHashtable()
{
if (mTable.entrySize) {
PL_DHashTableFinish(&mTable);
}
}
template<class EntryType>
void
-nsTHashtable<EntryType>::Init(uint32_t aInitSize)
+nsTHashtable<EntryType>::Init(uint32_t aInitLength)
{
static const PLDHashTableOps sOps =
{
::PL_DHashAllocTable,
::PL_DHashFreeTable,
s_HashKey,
s_MatchEntry,
EntryType::ALLOW_MEMMOVE ? ::PL_DHashMoveEntryStub : s_CopyEntry,
s_ClearEntry,
::PL_DHashFinalizeStub,
s_InitEntry
};
- PL_DHashTableInit(&mTable, &sOps, nullptr, sizeof(EntryType), aInitSize);
+ PL_DHashTableInit(&mTable, &sOps, nullptr, sizeof(EntryType), aInitLength);
}
// static
template<class EntryType>
size_t
nsTHashtable<EntryType>::BasicSizeOfEntryExcludingThisFun(EntryType* aEntry,
mozilla::MallocSizeOf aMallocSizeOf,
void*)
--- a/xpcom/glue/pldhash.cpp
+++ b/xpcom/glue/pldhash.cpp
@@ -165,70 +165,105 @@ SizeOfEntryStore(uint32_t aCapacity, uin
{
uint64_t nbytes64 = uint64_t(aCapacity) * uint64_t(aEntrySize);
*aNbytes = aCapacity * aEntrySize;
return uint64_t(*aNbytes) == nbytes64; // returns false on overflow
}
PLDHashTable*
PL_NewDHashTable(const PLDHashTableOps* aOps, void* aData, uint32_t aEntrySize,
- uint32_t aCapacity)
+ uint32_t aLength)
{
PLDHashTable* table = (PLDHashTable*)malloc(sizeof(*table));
if (!table) {
return nullptr;
}
- if (!PL_DHashTableInit(table, aOps, aData, aEntrySize, aCapacity,
- fallible_t())) {
+ if (!PL_DHashTableInit(table, aOps, aData, aEntrySize, fallible_t(),
+ aLength)) {
free(table);
return nullptr;
}
return table;
}
void
PL_DHashTableDestroy(PLDHashTable* aTable)
{
PL_DHashTableFinish(aTable);
free(aTable);
}
+/*
+ * Compute max and min load numbers (entry counts). We have a secondary max
+ * that allows us to overload a table reasonably if it cannot be grown further
+ * (i.e. if ChangeTable() fails). The table slows down drastically if the
+ * secondary max is too close to 1, but 0.96875 gives only a slight slowdown
+ * while allowing 1.3x more elements.
+ */
+static inline uint32_t
+MaxLoad(uint32_t aCapacity)
+{
+ return aCapacity - (aCapacity >> 2); // == aCapacity * 0.75
+}
+static inline uint32_t
+MaxLoadOnGrowthFailure(uint32_t aCapacity)
+{
+ return aCapacity - (aCapacity >> 5); // == aCapacity * 0.96875
+}
+static inline uint32_t
+MinLoad(uint32_t aCapacity)
+{
+ return aCapacity >> 2; // == aCapacity * 0.25
+}
+
+static inline uint32_t
+MinCapacity(uint32_t aLength)
+{
+ return (aLength * 4 + (3 - 1)) / 3; // == ceil(aLength * 4 / 3)
+}
+
bool
PL_DHashTableInit(PLDHashTable* aTable, const PLDHashTableOps* aOps,
- void* aData, uint32_t aEntrySize, uint32_t aCapacity,
- const fallible_t&)
+ void* aData, uint32_t aEntrySize, const fallible_t&,
+ uint32_t aLength)
{
#ifdef DEBUG
if (aEntrySize > 16 * sizeof(void*)) {
printf_stderr(
"pldhash: for the aTable at address %p, the given aEntrySize"
" of %lu definitely favors chaining over double hashing.\n",
(void*)aTable,
(unsigned long) aEntrySize);
}
#endif
- aTable->ops = aOps;
- aTable->data = aData;
- if (aCapacity < PL_DHASH_MIN_SIZE) {
- aCapacity = PL_DHASH_MIN_SIZE;
+ if (aLength > PL_DHASH_MAX_INITIAL_LENGTH) {
+ return false;
}
- int log2 = CeilingLog2(aCapacity);
+ aTable->ops = aOps;
+ aTable->data = aData;
- aCapacity = 1u << log2;
- if (aCapacity > PL_DHASH_MAX_SIZE) {
- return false;
+ // Compute the smallest capacity allowing |aLength| elements to be inserted
+ // without rehashing.
+ uint32_t capacity = MinCapacity(aLength);
+ if (capacity < PL_DHASH_MIN_CAPACITY) {
+ capacity = PL_DHASH_MIN_CAPACITY;
}
+
+ int log2 = CeilingLog2(capacity);
+
+ capacity = 1u << log2;
+ MOZ_ASSERT(capacity <= PL_DHASH_MAX_CAPACITY);
aTable->hashShift = PL_DHASH_BITS - log2;
aTable->entrySize = aEntrySize;
aTable->entryCount = aTable->removedCount = 0;
aTable->generation = 0;
uint32_t nbytes;
- if (!SizeOfEntryStore(aCapacity, aEntrySize, &nbytes))
+ if (!SizeOfEntryStore(capacity, aEntrySize, &nbytes))
return false; // overflowed
aTable->entryStore = (char*)aOps->allocTable(aTable, nbytes);
if (!aTable->entryStore) {
return false;
}
memset(aTable->entryStore, 0, nbytes);
METER(memset(&aTable->stats, 0, sizeof(aTable->stats)));
@@ -236,55 +271,33 @@ PL_DHashTableInit(PLDHashTable* aTable,
#ifdef DEBUG
aTable->recursionLevel = 0;
#endif
return true;
}
void
-PL_DHashTableInit(PLDHashTable* aTable, const PLDHashTableOps* aOps, void* aData,
- uint32_t aEntrySize, uint32_t aCapacity)
+PL_DHashTableInit(PLDHashTable* aTable, const PLDHashTableOps* aOps,
+ void* aData, uint32_t aEntrySize, uint32_t aLength)
{
- if (!PL_DHashTableInit(aTable, aOps, aData, aEntrySize, aCapacity, fallible_t())) {
- if (aCapacity > PL_DHASH_MAX_SIZE) {
- MOZ_CRASH();
+ if (!PL_DHashTableInit(aTable, aOps, aData, aEntrySize, fallible_t(),
+ aLength)) {
+ if (aLength > PL_DHASH_MAX_INITIAL_LENGTH) {
+ MOZ_CRASH(); // the asked-for length was too big
}
- uint32_t nbytes;
- if (!SizeOfEntryStore(aCapacity, aEntrySize, &nbytes)) {
- MOZ_CRASH();
+ uint32_t capacity = MinCapacity(aLength), nbytes;
+ if (!SizeOfEntryStore(capacity, aEntrySize, &nbytes)) {
+ MOZ_CRASH(); // the required entryStore size was too big
}
- NS_ABORT_OOM(nbytes);
+ NS_ABORT_OOM(nbytes); // allocation failed
}
}
/*
- * Compute max and min load numbers (entry counts). We have a secondary max
- * that allows us to overload a table reasonably if it cannot be grown further
- * (i.e. if ChangeTable() fails). The table slows down drastically if the
- * secondary max is too close to 1, but 0.96875 gives only a slight slowdown
- * while allowing 1.3x more elements.
- */
-static inline uint32_t
-MaxLoad(uint32_t aSize)
-{
- return aSize - (aSize >> 2); // == aSize * 0.75
-}
-static inline uint32_t
-MaxLoadOnGrowthFailure(uint32_t aSize)
-{
- return aSize - (aSize >> 5); // == aSize * 0.96875
-}
-static inline uint32_t
-MinLoad(uint32_t aSize)
-{
- return aSize >> 2; // == aSize * 0.25
-}
-
-/*
* Double hashing needs the second hash code to be relatively prime to table
* size, so we simply make hash2 odd.
*/
#define HASH1(hash0, shift) ((hash0) >> (shift))
#define HASH2(hash0,log2,shift) ((((hash0) << (log2)) >> (shift)) | 1)
/*
* Reserve keyHash 0 for free entries and 1 for removed-entry sentinels. Note
@@ -319,17 +332,17 @@ PL_DHashTableFinish(PLDHashTable* aTable
INCREMENT_RECURSION_LEVEL(aTable);
/* Call finalize before clearing entries, so it can enumerate them. */
aTable->ops->finalize(aTable);
/* Clear any remaining live entries. */
char* entryAddr = aTable->entryStore;
uint32_t entrySize = aTable->entrySize;
- char* entryLimit = entryAddr + PL_DHASH_TABLE_SIZE(aTable) * entrySize;
+ char* entryLimit = entryAddr + PL_DHASH_TABLE_CAPACITY(aTable) * entrySize;
while (entryAddr < entryLimit) {
PLDHashEntryHdr* entry = (PLDHashEntryHdr*)entryAddr;
if (ENTRY_IS_LIVE(entry)) {
METER(aTable->stats.removeEnums++);
aTable->ops->clearEntry(aTable, entry);
}
entryAddr += entrySize;
}
@@ -463,17 +476,17 @@ FindFreeEntry(PLDHashTable* aTable, PLDH
static bool
ChangeTable(PLDHashTable* aTable, int aDeltaLog2)
{
/* Look, but don't touch, until we succeed in getting new entry store. */
int oldLog2 = PL_DHASH_BITS - aTable->hashShift;
int newLog2 = oldLog2 + aDeltaLog2;
uint32_t newCapacity = 1u << newLog2;
- if (newCapacity > PL_DHASH_MAX_SIZE) {
+ if (newCapacity > PL_DHASH_MAX_CAPACITY) {
return false;
}
uint32_t entrySize = aTable->entrySize;
uint32_t nbytes;
if (!SizeOfEntryStore(newCapacity, entrySize, &nbytes)) {
return false; // overflowed
}
@@ -543,36 +556,36 @@ PL_DHashTableOperate(PLDHashTable* aTabl
break;
case PL_DHASH_ADD: {
/*
* If alpha is >= .75, grow or compress the table. If aKey is already
* in the table, we may grow once more than necessary, but only if we
* are on the edge of being overloaded.
*/
- uint32_t size = PL_DHASH_TABLE_SIZE(aTable);
- if (aTable->entryCount + aTable->removedCount >= MaxLoad(size)) {
+ uint32_t capacity = PL_DHASH_TABLE_CAPACITY(aTable);
+ if (aTable->entryCount + aTable->removedCount >= MaxLoad(capacity)) {
/* Compress if a quarter or more of all entries are removed. */
int deltaLog2;
- if (aTable->removedCount >= size >> 2) {
+ if (aTable->removedCount >= capacity >> 2) {
METER(aTable->stats.compresses++);
deltaLog2 = 0;
} else {
METER(aTable->stats.grows++);
deltaLog2 = 1;
}
/*
* Grow or compress aTable. If ChangeTable() fails, allow
* overloading up to the secondary max. Once we hit the secondary
* max, return null.
*/
if (!ChangeTable(aTable, deltaLog2) &&
aTable->entryCount + aTable->removedCount >=
- MaxLoadOnGrowthFailure(size)) {
+ MaxLoadOnGrowthFailure(capacity)) {
METER(aTable->stats.addFailures++);
entry = nullptr;
break;
}
}
/*
* Look for entry after possibly growing, so we don't have to add it,
@@ -606,19 +619,19 @@ PL_DHashTableOperate(PLDHashTable* aTabl
case PL_DHASH_REMOVE:
entry = SearchTable(aTable, aKey, keyHash, aOp);
if (ENTRY_IS_LIVE(entry)) {
/* Clear this entry and mark it as "removed". */
METER(aTable->stats.removeHits++);
PL_DHashTableRawRemove(aTable, entry);
/* Shrink if alpha is <= .25 and aTable isn't too small already. */
- uint32_t size = PL_DHASH_TABLE_SIZE(aTable);
- if (size > PL_DHASH_MIN_SIZE &&
- aTable->entryCount <= MinLoad(size)) {
+ uint32_t capacity = PL_DHASH_TABLE_CAPACITY(aTable);
+ if (capacity > PL_DHASH_MIN_CAPACITY &&
+ aTable->entryCount <= MinLoad(capacity)) {
METER(aTable->stats.shrinks++);
(void) ChangeTable(aTable, -1);
}
}
METER(else {
aTable->stats.removeMisses++;
});
entry = nullptr;
@@ -657,17 +670,17 @@ PL_DHashTableRawRemove(PLDHashTable* aTa
uint32_t
PL_DHashTableEnumerate(PLDHashTable* aTable, PLDHashEnumerator aEtor, void* aArg)
{
INCREMENT_RECURSION_LEVEL(aTable);
char* entryAddr = aTable->entryStore;
uint32_t entrySize = aTable->entrySize;
- uint32_t capacity = PL_DHASH_TABLE_SIZE(aTable);
+ uint32_t capacity = PL_DHASH_TABLE_CAPACITY(aTable);
uint32_t tableSize = capacity * entrySize;
char* entryLimit = entryAddr + tableSize;
uint32_t i = 0;
bool didRemove = false;
if (ChaosMode::isActive()) {
// Start iterating at a random point in the hashtable. It would be
// even more chaotic to iterate in fully random order, but that's a lot
@@ -703,23 +716,23 @@ PL_DHashTableEnumerate(PLDHashTable* aTa
* Shrink or compress if a quarter or more of all entries are removed, or
* if the table is underloaded according to the minimum alpha, and is not
* minimal-size already. Do this only if we removed above, so non-removing
* enumerations can count on stable aTable->entryStore until the next
* non-lookup-Operate or removing-Enumerate.
*/
if (didRemove &&
(aTable->removedCount >= capacity >> 2 ||
- (capacity > PL_DHASH_MIN_SIZE &&
+ (capacity > PL_DHASH_MIN_CAPACITY &&
aTable->entryCount <= MinLoad(capacity)))) {
METER(aTable->stats.enumShrinks++);
capacity = aTable->entryCount;
capacity += capacity >> 1;
- if (capacity < PL_DHASH_MIN_SIZE) {
- capacity = PL_DHASH_MIN_SIZE;
+ if (capacity < PL_DHASH_MIN_CAPACITY) {
+ capacity = PL_DHASH_MIN_CAPACITY;
}
uint32_t ceiling = CeilingLog2(capacity);
ceiling -= PL_DHASH_BITS - aTable->hashShift;
(void) ChangeTable(aTable, ceiling);
}
@@ -792,23 +805,23 @@ PL_DHashTableDumpMeter(PLDHashTable* aTa
PLDHashNumber hash1, hash2, maxChainHash1, maxChainHash2;
double sqsum, mean, variance, sigma;
PLDHashEntryHdr* entry;
char* entryAddr = aTable->entryStore;
uint32_t entrySize = aTable->entrySize;
int hashShift = aTable->hashShift;
int sizeLog2 = PL_DHASH_BITS - hashShift;
- uint32_t tableSize = PL_DHASH_TABLE_SIZE(aTable);
+ uint32_t capacity = PL_DHASH_TABLE_CAPACITY(aTable);
uint32_t sizeMask = (1u << sizeLog2) - 1;
uint32_t chainCount = 0, maxChainLen = 0;
hash2 = 0;
sqsum = 0;
- for (uint32_t i = 0; i < tableSize; i++) {
+ for (uint32_t i = 0; i < capacity; i++) {
entry = (PLDHashEntryHdr*)entryAddr;
entryAddr += entrySize;
if (!ENTRY_IS_LIVE(entry)) {
continue;
}
hash1 = HASH1(entry->keyHash & ~COLLISION_FLAG, hashShift);
PLDHashNumber saveHash1 = hash1;
PLDHashEntryHdr* probe = ADDRESS_ENTRY(aTable, hash1);
--- a/xpcom/glue/pldhash.h
+++ b/xpcom/glue/pldhash.h
@@ -18,31 +18,34 @@
#define PL_DHASH_FASTCALL __attribute__ ((regparm (3),stdcall))
#elif defined(XP_WIN)
#define PL_DHASH_FASTCALL __fastcall
#else
#define PL_DHASH_FASTCALL
#endif
/*
- * Table size limit; do not exceed. The max capacity used to be 1<<23 but that
- * occasionally that wasn't enough. Making it much bigger than 1<<26 probably
- * isn't worthwhile -- tables that big are kind of ridiculous. Also, the
- * growth operation will (deliberately) fail if |capacity * entrySize|
+ * Table capacity limit; do not exceed. The max capacity used to be 1<<23 but
+ * that occasionally that wasn't enough. Making it much bigger than 1<<26
+ * probably isn't worthwhile -- tables that big are kind of ridiculous. Also,
+ * the growth operation will (deliberately) fail if |capacity * entrySize|
* overflows a uint32_t, and entrySize is always at least 8 bytes.
*/
-#undef PL_DHASH_MAX_SIZE
-#define PL_DHASH_MAX_SIZE ((uint32_t)1 << 26)
+#define PL_DHASH_MAX_CAPACITY ((uint32_t)1 << 26)
+
+#define PL_DHASH_MIN_CAPACITY 16
-/* Minimum table size, or gross entry count (net is at most .75 loaded). */
-#ifndef PL_DHASH_MIN_SIZE
-#define PL_DHASH_MIN_SIZE 16
-#elif (PL_DHASH_MIN_SIZE & (PL_DHASH_MIN_SIZE - 1)) != 0
-#error "PL_DHASH_MIN_SIZE must be a power of two!"
-#endif
+/*
+ * Making this half of the max capacity ensures it'll fit. Nobody should need
+ * an initial length anywhere nearly this large, anyway.
+ */
+#define PL_DHASH_MAX_INITIAL_LENGTH (PL_DHASH_MAX_CAPACITY / 2)
+
+/* This gives a default initial capacity of 16. */
+#define PL_DHASH_DEFAULT_INITIAL_LENGTH 8
/*
* Multiplicative hash uses an unsigned 32 bit integer and the golden ratio,
* expressed as a fixed-point 32-bit fraction.
*/
#define PL_DHASH_BITS 32
#define PL_DHASH_GOLDEN_RATIO 0x9E3779B9U
@@ -157,19 +160,19 @@ PL_DHASH_ENTRY_IS_LIVE(PLDHashEntryHdr*
* alpha < (esize - 1) / (esize + k)
*
* Therefore double hashing should keep alpha >= (esize - 1) / (esize + k),
* assuming esize is not too large (in which case, chaining should probably be
* used for any alpha). For esize=2 and k=3, we want alpha >= .2; for esize=3
* and k=2, we want alpha >= .4. For k=4, esize could be 6, and alpha >= .5
* would still obtain.
*
- * The current implementation uses a configurable lower bound on alpha, which
- * defaults to .25, when deciding to shrink the table (while still respecting
- * PL_DHASH_MIN_SIZE).
+ * The current implementation uses a lower bound of 0.25 for alpha when
+ * deciding whether to shrink the table (while still respecting
+ * PL_DHASH_MIN_CAPACITY).
*
* Note a qualitative difference between chaining and double hashing: under
* chaining, entry addresses are stable across table shrinks and grows. With
* double hashing, you can't safely hold an entry pointer and use it after an
* ADD or REMOVE operation, unless you sample aTable->generation before adding
* or removing, and compare the sample after, dereferencing the entry pointer
* only if aTable->generation has not changed.
*
@@ -218,17 +221,17 @@ struct PLDHashTable
#endif
};
/*
* Size in entries (gross, not net of free and removed sentinels) for table.
* We store hashShift rather than sizeLog2 to optimize the collision-free case
* in SearchTable.
*/
-#define PL_DHASH_TABLE_SIZE(table) \
+#define PL_DHASH_TABLE_CAPACITY(table) \
((uint32_t)1 << (PL_DHASH_BITS - (table)->hashShift))
/*
* Table space at entryStore is allocated and freed using these callbacks.
* The allocator should return null on error only (not if called with aNBytes
* equal to 0; but note that pldhash.c code will never call with 0 aNBytes).
*/
typedef void* (*PLDHashAllocTable)(PLDHashTable* aTable, uint32_t aNBytes);
@@ -376,45 +379,47 @@ NS_COM_GLUE void PL_DHashFinalizeStub(PL
NS_COM_GLUE const PLDHashTableOps* PL_DHashGetStubOps(void);
/*
* Dynamically allocate a new PLDHashTable using malloc, initialize it using
* PL_DHashTableInit, and return its address. Return null on malloc failure.
* Note that the entry storage at aTable->entryStore will be allocated using
* the aOps->allocTable callback.
*/
-NS_COM_GLUE PLDHashTable* PL_NewDHashTable(const PLDHashTableOps* aOps,
- void* aData, uint32_t aEntrySize,
- uint32_t aCapacity);
+NS_COM_GLUE PLDHashTable* PL_NewDHashTable(
+ const PLDHashTableOps* aOps, void* aData, uint32_t aEntrySize,
+ uint32_t aLength = PL_DHASH_DEFAULT_INITIAL_LENGTH);
/*
* Finalize aTable's data, free its entry storage (via aTable->ops->freeTable),
* and return the memory starting at aTable to the malloc heap.
*/
NS_COM_GLUE void PL_DHashTableDestroy(PLDHashTable* aTable);
/*
- * Initialize aTable with aOps, aData, aEntrySize, and aCapacity. Capacity is
- * a guess for the smallest table size at which the table will usually be less
- * than 75% loaded (the table will grow or shrink as needed; capacity serves
- * only to avoid inevitable early growth from PL_DHASH_MIN_SIZE). This will
- * crash if it can't allocate enough memory, or if entrySize or capacity are
- * too large.
+ * Initialize aTable with aOps, aData, aEntrySize, and aCapacity. The table's
+ * initial capacity will be chosen such that |aLength| elements can be inserted
+ * without rehashing. If |aLength| is a power-of-two, this capacity will be
+ * |2*length|.
+ *
+ * This function will crash if it can't allocate enough memory, or if
+ * |aEntrySize| and/or |aLength| are too large.
*/
-NS_COM_GLUE void PL_DHashTableInit(PLDHashTable* aTable,
- const PLDHashTableOps* aOps, void* aData,
- uint32_t aEntrySize, uint32_t aCapacity);
+NS_COM_GLUE void PL_DHashTableInit(
+ PLDHashTable* aTable, const PLDHashTableOps* aOps, void* aData,
+ uint32_t aEntrySize, uint32_t aLength = PL_DHASH_DEFAULT_INITIAL_LENGTH);
/*
* Initialize aTable. This is the same as PL_DHashTableInit, except that it
* returns a boolean indicating success, rather than crashing on failure.
*/
MOZ_WARN_UNUSED_RESULT NS_COM_GLUE bool PL_DHashTableInit(
PLDHashTable* aTable, const PLDHashTableOps* aOps, void* aData,
- uint32_t aEntrySize, uint32_t aCapacity, const mozilla::fallible_t&);
+ uint32_t aEntrySize, const mozilla::fallible_t&,
+ uint32_t aLength = PL_DHASH_DEFAULT_INITIAL_LENGTH);
/*
* Finalize aTable's data, free its entry storage using aTable->ops->freeTable,
* and leave its members unchanged from their last live values (which leaves
* pointers dangling). If you want to burn cycles clearing aTable, it's up to
* your code to call memset.
*/
NS_COM_GLUE void PL_DHashTableFinish(PLDHashTable* aTable);
--- a/xpcom/io/nsDirectoryService.cpp
+++ b/xpcom/io/nsDirectoryService.cpp
@@ -195,17 +195,17 @@ nsDirectoryService::GetCurrentProcessDir
NS_ERROR("unable to get current process directory");
return NS_ERROR_FAILURE;
} // GetCurrentProcessDirectory()
nsDirectoryService* nsDirectoryService::gService = nullptr;
nsDirectoryService::nsDirectoryService()
- : mHashtable(256)
+ : mHashtable(128)
{
}
nsresult
nsDirectoryService::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult)
{
if (NS_WARN_IF(!aResult)) {
return NS_ERROR_INVALID_ARG;
--- a/xpcom/reflect/xptinfo/xptiWorkingSet.cpp
+++ b/xpcom/reflect/xptinfo/xptiWorkingSet.cpp
@@ -8,22 +8,22 @@
#include "mozilla/XPTInterfaceInfoManager.h"
#include "xptiprivate.h"
#include "nsString.h"
using namespace mozilla;
#define XPTI_STRUCT_ARENA_BLOCK_SIZE (1024 * 16)
-#define XPTI_HASHTABLE_SIZE 2048
+#define XPTI_HASHTABLE_LENGTH 1024
XPTInterfaceInfoManager::xptiWorkingSet::xptiWorkingSet()
: mTableReentrantMonitor("xptiWorkingSet::mTableReentrantMonitor")
- , mIIDTable(XPTI_HASHTABLE_SIZE)
- , mNameTable(XPTI_HASHTABLE_SIZE)
+ , mIIDTable(XPTI_HASHTABLE_LENGTH)
+ , mNameTable(XPTI_HASHTABLE_LENGTH)
{
MOZ_COUNT_CTOR(xptiWorkingSet);
gXPTIStructArena = XPT_NewArena(XPTI_STRUCT_ARENA_BLOCK_SIZE, sizeof(double),
"xptiWorkingSet structs");
}
static PLDHashOperator
--- a/xpcom/tests/TestHashtables.cpp
+++ b/xpcom/tests/TestHashtables.cpp
@@ -542,18 +542,17 @@ main(void) {
nsCOMArray<IFoo> fooArray;
for (i = 0; i < ENTITY_COUNT; ++i) {
printf(" Putting entry %u...", gEntities[i].mUnicode);
nsCOMPtr<IFoo> foo;
CreateIFoo(getter_AddRefs(foo));
foo->SetString(nsDependentCString(gEntities[i].mStr));
-
-
+
fooArray.InsertObjectAt(foo, i);
EntToUniClass2.Put(foo, gEntities[i].mUnicode);
printf("OK...\n");
}
printf("Testing Get:\n");
uint32_t myChar2;
@@ -608,17 +607,17 @@ main(void) {
printf("Filling hash with %u entries.\n", ENTITY_COUNT);
for (i = 0; i < ENTITY_COUNT; ++i) {
printf(" Putting entry %u...", gEntities[i].mUnicode);
nsCOMPtr<IFoo> foo;
CreateIFoo(getter_AddRefs(foo));
foo->SetString(nsDependentCString(gEntities[i].mStr));
-
+
UniToEntClass2.Put(gEntities[i].mUnicode, foo);
printf("OK...\n");
}
printf("Testing Get:\n");
for (i = 0; i < ENTITY_COUNT; ++i) {
printf(" Getting entry %s...", gEntities[i].mStr);
--- a/xpcom/tests/TestPLDHash.cpp
+++ b/xpcom/tests/TestPLDHash.cpp
@@ -11,36 +11,38 @@
// exposed through normal usage. Therefore, this test currently focusses on
// extreme cases relating to maximum table capacity and potential overflows,
// which are unlikely to be hit during normal execution.
namespace TestPLDHash {
static bool test_pldhash_Init_capacity_ok()
{
- // Try the largest allowed capacity. With PL_DHASH_MAX_SIZE==1<<26, this
+ // Try the largest allowed capacity. With PL_DHASH_MAX_CAPACITY==1<<26, this
// will allocate 0.5GB of entry store on 32-bit platforms and 1GB on 64-bit
// platforms.
PLDHashTable t;
bool ok = PL_DHashTableInit(&t, PL_DHashGetStubOps(), nullptr,
- sizeof(PLDHashEntryStub), PL_DHASH_MAX_SIZE,
- mozilla::fallible_t());
+ sizeof(PLDHashEntryStub),
+ mozilla::fallible_t(),
+ PL_DHASH_MAX_INITIAL_LENGTH);
if (ok)
PL_DHashTableFinish(&t);
return ok;
}
static bool test_pldhash_Init_capacity_too_large()
{
// Try the smallest too-large capacity.
PLDHashTable t;
bool ok = PL_DHashTableInit(&t, PL_DHashGetStubOps(), nullptr,
- sizeof(PLDHashEntryStub), PL_DHASH_MAX_SIZE + 1,
- mozilla::fallible_t());
+ sizeof(PLDHashEntryStub),
+ mozilla::fallible_t(),
+ PL_DHASH_MAX_INITIAL_LENGTH + 1);
// Don't call PL_DHashTableDestroy(), it's not safe after Init failure.
return !ok; // expected to fail
}
static bool test_pldhash_Init_overflow()
{
// Try an acceptable capacity, but one whose byte size overflows uint32_t.
@@ -53,18 +55,18 @@ static bool test_pldhash_Init_overflow()
struct OneKBEntry {
PLDHashEntryHdr hdr;
char buf[1024 - sizeof(PLDHashEntryHdr)];
};
// |nullptr| for |ops| is ok because it's unused due to the failure.
PLDHashTable t;
bool ok = PL_DHashTableInit(&t, /* ops = */nullptr, nullptr,
- sizeof(OneKBEntry), PL_DHASH_MAX_SIZE,
- mozilla::fallible_t());
+ sizeof(OneKBEntry), mozilla::fallible_t(),
+ PL_DHASH_MAX_INITIAL_LENGTH);
return !ok; // expected to fail
}
// See bug 931062, we skip this test on Android due to OOM.
#ifndef MOZ_WIDGET_ANDROID
// We insert the integers 0.., so this is has function is (a) as simple as
// possible, and (b) collision-free. Both of which are good, because we want
@@ -84,33 +86,33 @@ static bool test_pldhash_grow_to_max_cap
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub,
nullptr
};
PLDHashTable t;
- bool ok = PL_DHashTableInit(&t, &ops, nullptr, sizeof(PLDHashEntryStub), 256,
- mozilla::fallible_t());
+ bool ok = PL_DHashTableInit(&t, &ops, nullptr, sizeof(PLDHashEntryStub),
+ mozilla::fallible_t(), 128);
if (!ok)
return false;
// Keep inserting elements until failure occurs because the table is full.
size_t numInserted = 0;
while (true) {
if (!PL_DHashTableOperate(&t, (const void*)numInserted, PL_DHASH_ADD)) {
break;
}
numInserted++;
}
// We stop when the element count is 96.875% of PL_DHASH_MAX_SIZE (see
// MaxLoadOnGrowthFailure()).
- return numInserted == PL_DHASH_MAX_SIZE - (PL_DHASH_MAX_SIZE >> 5);
+ return numInserted == PL_DHASH_MAX_CAPACITY - (PL_DHASH_MAX_CAPACITY >> 5);
}
#endif
//----
typedef bool (*TestFunc)();
#define DECL_TEST(name) { #name, name }
