The Tor Browser: content/base/src/nsAttrValue.cpp@deefc01c0e14 (annotated)

content/base/src/nsAttrValue.cpp@deefc01c0e14 (annotated)

content/base/src/nsAttrValue.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/. */
 /*
  * A struct that represents the value (type and actual data) of an
  * attribute.
  */
 #include "mozilla/DebugOnly.h"
 #include "mozilla/HashFunctions.h"
 #include "nsAttrValue.h"
 #include "nsAttrValueInlines.h"
 #include "nsIAtom.h"
 #include "nsUnicharUtils.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/css/StyleRule.h"
 #include "mozilla/css/Declaration.h"
 #include "nsContentUtils.h"
 #include "nsReadableUtils.h"
 #include "prprf.h"
 #include "nsHTMLCSSStyleSheet.h"
 #include "nsCSSParser.h"
 #include "nsStyledElement.h"
 #include "nsIURI.h"
 #include "nsIDocument.h"
 #include <algorithm>
 using namespace mozilla;
 #define MISC_STR_PTR(_cont) \
   reinterpret_cast<void*>((_cont)->mStringBits & NS_ATTRVALUE_POINTERVALUE_MASK)
 bool
 MiscContainer::GetString(nsAString& aString) const
 {
   void* ptr = MISC_STR_PTR(this);
   if (!ptr) {
     return false;
   }
   if (static_cast<nsAttrValue::ValueBaseType>(mStringBits &
                                               NS_ATTRVALUE_BASETYPE_MASK) ==
       nsAttrValue::eStringBase) {
     nsStringBuffer* buffer = static_cast<nsStringBuffer*>(ptr);
     if (!buffer) {
       return false;
     }
     buffer->ToString(buffer->StorageSize() / sizeof(char16_t) - 1, aString);
     return true;
   }
   nsIAtom* atom = static_cast<nsIAtom*>(ptr);
   if (!atom) {
     return false;
   }
   atom->ToString(aString);
   return true;
 }
 void
 MiscContainer::Cache()
 {
   // Not implemented for anything else yet.
   MOZ_ASSERT(mType == nsAttrValue::eCSSStyleRule);
   MOZ_ASSERT(IsRefCounted());
   MOZ_ASSERT(mValue.mRefCount > 0);
   MOZ_ASSERT(!mValue.mCached);
   css::StyleRule* rule = mValue.mCSSStyleRule;
   nsHTMLCSSStyleSheet* sheet = rule->GetHTMLCSSStyleSheet();
   if (!sheet) {
     return;
   }
   nsString str;
   bool gotString = GetString(str);
   if (!gotString) {
     return;
   }
   sheet->CacheStyleAttr(str, this);
   mValue.mCached = 1;
   // This has to be immutable once it goes into the cache.
   css::Declaration* decl = rule->GetDeclaration();
   if (decl) {
     decl->SetImmutable();
   }
 }
 void
 MiscContainer::Evict()
 {
   // Not implemented for anything else yet.
   MOZ_ASSERT(mType == nsAttrValue::eCSSStyleRule);
   MOZ_ASSERT(IsRefCounted());
   MOZ_ASSERT(mValue.mRefCount == 0);
   if (!mValue.mCached) {
     return;
   }
   css::StyleRule* rule = mValue.mCSSStyleRule;
   nsHTMLCSSStyleSheet* sheet = rule->GetHTMLCSSStyleSheet();
   MOZ_ASSERT(sheet);
   nsString str;
   DebugOnly<bool> gotString = GetString(str);
   MOZ_ASSERT(gotString);
   sheet->EvictStyleAttr(str, this);
   mValue.mCached = 0;
 }
 nsTArray<const nsAttrValue::EnumTable*>* nsAttrValue::sEnumTableArray = nullptr;
 nsAttrValue::nsAttrValue()
     : mBits(0)
 {
 }
 nsAttrValue::nsAttrValue(const nsAttrValue& aOther)
     : mBits(0)
 {
   SetTo(aOther);
 }
 nsAttrValue::nsAttrValue(const nsAString& aValue)
     : mBits(0)
 {
   SetTo(aValue);
 }
 nsAttrValue::nsAttrValue(nsIAtom* aValue)
     : mBits(0)
 {
   SetTo(aValue);
 }
 nsAttrValue::nsAttrValue(css::StyleRule* aValue, const nsAString* aSerialized)
     : mBits(0)
 {
   SetTo(aValue, aSerialized);
 }
 nsAttrValue::nsAttrValue(const nsIntMargin& aValue)
     : mBits(0)
 {
   SetTo(aValue);
 }
 nsAttrValue::~nsAttrValue()
 {
   ResetIfSet();
 }
 /* static */
 nsresult
 nsAttrValue::Init()
 {
   NS_ASSERTION(!sEnumTableArray, "nsAttrValue already initialized");
   sEnumTableArray = new nsTArray<const EnumTable*>;
   NS_ENSURE_TRUE(sEnumTableArray, NS_ERROR_OUT_OF_MEMORY);
   return NS_OK;
 }
 /* static */
 void
 nsAttrValue::Shutdown()
 {
   delete sEnumTableArray;
   sEnumTableArray = nullptr;
 }
 nsAttrValue::ValueType
 nsAttrValue::Type() const
 {
   switch (BaseType()) {
     case eIntegerBase:
     {
       return static_cast<ValueType>(mBits & NS_ATTRVALUE_INTEGERTYPE_MASK);
     }
     case eOtherBase:
     {
       return GetMiscContainer()->mType;
     }
     default:
     {
       return static_cast<ValueType>(static_cast<uint16_t>(BaseType()));
     }
   }
 }
 void
 nsAttrValue::Reset()
 {
   switch(BaseType()) {
     case eStringBase:
     {
       nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
       if (str) {
         str->Release();
       }
       break;
     }
     case eOtherBase:
     {
       MiscContainer* cont = GetMiscContainer();
       if (cont->IsRefCounted() && cont->mValue.mRefCount > 1) {
         NS_RELEASE(cont);
         break;
       }
       delete ClearMiscContainer();
       break;
     }
     case eAtomBase:
     {
       nsIAtom* atom = GetAtomValue();
       NS_RELEASE(atom);
       break;
     }
     case eIntegerBase:
     {
       break;
     }
   }
   mBits = 0;
 }
 void
 nsAttrValue::SetTo(const nsAttrValue& aOther)
 {
   if (this == &aOther) {
     return;
   }
   switch (aOther.BaseType()) {
     case eStringBase:
     {
       ResetIfSet();
       nsStringBuffer* str = static_cast<nsStringBuffer*>(aOther.GetPtr());
       if (str) {
         str->AddRef();
         SetPtrValueAndType(str, eStringBase);
       }
       return;
     }
     case eOtherBase:
     {
       break;
     }
     case eAtomBase:
     {
       ResetIfSet();
       nsIAtom* atom = aOther.GetAtomValue();
       NS_ADDREF(atom);
       SetPtrValueAndType(atom, eAtomBase);
       return;
     }
     case eIntegerBase:
     {
       ResetIfSet();
       mBits = aOther.mBits;
       return;
     }
   }
   MiscContainer* otherCont = aOther.GetMiscContainer();
   if (otherCont->IsRefCounted()) {
     delete ClearMiscContainer();
     NS_ADDREF(otherCont);
     SetPtrValueAndType(otherCont, eOtherBase);
     return;
   }
   MiscContainer* cont = EnsureEmptyMiscContainer();
   switch (otherCont->mType) {
     case eInteger:
     {
       cont->mValue.mInteger = otherCont->mValue.mInteger;
       break;
     }
     case eEnum:
     {
       cont->mValue.mEnumValue = otherCont->mValue.mEnumValue;
       break;
     }
     case ePercent:
     {
       cont->mValue.mPercent = otherCont->mValue.mPercent;
       break;
     }
     case eColor:
     {
       cont->mValue.mColor = otherCont->mValue.mColor;
       break;
     }
     case eCSSStyleRule:
     {
       MOZ_CRASH("These should be refcounted!");
     }
     case eURL:
     {
       NS_ADDREF(cont->mValue.mURL = otherCont->mValue.mURL);
       break;
     }
     case eImage:
     {
       NS_ADDREF(cont->mValue.mImage = otherCont->mValue.mImage);
       break;
     }
     case eAtomArray:
     {
       if (!EnsureEmptyAtomArray() ||
           !GetAtomArrayValue()->AppendElements(*otherCont->mValue.mAtomArray)) {
         Reset();
         return;
       }
       break;
     }
     case eDoubleValue:
     {
       cont->mDoubleValue = otherCont->mDoubleValue;
       break;
     }
     case eIntMarginValue:
     {
       if (otherCont->mValue.mIntMargin)
         cont->mValue.mIntMargin =
           new nsIntMargin(*otherCont->mValue.mIntMargin);
       break;
     }
     default:
     {
       if (IsSVGType(otherCont->mType)) {
         // All SVG types are just pointers to classes and will therefore have
         // the same size so it doesn't really matter which one we assign
         cont->mValue.mSVGAngle = otherCont->mValue.mSVGAngle;
       } else {
         NS_NOTREACHED("unknown type stored in MiscContainer");
       }
       break;
     }
   }
   void* otherPtr = MISC_STR_PTR(otherCont);
   if (otherPtr) {
     if (static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
         eStringBase) {
       static_cast<nsStringBuffer*>(otherPtr)->AddRef();
     } else {
       static_cast<nsIAtom*>(otherPtr)->AddRef();
     }
     cont->mStringBits = otherCont->mStringBits;
   }
   // Note, set mType after switch-case, otherwise EnsureEmptyAtomArray doesn't
   // work correctly.
   cont->mType = otherCont->mType;
 }
 void
 nsAttrValue::SetTo(const nsAString& aValue)
 {
   ResetIfSet();
   nsStringBuffer* buf = GetStringBuffer(aValue).take();
   if (buf) {
     SetPtrValueAndType(buf, eStringBase);
   }
 }
 void
 nsAttrValue::SetTo(nsIAtom* aValue)
 {
   ResetIfSet();
   if (aValue) {
     NS_ADDREF(aValue);
     SetPtrValueAndType(aValue, eAtomBase);
   }
 }
 void
 nsAttrValue::SetTo(int16_t aInt)
 {
   ResetIfSet();
   SetIntValueAndType(aInt, eInteger, nullptr);
 }
 void
 nsAttrValue::SetTo(int32_t aInt, const nsAString* aSerialized)
 {
   ResetIfSet();
   SetIntValueAndType(aInt, eInteger, aSerialized);
 }
 void
 nsAttrValue::SetTo(double aValue, const nsAString* aSerialized)
 {
   MiscContainer* cont = EnsureEmptyMiscContainer();
   cont->mDoubleValue = aValue;
   cont->mType = eDoubleValue;
   SetMiscAtomOrString(aSerialized);
 }
 void
 nsAttrValue::SetTo(css::StyleRule* aValue, const nsAString* aSerialized)
 {
   MiscContainer* cont = EnsureEmptyMiscContainer();
   MOZ_ASSERT(cont->mValue.mRefCount == 0);
   NS_ADDREF(cont->mValue.mCSSStyleRule = aValue);
   cont->mType = eCSSStyleRule;
   NS_ADDREF(cont);
   SetMiscAtomOrString(aSerialized);
   MOZ_ASSERT(cont->mValue.mRefCount == 1);
 }
 void
 nsAttrValue::SetTo(css::URLValue* aValue, const nsAString* aSerialized)
 {
   MiscContainer* cont = EnsureEmptyMiscContainer();
   NS_ADDREF(cont->mValue.mURL = aValue);
   cont->mType = eURL;
   SetMiscAtomOrString(aSerialized);
 }
 void
 nsAttrValue::SetTo(const nsIntMargin& aValue)
 {
   MiscContainer* cont = EnsureEmptyMiscContainer();
   cont->mValue.mIntMargin = new nsIntMargin(aValue);
   cont->mType = eIntMarginValue;
 }
 void
 nsAttrValue::SetToSerialized(const nsAttrValue& aOther)
 {
   if (aOther.Type() != nsAttrValue::eString &&
       aOther.Type() != nsAttrValue::eAtom) {
     nsAutoString val;
     aOther.ToString(val);
     SetTo(val);
   } else {
     SetTo(aOther);
   }
 }
 void
 nsAttrValue::SetTo(const nsSVGAngle& aValue, const nsAString* aSerialized)
 {
   SetSVGType(eSVGAngle, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const nsSVGIntegerPair& aValue, const nsAString* aSerialized)
 {
   SetSVGType(eSVGIntegerPair, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const nsSVGLength2& aValue, const nsAString* aSerialized)
 {
   SetSVGType(eSVGLength, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGLengthList& aValue,
                    const nsAString* aSerialized)
 {
   // While an empty string will parse as a length list, there's no need to store
   // it (and SetMiscAtomOrString will assert if we try)
   if (aSerialized && aSerialized->IsEmpty()) {
     aSerialized = nullptr;
   }
   SetSVGType(eSVGLengthList, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGNumberList& aValue,
                    const nsAString* aSerialized)
 {
   // While an empty string will parse as a number list, there's no need to store
   // it (and SetMiscAtomOrString will assert if we try)
   if (aSerialized && aSerialized->IsEmpty()) {
     aSerialized = nullptr;
   }
   SetSVGType(eSVGNumberList, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const nsSVGNumberPair& aValue, const nsAString* aSerialized)
 {
   SetSVGType(eSVGNumberPair, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGPathData& aValue,
                    const nsAString* aSerialized)
 {
   // While an empty string will parse as path data, there's no need to store it
   // (and SetMiscAtomOrString will assert if we try)
   if (aSerialized && aSerialized->IsEmpty()) {
     aSerialized = nullptr;
   }
   SetSVGType(eSVGPathData, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGPointList& aValue,
                    const nsAString* aSerialized)
 {
   // While an empty string will parse as a point list, there's no need to store
   // it (and SetMiscAtomOrString will assert if we try)
   if (aSerialized && aSerialized->IsEmpty()) {
     aSerialized = nullptr;
   }
   SetSVGType(eSVGPointList, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGAnimatedPreserveAspectRatio& aValue,
                    const nsAString* aSerialized)
 {
   SetSVGType(eSVGPreserveAspectRatio, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGStringList& aValue,
                    const nsAString* aSerialized)
 {
   // While an empty string will parse as a string list, there's no need to store
   // it (and SetMiscAtomOrString will assert if we try)
   if (aSerialized && aSerialized->IsEmpty()) {
     aSerialized = nullptr;
   }
   SetSVGType(eSVGStringList, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const SVGTransformList& aValue,
                    const nsAString* aSerialized)
 {
   // While an empty string will parse as a transform list, there's no need to
   // store it (and SetMiscAtomOrString will assert if we try)
   if (aSerialized && aSerialized->IsEmpty()) {
     aSerialized = nullptr;
   }
   SetSVGType(eSVGTransformList, &aValue, aSerialized);
 }
 void
 nsAttrValue::SetTo(const nsSVGViewBox& aValue, const nsAString* aSerialized)
 {
   SetSVGType(eSVGViewBox, &aValue, aSerialized);
 }
 void
 nsAttrValue::SwapValueWith(nsAttrValue& aOther)
 {
   uintptr_t tmp = aOther.mBits;
   aOther.mBits = mBits;
   mBits = tmp;
 }
 void
 nsAttrValue::ToString(nsAString& aResult) const
 {
   MiscContainer* cont = nullptr;
   if (BaseType() == eOtherBase) {
     cont = GetMiscContainer();
     if (cont->GetString(aResult)) {
       return;
     }
   }
   switch(Type()) {
     case eString:
     {
       nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
       if (str) {
         str->ToString(str->StorageSize()/sizeof(char16_t) - 1, aResult);
       }
       else {
         aResult.Truncate();
       }
       break;
     }
     case eAtom:
     {
       nsIAtom *atom = static_cast<nsIAtom*>(GetPtr());
       atom->ToString(aResult);
       break;
     }
     case eInteger:
     {
       nsAutoString intStr;
       intStr.AppendInt(GetIntegerValue());
       aResult = intStr;
       break;
     }
 #ifdef DEBUG
     case eColor:
     {
       NS_NOTREACHED("color attribute without string data");
       aResult.Truncate();
       break;
     }
 #endif
     case eEnum:
     {
       GetEnumString(aResult, false);
       break;
     }
     case ePercent:
     {
       nsAutoString intStr;
       intStr.AppendInt(cont ? cont->mValue.mPercent : GetIntInternal());
       aResult = intStr + NS_LITERAL_STRING("%");
       break;
     }
     case eCSSStyleRule:
     {
       aResult.Truncate();
       MiscContainer *container = GetMiscContainer();
       css::Declaration *decl =
         container->mValue.mCSSStyleRule->GetDeclaration();
       if (decl) {
         decl->ToString(aResult);
       }
       const_cast<nsAttrValue*>(this)->SetMiscAtomOrString(&aResult);
       break;
     }
     case eDoubleValue:
     {
       aResult.Truncate();
       aResult.AppendFloat(GetDoubleValue());
       break;
     }
     case eSVGAngle:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGAngle,
                                     aResult);
       break;
     }
     case eSVGIntegerPair:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGIntegerPair,
                                     aResult);
       break;
     }
     case eSVGLength:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGLength,
                                     aResult);
       break;
     }
     case eSVGLengthList:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGLengthList,
                                     aResult);
       break;
     }
     case eSVGNumberList:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGNumberList,
                                     aResult);
       break;
     }
     case eSVGNumberPair:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGNumberPair,
                                     aResult);
       break;
     }
     case eSVGPathData:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGPathData,
                                     aResult);
       break;
     }
     case eSVGPointList:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGPointList,
                                     aResult);
       break;
     }
     case eSVGPreserveAspectRatio:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGPreserveAspectRatio,
                                     aResult);
       break;
     }
     case eSVGStringList:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGStringList,
                                     aResult);
       break;
     }
     case eSVGTransformList:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGTransformList,
                                     aResult);
       break;
     }
     case eSVGViewBox:
     {
       SVGAttrValueWrapper::ToString(GetMiscContainer()->mValue.mSVGViewBox,
                                     aResult);
       break;
     }
     default:
     {
       aResult.Truncate();
       break;
     }
   }
 }
 already_AddRefed<nsIAtom>
 nsAttrValue::GetAsAtom() const
 {
   switch (Type()) {
     case eString:
       return do_GetAtom(GetStringValue());
     case eAtom:
       {
         nsCOMPtr<nsIAtom> atom = GetAtomValue();
         return atom.forget();
       }
     default:
       {
         nsAutoString val;
         ToString(val);
         return do_GetAtom(val);
       }
   }
 }
 const nsCheapString
 nsAttrValue::GetStringValue() const
 {
   NS_PRECONDITION(Type() == eString, "wrong type");
   return nsCheapString(static_cast<nsStringBuffer*>(GetPtr()));
 }
 bool
 nsAttrValue::GetColorValue(nscolor& aColor) const
 {
   if (Type() != eColor) {
     // Unparseable value, treat as unset.
     NS_ASSERTION(Type() == eString, "unexpected type for color-valued attr");
     return false;
   }
   aColor = GetMiscContainer()->mValue.mColor;
   return true;
 }
 void
 nsAttrValue::GetEnumString(nsAString& aResult, bool aRealTag) const
 {
   NS_PRECONDITION(Type() == eEnum, "wrong type");
   uint32_t allEnumBits =
     (BaseType() == eIntegerBase) ? static_cast<uint32_t>(GetIntInternal())
                                    : GetMiscContainer()->mValue.mEnumValue;
   int16_t val = allEnumBits >> NS_ATTRVALUE_ENUMTABLEINDEX_BITS;
   const EnumTable* table = sEnumTableArray->
     ElementAt(allEnumBits & NS_ATTRVALUE_ENUMTABLEINDEX_MASK);
   while (table->tag) {
     if (table->value == val) {
       aResult.AssignASCII(table->tag);
       if (!aRealTag && allEnumBits & NS_ATTRVALUE_ENUMTABLE_VALUE_NEEDS_TO_UPPER) {
         nsContentUtils::ASCIIToUpper(aResult);
       }
       return;
     }
     table++;
   }
   NS_NOTREACHED("couldn't find value in EnumTable");
 }
 uint32_t
 nsAttrValue::GetAtomCount() const
 {
   ValueType type = Type();
   if (type == eAtom) {
     return 1;
   }
   if (type == eAtomArray) {
     return GetAtomArrayValue()->Length();
   }
   return 0;
 }
 nsIAtom*
 nsAttrValue::AtomAt(int32_t aIndex) const
 {
   NS_PRECONDITION(aIndex >= 0, "Index must not be negative");
   NS_PRECONDITION(GetAtomCount() > uint32_t(aIndex), "aIndex out of range");
   if (BaseType() == eAtomBase) {
     return GetAtomValue();
   }
   NS_ASSERTION(Type() == eAtomArray, "GetAtomCount must be confused");
   return GetAtomArrayValue()->ElementAt(aIndex);
 }
 uint32_t
 nsAttrValue::HashValue() const
 {
   switch(BaseType()) {
     case eStringBase:
     {
       nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
       if (str) {
         uint32_t len = str->StorageSize()/sizeof(char16_t) - 1;
         return HashString(static_cast<char16_t*>(str->Data()), len);
       }
       return 0;
     }
     case eOtherBase:
     {
       break;
     }
     case eAtomBase:
     case eIntegerBase:
     {
       // mBits and uint32_t might have different size. This should silence
       // any warnings or compile-errors. This is what the implementation of
       // NS_PTR_TO_INT32 does to take care of the same problem.
       return mBits - 0;
     }
   }
   MiscContainer* cont = GetMiscContainer();
   if (static_cast<ValueBaseType>(cont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK)
       == eAtomBase) {
     return cont->mStringBits - 0;
   }
   switch (cont->mType) {
     case eInteger:
     {
       return cont->mValue.mInteger;
     }
     case eEnum:
     {
       return cont->mValue.mEnumValue;
     }
     case ePercent:
     {
       return cont->mValue.mPercent;
     }
     case eColor:
     {
       return cont->mValue.mColor;
     }
     case eCSSStyleRule:
     {
       return NS_PTR_TO_INT32(cont->mValue.mCSSStyleRule);
     }
     // Intentionally identical, so that loading the image does not change the
     // hash code.
     case eURL:
     case eImage:
     {
       nsString str;
       ToString(str);
       return HashString(str);
     }
     case eAtomArray:
     {
       uint32_t hash = 0;
       uint32_t count = cont->mValue.mAtomArray->Length();
       for (nsCOMPtr<nsIAtom> *cur = cont->mValue.mAtomArray->Elements(),
                              *end = cur + count;
            cur != end; ++cur) {
         hash = AddToHash(hash, cur->get());
       }
       return hash;
     }
     case eDoubleValue:
     {
       // XXX this is crappy, but oh well
       return cont->mDoubleValue;
     }
     case eIntMarginValue:
     {
       return NS_PTR_TO_INT32(cont->mValue.mIntMargin);
     }
     default:
     {
       if (IsSVGType(cont->mType)) {
         // All SVG types are just pointers to classes so we can treat them alike
         return NS_PTR_TO_INT32(cont->mValue.mSVGAngle);
       }
       NS_NOTREACHED("unknown type stored in MiscContainer");
       return 0;
     }
   }
 }
 bool
 nsAttrValue::Equals(const nsAttrValue& aOther) const
 {
   if (BaseType() != aOther.BaseType()) {
     return false;
   }
   switch(BaseType()) {
     case eStringBase:
     {
       return GetStringValue().Equals(aOther.GetStringValue());
     }
     case eOtherBase:
     {
       break;
     }
     case eAtomBase:
     case eIntegerBase:
     {
       return mBits == aOther.mBits;
     }
   }
   MiscContainer* thisCont = GetMiscContainer();
   MiscContainer* otherCont = aOther.GetMiscContainer();
   if (thisCont == otherCont) {
     return true;
   }
   if (thisCont->mType != otherCont->mType) {
     return false;
   }
   bool needsStringComparison = false;
   switch (thisCont->mType) {
     case eInteger:
     {
       if (thisCont->mValue.mInteger == otherCont->mValue.mInteger) {
         needsStringComparison = true;
       }
       break;
     }
     case eEnum:
     {
       if (thisCont->mValue.mEnumValue == otherCont->mValue.mEnumValue) {
         needsStringComparison = true;
       }
       break;
     }
     case ePercent:
     {
       if (thisCont->mValue.mPercent == otherCont->mValue.mPercent) {
         needsStringComparison = true;
       }
       break;
     }
     case eColor:
     {
       if (thisCont->mValue.mColor == otherCont->mValue.mColor) {
         needsStringComparison = true;
       }
       break;
     }
     case eCSSStyleRule:
     {
       return thisCont->mValue.mCSSStyleRule == otherCont->mValue.mCSSStyleRule;
     }
     case eURL:
     {
       return thisCont->mValue.mURL == otherCont->mValue.mURL;
     }
     case eImage:
     {
       return thisCont->mValue.mImage == otherCont->mValue.mImage;
     }
     case eAtomArray:
     {
       // For classlists we could be insensitive to order, however
       // classlists are never mapped attributes so they are never compared.
       if (!(*thisCont->mValue.mAtomArray == *otherCont->mValue.mAtomArray)) {
         return false;
       }
       needsStringComparison = true;
       break;
     }
     case eDoubleValue:
     {
       return thisCont->mDoubleValue == otherCont->mDoubleValue;
     }
     case eIntMarginValue:
     {
       return thisCont->mValue.mIntMargin == otherCont->mValue.mIntMargin;
     }
     default:
     {
       if (IsSVGType(thisCont->mType)) {
         // Currently this method is never called for nsAttrValue objects that
         // point to SVG data types.
         // If that changes then we probably want to add methods to the
         // corresponding SVG types to compare their base values.
         // As a shortcut, however, we can begin by comparing the pointers.
         NS_ABORT_IF_FALSE(false, "Comparing nsAttrValues that point to SVG "
           "data");
         return false;
       }
       NS_NOTREACHED("unknown type stored in MiscContainer");
       return false;
     }
   }
   if (needsStringComparison) {
     if (thisCont->mStringBits == otherCont->mStringBits) {
       return true;
     }
     if ((static_cast<ValueBaseType>(thisCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
          eStringBase) &&
         (static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
          eStringBase)) {
       return nsCheapString(reinterpret_cast<nsStringBuffer*>(thisCont->mStringBits)).Equals(
         nsCheapString(reinterpret_cast<nsStringBuffer*>(otherCont->mStringBits)));
     }
   }
   return false;
 }
 bool
 nsAttrValue::Equals(const nsAString& aValue,
                     nsCaseTreatment aCaseSensitive) const
 {
   switch (BaseType()) {
     case eStringBase:
     {
       nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
       if (str) {
         nsDependentString dep(static_cast<char16_t*>(str->Data()),
                               str->StorageSize()/sizeof(char16_t) - 1);
         return aCaseSensitive == eCaseMatters ? aValue.Equals(dep) :
           nsContentUtils::EqualsIgnoreASCIICase(aValue, dep);
       }
       return aValue.IsEmpty();
     }
     case eAtomBase:
       if (aCaseSensitive == eCaseMatters) {
         return static_cast<nsIAtom*>(GetPtr())->Equals(aValue);
       }
       return nsContentUtils::EqualsIgnoreASCIICase(
           nsDependentAtomString(static_cast<nsIAtom*>(GetPtr())),
           aValue);
     default:
       break;
   }
   nsAutoString val;
   ToString(val);
   return aCaseSensitive == eCaseMatters ? val.Equals(aValue) :
     nsContentUtils::EqualsIgnoreASCIICase(val, aValue);
 }
 bool
 nsAttrValue::Equals(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const
 {
   if (aCaseSensitive != eCaseMatters) {
     // Need a better way to handle this!
     nsAutoString value;
     aValue->ToString(value);
     return Equals(value, aCaseSensitive);
   }
   switch (BaseType()) {
     case eStringBase:
     {
       nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
       if (str) {
         nsDependentString dep(static_cast<char16_t*>(str->Data()),
                               str->StorageSize()/sizeof(char16_t) - 1);
         return aValue->Equals(dep);
       }
       return aValue == nsGkAtoms::_empty;
     }
     case eAtomBase:
     {
       return static_cast<nsIAtom*>(GetPtr()) == aValue;
     }
     default:
       break;
   }
   nsAutoString val;
   ToString(val);
   return aValue->Equals(val);
 }
 bool
 nsAttrValue::EqualsAsStrings(const nsAttrValue& aOther) const
 {
   if (Type() == aOther.Type()) {
     return Equals(aOther);
   }
   // We need to serialize at least one nsAttrValue before passing to
   // Equals(const nsAString&), but we can avoid unnecessarily serializing both
   // by checking if one is already of a string type.
   bool thisIsString = (BaseType() == eStringBase || BaseType() == eAtomBase);
   const nsAttrValue& lhs = thisIsString ? *this : aOther;
   const nsAttrValue& rhs = thisIsString ? aOther : *this;
   switch (rhs.BaseType()) {
     case eAtomBase:
       return lhs.Equals(rhs.GetAtomValue(), eCaseMatters);
     case eStringBase:
       return lhs.Equals(rhs.GetStringValue(), eCaseMatters);
     default:
     {
       nsAutoString val;
       rhs.ToString(val);
       return lhs.Equals(val, eCaseMatters);
     }
   }
 }
 bool
 nsAttrValue::Contains(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const
 {
   switch (BaseType()) {
     case eAtomBase:
     {
       nsIAtom* atom = GetAtomValue();
       if (aCaseSensitive == eCaseMatters) {
         return aValue == atom;
       }
       // For performance reasons, don't do a full on unicode case insensitive
       // string comparison. This is only used for quirks mode anyway.
       return
         nsContentUtils::EqualsIgnoreASCIICase(nsDependentAtomString(aValue),
                                               nsDependentAtomString(atom));
     }
     default:
     {
       if (Type() == eAtomArray) {
         AtomArray* array = GetAtomArrayValue();
         if (aCaseSensitive == eCaseMatters) {
           return array->Contains(aValue);
         }
         nsDependentAtomString val1(aValue);
         for (nsCOMPtr<nsIAtom> *cur = array->Elements(),
                                *end = cur + array->Length();
              cur != end; ++cur) {
           // For performance reasons, don't do a full on unicode case
           // insensitive string comparison. This is only used for quirks mode
           // anyway.
           if (nsContentUtils::EqualsIgnoreASCIICase(val1,
                 nsDependentAtomString(*cur))) {
             return true;
           }
         }
       }
     }
   }
   return false;
 }
 struct AtomArrayStringComparator {
   bool Equals(nsIAtom* atom, const nsAString& string) const {
     return atom->Equals(string);
   }
 };
 bool
 nsAttrValue::Contains(const nsAString& aValue) const
 {
   switch (BaseType()) {
     case eAtomBase:
     {
       nsIAtom* atom = GetAtomValue();
       return atom->Equals(aValue);
     }
     default:
     {
       if (Type() == eAtomArray) {
         AtomArray* array = GetAtomArrayValue();
         return array->Contains(aValue, AtomArrayStringComparator());
       }
     }
   }
   return false;
 }
 void
 nsAttrValue::ParseAtom(const nsAString& aValue)
 {
   ResetIfSet();
   nsCOMPtr<nsIAtom> atom = NS_NewAtom(aValue);
   if (atom) {
     SetPtrValueAndType(atom.forget().take(), eAtomBase);
   }
 }
 void
 nsAttrValue::ParseAtomArray(const nsAString& aValue)
 {
   nsAString::const_iterator iter, end;
   aValue.BeginReading(iter);
   aValue.EndReading(end);
   bool hasSpace = false;
   // skip initial whitespace
   while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
     hasSpace = true;
     ++iter;
   }
   if (iter == end) {
     SetTo(aValue);
     return;
   }
   nsAString::const_iterator start(iter);
   // get first - and often only - atom
   do {
     ++iter;
   } while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
   nsCOMPtr<nsIAtom> classAtom = do_GetAtom(Substring(start, iter));
   if (!classAtom) {
     Reset();
     return;
   }
   // skip whitespace
   while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
     hasSpace = true;
     ++iter;
   }
   if (iter == end && !hasSpace) {
     // we only found one classname and there was no whitespace so
     // don't bother storing a list
     ResetIfSet();
     nsIAtom* atom = nullptr;
     classAtom.swap(atom);
     SetPtrValueAndType(atom, eAtomBase);
     return;
   }
   if (!EnsureEmptyAtomArray()) {
     return;
   }
   AtomArray* array = GetAtomArrayValue();
   if (!array->AppendElement(classAtom)) {
     Reset();
     return;
   }
   // parse the rest of the classnames
   while (iter != end) {
     start = iter;
     do {
       ++iter;
     } while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
     classAtom = do_GetAtom(Substring(start, iter));
     if (!array->AppendElement(classAtom)) {
       Reset();
       return;
     }
     // skip whitespace
     while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
       ++iter;
     }
   }
   SetMiscAtomOrString(&aValue);
   return;
 }
 void
 nsAttrValue::ParseStringOrAtom(const nsAString& aValue)
 {
   uint32_t len = aValue.Length();
   // Don't bother with atoms if it's an empty string since
   // we can store those efficently anyway.
   if (len && len <= NS_ATTRVALUE_MAX_STRINGLENGTH_ATOM) {
     ParseAtom(aValue);
   }
   else {
     SetTo(aValue);
   }
 }
 void
 nsAttrValue::SetIntValueAndType(int32_t aValue, ValueType aType,
                                 const nsAString* aStringValue)
 {
   if (aStringValue || aValue > NS_ATTRVALUE_INTEGERTYPE_MAXVALUE ||
       aValue < NS_ATTRVALUE_INTEGERTYPE_MINVALUE) {
     MiscContainer* cont = EnsureEmptyMiscContainer();
     switch (aType) {
       case eInteger:
       {
         cont->mValue.mInteger = aValue;
         break;
       }
       case ePercent:
       {
         cont->mValue.mPercent = aValue;
         break;
       }
       case eEnum:
       {
         cont->mValue.mEnumValue = aValue;
         break;
       }
       default:
       {
         NS_NOTREACHED("unknown integer type");
         break;
       }
     }
     cont->mType = aType;
     SetMiscAtomOrString(aStringValue);
   } else {
     NS_ASSERTION(!mBits, "Reset before calling SetIntValueAndType!");
     mBits = (aValue * NS_ATTRVALUE_INTEGERTYPE_MULTIPLIER) | aType;
   }
 }
 int16_t
 nsAttrValue::GetEnumTableIndex(const EnumTable* aTable)
 {
   int16_t index = sEnumTableArray->IndexOf(aTable);
   if (index < 0) {
     index = sEnumTableArray->Length();
     NS_ASSERTION(index <= NS_ATTRVALUE_ENUMTABLEINDEX_MAXVALUE,
         "too many enum tables");
     sEnumTableArray->AppendElement(aTable);
   }
   return index;
 }
 int32_t
 nsAttrValue::EnumTableEntryToValue(const EnumTable* aEnumTable,
                                    const EnumTable* aTableEntry)
 {
   int16_t index = GetEnumTableIndex(aEnumTable);
   int32_t value = (aTableEntry->value << NS_ATTRVALUE_ENUMTABLEINDEX_BITS) +
                   index;
   return value;
 }
 bool
 nsAttrValue::ParseEnumValue(const nsAString& aValue,
                             const EnumTable* aTable,
                             bool aCaseSensitive,
                             const EnumTable* aDefaultValue)
 {
   ResetIfSet();
   const EnumTable* tableEntry = aTable;
   while (tableEntry->tag) {
     if (aCaseSensitive ? aValue.EqualsASCII(tableEntry->tag) :
                          aValue.LowerCaseEqualsASCII(tableEntry->tag)) {
       int32_t value = EnumTableEntryToValue(aTable, tableEntry);
       bool equals = aCaseSensitive || aValue.EqualsASCII(tableEntry->tag);
       if (!equals) {
         nsAutoString tag;
         tag.AssignASCII(tableEntry->tag);
         nsContentUtils::ASCIIToUpper(tag);
         if ((equals = tag.Equals(aValue))) {
           value |= NS_ATTRVALUE_ENUMTABLE_VALUE_NEEDS_TO_UPPER;
         }
       }
       SetIntValueAndType(value, eEnum, equals ? nullptr : &aValue);
       NS_ASSERTION(GetEnumValue() == tableEntry->value,
                    "failed to store enum properly");
       return true;
     }
     tableEntry++;
   }
   if (aDefaultValue) {
     NS_PRECONDITION(aTable <= aDefaultValue && aDefaultValue < tableEntry,
                     "aDefaultValue not inside aTable?");
     SetIntValueAndType(EnumTableEntryToValue(aTable, aDefaultValue),
                        eEnum, &aValue);
     return true;
   }
   return false;
 }
 bool
 nsAttrValue::ParseSpecialIntValue(const nsAString& aString)
 {
   ResetIfSet();
   nsresult ec;
   bool strict;
   bool isPercent = false;
   nsAutoString tmp(aString);
   int32_t originalVal = StringToInteger(aString, &strict, &ec, true, &isPercent);
   if (NS_FAILED(ec)) {
     return false;
   }
   int32_t val = std::max(originalVal, 0);
   // % (percent)
   if (isPercent || tmp.RFindChar('%') >= 0) {
     isPercent = true;
   }
   strict = strict && (originalVal == val);
   SetIntValueAndType(val,
                      isPercent ? ePercent : eInteger,
                      strict ? nullptr : &aString);
   return true;
 }
 bool
 nsAttrValue::ParseIntWithBounds(const nsAString& aString,
                                 int32_t aMin, int32_t aMax)
 {
   NS_PRECONDITION(aMin < aMax, "bad boundaries");
   ResetIfSet();
   nsresult ec;
   bool strict;
   int32_t originalVal = StringToInteger(aString, &strict, &ec);
   if (NS_FAILED(ec)) {
     return false;
   }
   int32_t val = std::max(originalVal, aMin);
   val = std::min(val, aMax);
   strict = strict && (originalVal == val);
   SetIntValueAndType(val, eInteger, strict ? nullptr : &aString);
   return true;
 }
 bool
 nsAttrValue::ParseNonNegativeIntValue(const nsAString& aString)
 {
   ResetIfSet();
   nsresult ec;
   bool strict;
   int32_t originalVal = StringToInteger(aString, &strict, &ec);
   if (NS_FAILED(ec) || originalVal < 0) {
     return false;
   }
   SetIntValueAndType(originalVal, eInteger, strict ? nullptr : &aString);
   return true;
 }
 bool
 nsAttrValue::ParsePositiveIntValue(const nsAString& aString)
 {
   ResetIfSet();
   nsresult ec;
   bool strict;
   int32_t originalVal = StringToInteger(aString, &strict, &ec);
   if (NS_FAILED(ec) || originalVal <= 0) {
     return false;
   }
   SetIntValueAndType(originalVal, eInteger, strict ? nullptr : &aString);
   return true;
 }
 void
 nsAttrValue::SetColorValue(nscolor aColor, const nsAString& aString)
 {
   nsStringBuffer* buf = GetStringBuffer(aString).take();
   if (!buf) {
     return;
   }
   MiscContainer* cont = EnsureEmptyMiscContainer();
   cont->mValue.mColor = aColor;
   cont->mType = eColor;
   // Save the literal string we were passed for round-tripping.
   cont->mStringBits = reinterpret_cast<uintptr_t>(buf) | eStringBase;
 }
 bool
 nsAttrValue::ParseColor(const nsAString& aString)
 {
   ResetIfSet();
   // FIXME (partially, at least): HTML5's algorithm says we shouldn't do
   // the whitespace compression, trimming, or the test for emptiness.
   // (I'm a little skeptical that we shouldn't do the whitespace
   // trimming; WebKit also does it.)
   nsAutoString colorStr(aString);
   colorStr.CompressWhitespace(true, true);
   if (colorStr.IsEmpty()) {
     return false;
   }
   nscolor color;
   // No color names begin with a '#'; in standards mode, all acceptable
   // numeric colors do.
   if (colorStr.First() == '#') {
     nsDependentString withoutHash(colorStr.get() + 1, colorStr.Length() - 1);
     if (NS_HexToRGB(withoutHash, &color)) {
       SetColorValue(color, aString);
       return true;
     }
   } else {
     if (NS_ColorNameToRGB(colorStr, &color)) {
       SetColorValue(color, aString);
       return true;
     }
   }
   // FIXME (maybe): HTML5 says we should handle system colors.  This
   // means we probably need another storage type, since we'd need to
   // handle dynamic changes.  However, I think this is a bad idea:
   // http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2010-May/026449.html
   // Use NS_LooseHexToRGB as a fallback if nothing above worked.
   if (NS_LooseHexToRGB(colorStr, &color)) {
     SetColorValue(color, aString);
     return true;
   }
   return false;
 }
 bool nsAttrValue::ParseDoubleValue(const nsAString& aString)
 {
   ResetIfSet();
   nsresult ec;
   double val = PromiseFlatString(aString).ToDouble(&ec);
   if (NS_FAILED(ec)) {
     return false;
   }
   MiscContainer* cont = EnsureEmptyMiscContainer();
   cont->mDoubleValue = val;
   cont->mType = eDoubleValue;
   nsAutoString serializedFloat;
   serializedFloat.AppendFloat(val);
   SetMiscAtomOrString(serializedFloat.Equals(aString) ? nullptr : &aString);
   return true;
 }
 bool
 nsAttrValue::ParseIntMarginValue(const nsAString& aString)
 {
   ResetIfSet();
   nsIntMargin margins;
   if (!nsContentUtils::ParseIntMarginValue(aString, margins))
     return false;
   MiscContainer* cont = EnsureEmptyMiscContainer();
   cont->mValue.mIntMargin = new nsIntMargin(margins);
   cont->mType = eIntMarginValue;
   SetMiscAtomOrString(&aString);
   return true;
 }
 void
 nsAttrValue::LoadImage(nsIDocument* aDocument)
 {
   NS_ASSERTION(Type() == eURL, "wrong type");
 #ifdef DEBUG
   {
     nsString val;
     ToString(val);
     NS_ASSERTION(!val.IsEmpty(),
                  "How did we end up with an empty string for eURL");
   }
 #endif
   MiscContainer* cont = GetMiscContainer();
   mozilla::css::URLValue* url = cont->mValue.mURL;
   mozilla::css::ImageValue* image =
     new css::ImageValue(url->GetURI(), url->mString, url->mReferrer,
                         url->mOriginPrincipal, aDocument);
   NS_ADDREF(image);
   cont->mValue.mImage = image;
   NS_RELEASE(url);
   cont->mType = eImage;
 }
 bool
 nsAttrValue::ParseStyleAttribute(const nsAString& aString,
                                  nsStyledElementNotElementCSSInlineStyle* aElement)
 {
   nsIDocument* ownerDoc = aElement->OwnerDoc();
   nsHTMLCSSStyleSheet* sheet = ownerDoc->GetInlineStyleSheet();
   nsCOMPtr<nsIURI> baseURI = aElement->GetBaseURI();
   nsIURI* docURI = ownerDoc->GetDocumentURI();
   NS_ASSERTION(aElement->NodePrincipal() == ownerDoc->NodePrincipal(),
                "This is unexpected");
   // If the (immutable) document URI does not match the element's base URI
   // (the common case is that they do match) do not cache the rule.  This is
   // because the results of the CSS parser are dependent on these URIs, and we
   // do not want to have to account for the URIs in the hash lookup.
   bool cachingAllowed = sheet && baseURI == docURI;
   if (cachingAllowed) {
     MiscContainer* cont = sheet->LookupStyleAttr(aString);
     if (cont) {
       // Set our MiscContainer to the cached one.
       NS_ADDREF(cont);
       SetPtrValueAndType(cont, eOtherBase);
       return true;
     }
   }
   css::Loader* cssLoader = ownerDoc->CSSLoader();
   nsCSSParser cssParser(cssLoader);
   nsRefPtr<css::StyleRule> rule;
   cssParser.ParseStyleAttribute(aString, docURI, baseURI,
                                 aElement->NodePrincipal(),
                                 getter_AddRefs(rule));
   if (rule) {
     rule->SetHTMLCSSStyleSheet(sheet);
     SetTo(rule, &aString);
     if (cachingAllowed) {
       MiscContainer* cont = GetMiscContainer();
       cont->Cache();
     }
     return true;
   }
   return false;
 }
 void
 nsAttrValue::SetMiscAtomOrString(const nsAString* aValue)
 {
   NS_ASSERTION(GetMiscContainer(), "Must have MiscContainer!");
   NS_ASSERTION(!GetMiscContainer()->mStringBits,
                "Trying to re-set atom or string!");
   if (aValue) {
     uint32_t len = aValue->Length();
     // * We're allowing eCSSStyleRule attributes to store empty strings as it
     //   can be beneficial to store an empty style attribute as a parsed rule.
     // * We're allowing enumerated values because sometimes the empty
     //   string corresponds to a particular enumerated value, especially
     //   for enumerated values that are not limited enumerated.
     // Add other types as needed.
     NS_ASSERTION(len || Type() == eCSSStyleRule || Type() == eEnum,
                  "Empty string?");
     MiscContainer* cont = GetMiscContainer();
     if (len <= NS_ATTRVALUE_MAX_STRINGLENGTH_ATOM) {
       nsCOMPtr<nsIAtom> atom = NS_NewAtom(*aValue);
       if (atom) {
         cont->mStringBits =
           reinterpret_cast<uintptr_t>(atom.forget().take()) | eAtomBase;
       }
     } else {
       nsStringBuffer* buf = GetStringBuffer(*aValue).take();
       if (buf) {
         cont->mStringBits = reinterpret_cast<uintptr_t>(buf) | eStringBase;
       }
     }
   }
 }
 void
 nsAttrValue::ResetMiscAtomOrString()
 {
   MiscContainer* cont = GetMiscContainer();
   void* ptr = MISC_STR_PTR(cont);
   if (ptr) {
     if (static_cast<ValueBaseType>(cont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
         eStringBase) {
       static_cast<nsStringBuffer*>(ptr)->Release();
     } else {
       static_cast<nsIAtom*>(ptr)->Release();
     }
     cont->mStringBits = 0;
   }
 }
 void
 nsAttrValue::SetSVGType(ValueType aType, const void* aValue,
                         const nsAString* aSerialized) {
   NS_ABORT_IF_FALSE(IsSVGType(aType), "Not an SVG type");
   MiscContainer* cont = EnsureEmptyMiscContainer();
   // All SVG types are just pointers to classes so just setting any of them
   // will do. We'll lose type-safety but the signature of the calling
   // function should ensure we don't get anything unexpected, and once we
   // stick aValue in a union we lose type information anyway.
   cont->mValue.mSVGAngle = static_cast<const nsSVGAngle*>(aValue);
   cont->mType = aType;
   SetMiscAtomOrString(aSerialized);
 }
 MiscContainer*
 nsAttrValue::ClearMiscContainer()
 {
   MiscContainer* cont = nullptr;
   if (BaseType() == eOtherBase) {
     cont = GetMiscContainer();
     if (cont->IsRefCounted() && cont->mValue.mRefCount > 1) {
       // This MiscContainer is shared, we need a new one.
       NS_RELEASE(cont);
       cont = new MiscContainer;
       SetPtrValueAndType(cont, eOtherBase);
     }
     else {
       switch (cont->mType) {
         case eCSSStyleRule:
         {
           MOZ_ASSERT(cont->mValue.mRefCount == 1);
           cont->Release();
           cont->Evict();
           NS_RELEASE(cont->mValue.mCSSStyleRule);
           break;
         }
         case eURL:
         {
           NS_RELEASE(cont->mValue.mURL);
           break;
         }
         case eImage:
         {
           NS_RELEASE(cont->mValue.mImage);
           break;
         }
         case eAtomArray:
         {
           delete cont->mValue.mAtomArray;
           break;
         }
         case eIntMarginValue:
         {
           delete cont->mValue.mIntMargin;
           break;
         }
         default:
         {
           break;
         }
       }
     }
     ResetMiscAtomOrString();
   }
   else {
     ResetIfSet();
   }
   return cont;
 }
 MiscContainer*
 nsAttrValue::EnsureEmptyMiscContainer()
 {
   MiscContainer* cont = ClearMiscContainer();
   if (cont) {
     MOZ_ASSERT(BaseType() == eOtherBase);
     ResetMiscAtomOrString();
     cont = GetMiscContainer();
   }
   else {
     cont = new MiscContainer;
     SetPtrValueAndType(cont, eOtherBase);
   }
   return cont;
 }
 bool
 nsAttrValue::EnsureEmptyAtomArray()
 {
   if (Type() == eAtomArray) {
     ResetMiscAtomOrString();
     GetAtomArrayValue()->Clear();
     return true;
   }
   AtomArray* array = new AtomArray;
   if (!array) {
     Reset();
     return false;
   }
   MiscContainer* cont = EnsureEmptyMiscContainer();
   cont->mValue.mAtomArray = array;
   cont->mType = eAtomArray;
   return true;
 }
 already_AddRefed<nsStringBuffer>
 nsAttrValue::GetStringBuffer(const nsAString& aValue) const
 {
   uint32_t len = aValue.Length();
   if (!len) {
     return nullptr;
   }
   nsRefPtr<nsStringBuffer> buf = nsStringBuffer::FromString(aValue);
   if (buf && (buf->StorageSize()/sizeof(char16_t) - 1) == len) {
     return buf.forget();
   }
   buf = nsStringBuffer::Alloc((len + 1) * sizeof(char16_t));
   if (!buf) {
     return nullptr;
   }
   char16_t *data = static_cast<char16_t*>(buf->Data());
   CopyUnicodeTo(aValue, 0, data, len);
   data[len] = char16_t(0);
   return buf.forget();
 }
 int32_t
 nsAttrValue::StringToInteger(const nsAString& aValue, bool* aStrict,
                              nsresult* aErrorCode,
                              bool aCanBePercent,
                              bool* aIsPercent) const
 {
   *aStrict = true;
   *aErrorCode = NS_ERROR_ILLEGAL_VALUE;
   if (aCanBePercent) {
     *aIsPercent = false;
   }
   nsAString::const_iterator iter, end;
   aValue.BeginReading(iter);
   aValue.EndReading(end);
   while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
     *aStrict = false;
     ++iter;
   }
   if (iter == end) {
     return 0;
   }
   bool negate = false;
   if (*iter == char16_t('-')) {
     negate = true;
     ++iter;
   } else if (*iter == char16_t('+')) {
     *aStrict = false;
     ++iter;
   }
   int32_t value = 0;
   int32_t pValue = 0; // Previous value, used to check integer overflow
   while (iter != end) {
     if (*iter >= char16_t('0') && *iter <= char16_t('9')) {
       value = (value * 10) + (*iter - char16_t('0'));
       ++iter;
       // Checking for integer overflow.
       if (pValue > value) {
         *aStrict = false;
         *aErrorCode = NS_ERROR_ILLEGAL_VALUE;
         break;
       } else {
         pValue = value;
         *aErrorCode = NS_OK;
       }
     } else if (aCanBePercent && *iter == char16_t('%')) {
       ++iter;
       *aIsPercent = true;
       if (iter != end) {
         *aStrict = false;
         break;
       }
     } else {
       *aStrict = false;
       break;
     }
   }
   if (negate) {
     value = -value;
     // Checking the special case of -0.
     if (!value) {
       *aStrict = false;
     }
   }
   return value;
 }
 size_t
 nsAttrValue::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
 {
   size_t n = 0;
   switch (BaseType()) {
     case eStringBase:
     {
       nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
       n += str ? str->SizeOfIncludingThisIfUnshared(aMallocSizeOf) : 0;
       break;
     }
     case eOtherBase:
     {
       MiscContainer* container = GetMiscContainer();
       if (!container) {
         break;
       }
       n += aMallocSizeOf(container);
       void* otherPtr = MISC_STR_PTR(container);
       // We only count the size of the object pointed by otherPtr if it's a
       // string. When it's an atom, it's counted separatly.
       if (otherPtr &&
           static_cast<ValueBaseType>(container->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase) {
         nsStringBuffer* str = static_cast<nsStringBuffer*>(otherPtr);
         n += str ? str->SizeOfIncludingThisIfUnshared(aMallocSizeOf) : 0;
       }
       if (Type() == eCSSStyleRule && container->mValue.mCSSStyleRule) {
         // TODO: mCSSStyleRule might be owned by another object which would
         //       make us count them twice, bug 677493.
         //n += container->mCSSStyleRule->SizeOfIncludingThis(aMallocSizeOf);
       } else if (Type() == eAtomArray && container->mValue.mAtomArray) {
         // Don't measure each nsIAtom, they are measured separatly.
         n += container->mValue.mAtomArray->SizeOfIncludingThis(aMallocSizeOf);
       }
       break;
     }
     case eAtomBase:    // Atoms are counted separately.
     case eIntegerBase: // The value is in mBits, nothing to do.
       break;
   }
   return n;
 }

The Tor Browser / annotate

content/base/src/nsAttrValue.cpp@deefc01c0e14 (annotated)

content/base/src/nsAttrValue.cpp