The Tor Browser: embedding/components/commandhandler/src/nsCommandParams.cpp@6474c204b198 (annotated)

embedding/components/commandhandler/src/nsCommandParams.cpp@6474c204b198 (annotated)

embedding/components/commandhandler/src/nsCommandParams.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

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

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "xpcom-config.h"
 #include <new>    // for placement new
 #include "nscore.h"
 #include "nsCRT.h"
 #include "nsCommandParams.h"
 #include "mozilla/HashFunctions.h"
 using namespace mozilla;
 const PLDHashTableOps nsCommandParams::sHashOps =
 {
     PL_DHashAllocTable,
     PL_DHashFreeTable,
     HashKey,
     HashMatchEntry,
     HashMoveEntry,
     HashClearEntry,
     PL_DHashFinalizeStub
 };
 NS_IMPL_ISUPPORTS(nsCommandParams, nsICommandParams)
 nsCommandParams::nsCommandParams()
 : mCurEntry(0)
 , mNumEntries(eNumEntriesUnknown)
 {
   // init the hash table later
 }
 nsCommandParams::~nsCommandParams()
 {
   PL_DHashTableFinish(&mValuesHash);
 }
 nsresult
 nsCommandParams::Init()
 {
   PL_DHashTableInit(&mValuesHash, &sHashOps, (void *)this, sizeof(HashEntry), 4);
   return NS_OK;
 }
 #if 0
 #pragma mark -
 #endif
 /* short getValueType (in string name); */
 NS_IMETHODIMP nsCommandParams::GetValueType(const char * name, int16_t *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = eNoType;
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry)
   {
     *_retval = foundEntry->mEntryType;
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 /* boolean getBooleanValue (in AString name); */
 NS_IMETHODIMP nsCommandParams::GetBooleanValue(const char * name, bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = false;
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry && foundEntry->mEntryType == eBooleanType)
   {
     *_retval = foundEntry->mData.mBoolean;
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 /* long getLongValue (in AString name); */
 NS_IMETHODIMP nsCommandParams::GetLongValue(const char * name, int32_t *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = false;
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry && foundEntry->mEntryType == eLongType)
   {
     *_retval = foundEntry->mData.mLong;
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 /* double getDoubleValue (in AString name); */
 NS_IMETHODIMP nsCommandParams::GetDoubleValue(const char * name, double *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = 0.0;
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry && foundEntry->mEntryType == eDoubleType)
   {
     *_retval = foundEntry->mData.mDouble;
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 /* AString getStringValue (in AString name); */
 NS_IMETHODIMP nsCommandParams::GetStringValue(const char *name, nsAString & _retval)
 {
   _retval.Truncate();
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry && foundEntry->mEntryType == eWStringType)
   {
     NS_ASSERTION(foundEntry->mData.mString, "Null string");
     _retval.Assign(*foundEntry->mData.mString);
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 /* AString getStringValue (in AString name); */
 NS_IMETHODIMP nsCommandParams::GetCStringValue(const char * name, char **_retval)
 {
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry && foundEntry->mEntryType == eStringType)
   {
     NS_ASSERTION(foundEntry->mData.mCString, "Null string");
     *_retval = ToNewCString(*foundEntry->mData.mCString);
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 /* nsISupports getISupportsValue (in AString name); */
 NS_IMETHODIMP nsCommandParams::GetISupportsValue(const char * name, nsISupports **_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = nullptr;
   HashEntry*  foundEntry = GetNamedEntry(name);
   if (foundEntry && foundEntry->mEntryType == eISupportsType)
   {
     NS_IF_ADDREF(*_retval = foundEntry->mISupports.get());
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 #if 0
 #pragma mark -
 #endif
 /* void setBooleanValue (in AString name, in boolean value); */
 NS_IMETHODIMP nsCommandParams::SetBooleanValue(const char * name, bool value)
 {
   HashEntry*  foundEntry;
   GetOrMakeEntry(name, eBooleanType, foundEntry);
   if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
   foundEntry->mData.mBoolean = value;
   return NS_OK;
 }
 /* void setLongValue (in AString name, in long value); */
 NS_IMETHODIMP nsCommandParams::SetLongValue(const char * name, int32_t value)
 {
   HashEntry*  foundEntry;
   GetOrMakeEntry(name, eLongType, foundEntry);
   if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
   foundEntry->mData.mLong = value;
   return NS_OK;
 }
 /* void setDoubleValue (in AString name, in double value); */
 NS_IMETHODIMP nsCommandParams::SetDoubleValue(const char * name, double value)
 {
   HashEntry*  foundEntry;
   GetOrMakeEntry(name, eDoubleType, foundEntry);
   if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
   foundEntry->mData.mDouble = value;
   return NS_OK;
 }
 /* void setStringValue (in AString name, in AString value); */
 NS_IMETHODIMP nsCommandParams::SetStringValue(const char * name, const nsAString & value)
 {
   HashEntry*  foundEntry;
   GetOrMakeEntry(name, eWStringType, foundEntry);
   if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
   foundEntry->mData.mString = new nsString(value);
   return NS_OK;
 }
 /* void setCStringValue (in string name, in string value); */
 NS_IMETHODIMP nsCommandParams::SetCStringValue(const char * name, const char * value)
 {
   HashEntry*  foundEntry;
   GetOrMakeEntry(name, eStringType, foundEntry);
   if (!foundEntry)
     return NS_ERROR_OUT_OF_MEMORY;
   foundEntry->mData.mCString = new nsCString(value);
   return NS_OK;
 }
 /* void setISupportsValue (in AString name, in nsISupports value); */
 NS_IMETHODIMP nsCommandParams::SetISupportsValue(const char * name, nsISupports *value)
 {
   HashEntry*  foundEntry;
   GetOrMakeEntry(name, eISupportsType, foundEntry);
   if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
   foundEntry->mISupports = value;   // addrefs
   return NS_OK;
 }
 /* void removeValue (in AString name); */
 NS_IMETHODIMP
 nsCommandParams::RemoveValue(const char * name)
 {
   // PL_DHASH_REMOVE doesn't tell us if the entry was really removed, so we return
   // NS_OK unconditionally.
   (void)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_REMOVE);
   // inval the number of entries
   mNumEntries = eNumEntriesUnknown;
   return NS_OK;
 }
 #if 0
 #pragma mark -
 #endif
 nsCommandParams::HashEntry*
 nsCommandParams::GetNamedEntry(const char * name)
 {
   HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_LOOKUP);
   if (PL_DHASH_ENTRY_IS_BUSY(foundEntry))
     return foundEntry;
   return nullptr;
 }
 nsCommandParams::HashEntry*
 nsCommandParams::GetIndexedEntry(int32_t index)
 {
   HashEntry*  entry = reinterpret_cast<HashEntry*>(mValuesHash.entryStore);
   HashEntry*  limit = entry + PL_DHASH_TABLE_SIZE(&mValuesHash);
   uint32_t    entryCount = 0;
   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);
   uint32_t    entryCount = 0;
   do
   {
     if (PL_DHASH_ENTRY_IS_LIVE(entry))
       entryCount ++;
   } while (++entry < limit);
   return entryCount;
 }
 nsresult
 nsCommandParams::GetOrMakeEntry(const char * name, uint8_t entryType, HashEntry*& outEntry)
 {
   HashEntry *foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_LOOKUP);
   if (PL_DHASH_ENTRY_IS_BUSY(foundEntry))   // reuse existing entry
   {
     foundEntry->Reset(entryType);
     foundEntry->mEntryName.Assign(name);
     outEntry = foundEntry;
     return NS_OK;
   }
   foundEntry = (HashEntry *)PL_DHashTableOperate(&mValuesHash, (void *)name, PL_DHASH_ADD);
   if (!foundEntry) return NS_ERROR_OUT_OF_MEMORY;
   // placement new that sucker. Our ctor does not clobber keyHash, which is important.
   outEntry = new (foundEntry) HashEntry(entryType, name);
   return NS_OK;
 }
 #if 0
 #pragma mark -
 #endif
 PLDHashNumber
 nsCommandParams::HashKey(PLDHashTable *table, const void *key)
 {
   return HashString((const char *)key);
 }
 bool
 nsCommandParams::HashMatchEntry(PLDHashTable *table,
                                 const PLDHashEntryHdr *entry, const void *key)
 {
   const char*   keyString = (const char*)key;
   const HashEntry*   thisEntry = static_cast<const HashEntry*>(entry);
   return thisEntry->mEntryName.Equals(keyString);
 }
 void
 nsCommandParams::HashMoveEntry(PLDHashTable *table, const PLDHashEntryHdr *from,
                                 PLDHashEntryHdr *to)
 {
   const HashEntry*   fromEntry  = static_cast<const HashEntry*>(from);
   HashEntry*         toEntry    = static_cast<HashEntry*>(to);
   *toEntry = *fromEntry;
   // we leave from dirty, but that's OK
 }
 void
 nsCommandParams::HashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
 {
   HashEntry*    thisEntry = static_cast<HashEntry*>(entry);
   thisEntry->~HashEntry();      // call dtor explicitly
   memset(thisEntry, 0, sizeof(HashEntry));    // and clear out
 }
 #if 0
 #pragma mark -
 #endif
 /* boolean hasMoreElements (); */
 NS_IMETHODIMP
 nsCommandParams::HasMoreElements(bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   if (mNumEntries == eNumEntriesUnknown)
     mNumEntries = GetNumEntries();
   *_retval = mCurEntry < mNumEntries;
   return NS_OK;
 }
 /* void first (); */
 NS_IMETHODIMP
 nsCommandParams::First()
 {
   mCurEntry = 0;
   return NS_OK;
 }
 /* AString getNext (); */
 NS_IMETHODIMP
 nsCommandParams::GetNext(char **_retval)
 {
   HashEntry*    thisEntry = GetIndexedEntry(mCurEntry);
   if (!thisEntry)
     return NS_ERROR_FAILURE;
   *_retval = ToNewCString(thisEntry->mEntryName);
   mCurEntry++;
   return NS_OK;
 }

The Tor Browser / annotate

embedding/components/commandhandler/src/nsCommandParams.cpp@6474c204b198 (annotated)

embedding/components/commandhandler/src/nsCommandParams.cpp