The Tor Browser: xpcom/ds/nsStaticNameTable.cpp@129ffea94266 (annotated)

xpcom/ds/nsStaticNameTable.cpp@129ffea94266 (annotated)

xpcom/ds/nsStaticNameTable.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * 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/. */
 /* Class to manage lookup of static names in a table. */
 #include "nsCRT.h"
 #include "nscore.h"
 #include "mozilla/HashFunctions.h"
 #include "nsISupportsImpl.h"
 #define PL_ARENA_CONST_ALIGN_MASK 3
 #include "nsStaticNameTable.h"
 using namespace mozilla;
 struct NameTableKey
 {
     NameTableKey(const nsAFlatCString* aKeyStr)
         : mIsUnichar(false)
     {
         mKeyStr.m1b = aKeyStr;
     }
     NameTableKey(const nsAFlatString* aKeyStr)
         : mIsUnichar(true)
     {
         mKeyStr.m2b = aKeyStr;
     }
     bool mIsUnichar;
     union {
         const nsAFlatCString* m1b;
         const nsAFlatString* m2b;
     } mKeyStr;
 };
 struct NameTableEntry : public PLDHashEntryHdr
 {
     // no ownership here!
     const nsAFlatCString* mString;
     int32_t mIndex;
 };
 static bool
 matchNameKeysCaseInsensitive(PLDHashTable*, const PLDHashEntryHdr* aHdr,
                              const void* key)
 {
     const NameTableEntry* entry =
         static_cast<const NameTableEntry *>(aHdr);
     const NameTableKey *keyValue = static_cast<const NameTableKey*>(key);
     const nsAFlatCString* entryKey = entry->mString;
     if (keyValue->mIsUnichar) {
         return keyValue->mKeyStr.m2b->
             LowerCaseEqualsASCII(entryKey->get(), entryKey->Length());
     }
     return keyValue->mKeyStr.m1b->
         LowerCaseEqualsASCII(entryKey->get(), entryKey->Length());
 }
 /*
  * caseInsensitiveHashKey is just like PL_DHashStringKey except it
  * uses (*s & ~0x20) instead of simply *s.  This means that "aFOO" and
  * "afoo" and "aFoo" will all hash to the same thing.  It also means
  * that some strings that aren't case-insensensitively equal will hash
  * to the same value, but it's just a hash function so it doesn't
  * matter.
  */
 static PLDHashNumber
 caseInsensitiveStringHashKey(PLDHashTable *table, const void *key)
 {
     PLDHashNumber h = 0;
     const NameTableKey* tableKey = static_cast<const NameTableKey*>(key);
     if (tableKey->mIsUnichar) {
         for (const char16_t* s = tableKey->mKeyStr.m2b->get();
              *s != '\0';
              s++)
             h = AddToHash(h, *s & ~0x20);
     } else {
         for (const unsigned char* s =
                  reinterpret_cast<const unsigned char*>
                                  (tableKey->mKeyStr.m1b->get());
              *s != '\0';
              s++)
             h = AddToHash(h, *s & ~0x20);
     }
     return h;
 }
 static const struct PLDHashTableOps nametable_CaseInsensitiveHashTableOps = {
     PL_DHashAllocTable,
     PL_DHashFreeTable,
     caseInsensitiveStringHashKey,
     matchNameKeysCaseInsensitive,
     PL_DHashMoveEntryStub,
     PL_DHashClearEntryStub,
     PL_DHashFinalizeStub,
     nullptr,
 };
 nsStaticCaseInsensitiveNameTable::nsStaticCaseInsensitiveNameTable()
   : mNameArray(nullptr), mNullStr("")
 {
     MOZ_COUNT_CTOR(nsStaticCaseInsensitiveNameTable);
     mNameTable.ops = nullptr;
 }
 nsStaticCaseInsensitiveNameTable::~nsStaticCaseInsensitiveNameTable()
 {
     if (mNameArray) {
         // manually call the destructor on placement-new'ed objects
         for (uint32_t index = 0; index < mNameTable.entryCount; index++) {
             mNameArray[index].~nsDependentCString();
         }
         nsMemory::Free((void*)mNameArray);
     }
     if (mNameTable.ops)
         PL_DHashTableFinish(&mNameTable);
     MOZ_COUNT_DTOR(nsStaticCaseInsensitiveNameTable);
 }
 bool
 nsStaticCaseInsensitiveNameTable::Init(const char* const aNames[], int32_t Count)
 {
     NS_ASSERTION(!mNameArray, "double Init");
     NS_ASSERTION(!mNameTable.ops, "double Init");
     NS_ASSERTION(aNames, "null name table");
     NS_ASSERTION(Count, "0 count");
     mNameArray = (nsDependentCString*)
                    nsMemory::Alloc(Count * sizeof(nsDependentCString));
     if (!mNameArray)
         return false;
     if (!PL_DHashTableInit(&mNameTable, &nametable_CaseInsensitiveHashTableOps,
                            nullptr, sizeof(NameTableEntry), Count,
                            fallible_t())) {
         mNameTable.ops = nullptr;
         return false;
     }
     for (int32_t index = 0; index < Count; ++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");
             NS_ASSERTION(nsCRT::IsAscii(raw),
                          "non-ascii string in table -- "
                          "case-insensitive matching won't work right");
         }
 #endif
         // use placement-new to initialize the string object
         nsDependentCString* strPtr = &mNameArray[index];
         new (strPtr) nsDependentCString(raw);
         NameTableKey key(strPtr);
         NameTableEntry *entry =
           static_cast<NameTableEntry*>
                      (PL_DHashTableOperate(&mNameTable, &key,
                                               PL_DHASH_ADD));
         if (!entry) continue;
         NS_ASSERTION(entry->mString == 0, "Entry already exists!");
         entry->mString = strPtr;      // not owned!
         entry->mIndex = index;
     }
 #ifdef DEBUG
     PL_DHashMarkTableImmutable(&mNameTable);
 #endif
     return true;
 }
 int32_t
 nsStaticCaseInsensitiveNameTable::Lookup(const nsACString& aName)
 {
     NS_ASSERTION(mNameArray, "not inited");
     NS_ASSERTION(mNameTable.ops, "not inited");
     const nsAFlatCString& str = PromiseFlatCString(aName);
     NameTableKey key(&str);
     NameTableEntry *entry =
         static_cast<NameTableEntry*>
                    (PL_DHashTableOperate(&mNameTable, &key,
                                             PL_DHASH_LOOKUP));
     if (PL_DHASH_ENTRY_IS_FREE(entry))
         return nsStaticCaseInsensitiveNameTable::NOT_FOUND;
     return entry->mIndex;
 }
 int32_t
 nsStaticCaseInsensitiveNameTable::Lookup(const nsAString& aName)
 {
     NS_ASSERTION(mNameArray, "not inited");
     NS_ASSERTION(mNameTable.ops, "not inited");
     const nsAFlatString& str = PromiseFlatString(aName);
     NameTableKey key(&str);
     NameTableEntry *entry =
         static_cast<NameTableEntry*>
                    (PL_DHashTableOperate(&mNameTable, &key,
                                             PL_DHASH_LOOKUP));
     if (PL_DHASH_ENTRY_IS_FREE(entry))
         return nsStaticCaseInsensitiveNameTable::NOT_FOUND;
     return entry->mIndex;
 }
 const nsAFlatCString&
 nsStaticCaseInsensitiveNameTable::GetStringValue(int32_t index)
 {
     NS_ASSERTION(mNameArray, "not inited");
     NS_ASSERTION(mNameTable.ops, "not inited");
     if ((NOT_FOUND < index) && ((uint32_t)index < mNameTable.entryCount)) {
         return mNameArray[index];
     }
     return mNullStr;
 }

The Tor Browser / annotate

xpcom/ds/nsStaticNameTable.cpp@129ffea94266 (annotated)

xpcom/ds/nsStaticNameTable.cpp