The Tor Browser: embedding/components/commandhandler/src/nsCommandGroup.cpp@deefc01c0e14 (annotated)

embedding/components/commandhandler/src/nsCommandGroup.cpp@deefc01c0e14 (annotated)

embedding/components/commandhandler/src/nsCommandGroup.cpp

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- 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 "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsTArray.h"
 #include "nsISimpleEnumerator.h"
 #include "nsXPCOM.h"
 #include "nsSupportsPrimitives.h"
 #include "nsIComponentManager.h"
 #include "nsCommandGroup.h"
 #include "nsIControllerCommand.h"
 #include "nsCRT.h"
 class nsGroupsEnumerator : public nsISimpleEnumerator
 {
 public:
               nsGroupsEnumerator(nsHashtable& inHashTable);
   virtual     ~nsGroupsEnumerator();
   NS_DECL_ISUPPORTS
   NS_DECL_NSISIMPLEENUMERATOR
 protected:
   static bool HashEnum(nsHashKey *aKey, void *aData, void* aClosure);
   nsresult      Initialize();
 protected:
   nsHashtable&  mHashTable;
   int32_t       mIndex;
   char **       mGroupNames;        // array of pointers to char16_t* in the hash table
   bool          mInitted;
 };
 /* Implementation file */
 NS_IMPL_ISUPPORTS(nsGroupsEnumerator, nsISimpleEnumerator)
 nsGroupsEnumerator::nsGroupsEnumerator(nsHashtable& inHashTable)
 : mHashTable(inHashTable)
 , mIndex(-1)
 , mGroupNames(nullptr)
 , mInitted(false)
 {
   /* member initializers and constructor code */
 }
 nsGroupsEnumerator::~nsGroupsEnumerator()
 {
   delete [] mGroupNames;    // ok on null pointer
 }
 /* boolean hasMoreElements (); */
 NS_IMETHODIMP
 nsGroupsEnumerator::HasMoreElements(bool *_retval)
 {
   nsresult  rv = NS_OK;
   NS_ENSURE_ARG_POINTER(_retval);
   if (!mInitted) {
     rv = Initialize();
     if (NS_FAILED(rv)) return rv;
   }
   *_retval = (mIndex < mHashTable.Count() - 1);
   return NS_OK;
 }
 /* nsISupports getNext (); */
 NS_IMETHODIMP
 nsGroupsEnumerator::GetNext(nsISupports **_retval)
 {
   nsresult  rv = NS_OK;
   NS_ENSURE_ARG_POINTER(_retval);
   if (!mInitted) {
     rv = Initialize();
     if (NS_FAILED(rv)) return rv;
   }
   mIndex ++;
   if (mIndex >= mHashTable.Count())
     return NS_ERROR_FAILURE;
   char *thisGroupName = mGroupNames[mIndex];
   nsCOMPtr<nsISupportsCString> supportsString = do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
   if (NS_FAILED(rv)) return rv;
   supportsString->SetData(nsDependentCString(thisGroupName));
   return CallQueryInterface(supportsString, _retval);
 }
 /* static */
 /* return false to stop */
 bool
 nsGroupsEnumerator::HashEnum(nsHashKey *aKey, void *aData, void* aClosure)
 {
   nsGroupsEnumerator*   groupsEnum = reinterpret_cast<nsGroupsEnumerator *>(aClosure);
   nsCStringKey*         stringKey = static_cast<nsCStringKey*>(aKey);
   groupsEnum->mGroupNames[groupsEnum->mIndex] = (char*)stringKey->GetString();
   groupsEnum->mIndex ++;
   return true;
 }
 nsresult
 nsGroupsEnumerator::Initialize()
 {
   if (mInitted) return NS_OK;
   mGroupNames = new char*[mHashTable.Count()];
   if (!mGroupNames) return NS_ERROR_OUT_OF_MEMORY;
   mIndex = 0;
   mHashTable.Enumerate(HashEnum, (void*)this);
   mIndex = -1;
   mInitted = true;
   return NS_OK;
 }
 #if 0
 #pragma mark -
 #endif
 class nsNamedGroupEnumerator : public nsISimpleEnumerator
 {
 public:
               nsNamedGroupEnumerator(nsTArray<char*>* inArray);
   virtual     ~nsNamedGroupEnumerator();
   NS_DECL_ISUPPORTS
   NS_DECL_NSISIMPLEENUMERATOR
 protected:
   nsTArray<char*>* mGroupArray;
   int32_t          mIndex;
 };
 nsNamedGroupEnumerator::nsNamedGroupEnumerator(nsTArray<char*>* inArray)
 : mGroupArray(inArray)
 , mIndex(-1)
 {
 }
 nsNamedGroupEnumerator::~nsNamedGroupEnumerator()
 {
 }
 NS_IMPL_ISUPPORTS(nsNamedGroupEnumerator, nsISimpleEnumerator)
 /* boolean hasMoreElements (); */
 NS_IMETHODIMP
 nsNamedGroupEnumerator::HasMoreElements(bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   int32_t arrayLen = mGroupArray ? mGroupArray->Length() : 0;
   *_retval = (mIndex < arrayLen - 1);
   return NS_OK;
 }
 /* nsISupports getNext (); */
 NS_IMETHODIMP
 nsNamedGroupEnumerator::GetNext(nsISupports **_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   if (!mGroupArray)
     return NS_ERROR_FAILURE;
   mIndex ++;
   if (mIndex >= int32_t(mGroupArray->Length()))
     return NS_ERROR_FAILURE;
   char16_t   *thisGroupName = (char16_t*)mGroupArray->ElementAt(mIndex);
   NS_ASSERTION(thisGroupName, "Bad Element in mGroupArray");
   nsresult rv;
   nsCOMPtr<nsISupportsString> supportsString = do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
   if (NS_FAILED(rv)) return rv;
   supportsString->SetData(nsDependentString(thisGroupName));
   return CallQueryInterface(supportsString, _retval);
 }
 #if 0
 #pragma mark -
 #endif
 /* Implementation file */
 NS_IMPL_ISUPPORTS(nsControllerCommandGroup, nsIControllerCommandGroup)
 nsControllerCommandGroup::nsControllerCommandGroup()
 {
 }
 nsControllerCommandGroup::~nsControllerCommandGroup()
 {
   ClearGroupsHash();
 }
 void
 nsControllerCommandGroup::ClearGroupsHash()
 {
     mGroupsHash.Reset(ClearEnumerator, (void *)this);
 }
 #if 0
 #pragma mark -
 #endif
 /* void addCommandToGroup (in DOMString aCommand, in DOMString aGroup); */
 NS_IMETHODIMP
 nsControllerCommandGroup::AddCommandToGroup(const char * aCommand, const char *aGroup)
 {
   nsCStringKey   groupKey(aGroup);
   nsTArray<char*>* commandList;
   if ((commandList = (nsTArray<char*> *)mGroupsHash.Get(&groupKey)) == nullptr)
   {
     // make this list
     commandList = new nsAutoTArray<char*, 8>;
     mGroupsHash.Put(&groupKey, (void *)commandList);
   }
   // add the command to the list. Note that we're not checking for duplicates here
   char* commandString = NS_strdup(aCommand); // we store allocated char16_t* in the array
   if (!commandString) return NS_ERROR_OUT_OF_MEMORY;
 #ifdef DEBUG
   char** appended =
 #endif
     commandList->AppendElement(commandString);
   NS_ASSERTION(appended, "Append failed");
   return NS_OK;
 }
 /* void removeCommandFromGroup (in DOMString aCommand, in DOMString aGroup); */
 NS_IMETHODIMP
 nsControllerCommandGroup::RemoveCommandFromGroup(const char * aCommand, const char * aGroup)
 {
   nsCStringKey   groupKey(aGroup);
   nsTArray<char*>* commandList = (nsTArray<char*> *)mGroupsHash.Get(&groupKey);
   if (!commandList) return NS_OK;     // no group
   uint32_t numEntries = commandList->Length();
   for (uint32_t i = 0; i < numEntries; i ++)
   {
     char*  commandString = commandList->ElementAt(i);
     if (!nsCRT::strcmp(aCommand,commandString))
     {
       commandList->RemoveElementAt(i);
       nsMemory::Free(commandString);
       break;
     }
   }
   return NS_OK;
 }
 /* boolean isCommandInGroup (in DOMString aCommand, in DOMString aGroup); */
 NS_IMETHODIMP
 nsControllerCommandGroup::IsCommandInGroup(const char * aCommand, const char * aGroup, bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = false;
   nsCStringKey   groupKey(aGroup);
   nsTArray<char*>* commandList = (nsTArray<char*> *)mGroupsHash.Get(&groupKey);
   if (!commandList) return NS_OK;     // no group
   uint32_t numEntries = commandList->Length();
   for (uint32_t i = 0; i < numEntries; i ++)
   {
     char*  commandString = commandList->ElementAt(i);
     if (!nsCRT::strcmp(aCommand,commandString))
     {
       *_retval = true;
       break;
     }
   }
   return NS_OK;
 }
 /* nsISimpleEnumerator getGroupsEnumerator (); */
 NS_IMETHODIMP
 nsControllerCommandGroup::GetGroupsEnumerator(nsISimpleEnumerator **_retval)
 {
   nsGroupsEnumerator*   groupsEnum = new nsGroupsEnumerator(mGroupsHash);
   if (!groupsEnum) return NS_ERROR_OUT_OF_MEMORY;
   return groupsEnum->QueryInterface(NS_GET_IID(nsISimpleEnumerator), (void **)_retval);
 }
 /* nsISimpleEnumerator getEnumeratorForGroup (in DOMString aGroup); */
 NS_IMETHODIMP
 nsControllerCommandGroup::GetEnumeratorForGroup(const char * aGroup, nsISimpleEnumerator **_retval)
 {
   nsCStringKey   groupKey(aGroup);
   nsTArray<char*>* commandList = (nsTArray<char*> *)mGroupsHash.Get(&groupKey); // may be null
   nsNamedGroupEnumerator*   theGroupEnum = new nsNamedGroupEnumerator(commandList);
   if (!theGroupEnum) return NS_ERROR_OUT_OF_MEMORY;
   return theGroupEnum->QueryInterface(NS_GET_IID(nsISimpleEnumerator), (void **)_retval);
 }
 #if 0
 #pragma mark -
 #endif
 bool nsControllerCommandGroup::ClearEnumerator(nsHashKey *aKey, void *aData, void* closure)
 {
   nsTArray<char*>* commandList = (nsTArray<char*> *)aData;
   if (commandList)
   {
     uint32_t numEntries = commandList->Length();
     for (uint32_t i = 0; i < numEntries; i ++)
     {
       char* commandString = commandList->ElementAt(i);
       nsMemory::Free(commandString);
     }
     delete commandList;
   }
   return true;
 }

The Tor Browser / annotate

embedding/components/commandhandler/src/nsCommandGroup.cpp@deefc01c0e14 (annotated)

embedding/components/commandhandler/src/nsCommandGroup.cpp