tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

SanitizerTypes.cpp (3840B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #include "SanitizerTypes.h"
      6 
      7 namespace mozilla::dom::sanitizer {
      8 
      9 template <typename CanonicalName, typename SanitizerName>
     10 static void SetSanitizerName(const CanonicalName& aName,
     11                             SanitizerName& aSanitizerName) {
     12  aName->LocalName()->ToString(aSanitizerName.mName);
     13  if (nsAtom* ns = aName->GetNamespace()) {
     14    ns->ToString(aSanitizerName.mNamespace);
     15  } else {
     16    aSanitizerName.mNamespace.SetIsVoid(true);
     17  }
     18 }
     19 
     20 bool CanonicalAttribute::IsDataAttribute() const {
     21  return StringBeginsWith(nsDependentAtomString(mLocalName), u"data-"_ns) &&
     22         !mNamespace;
     23 }
     24 
     25 SanitizerAttributeNamespace CanonicalAttribute::ToSanitizerAttributeNamespace()
     26    const {
     27  SanitizerAttributeNamespace result;
     28  SetSanitizerName(this, result);
     29  return result;
     30 }
     31 
     32 SanitizerElementNamespace CanonicalElement::ToSanitizerElementNamespace()
     33    const {
     34  SanitizerElementNamespace result;
     35  SetSanitizerName(this, result);
     36  return result;
     37 }
     38 
     39 SanitizerElementNamespaceWithAttributes
     40 CanonicalElement::ToSanitizerElementNamespaceWithAttributes(
     41    const CanonicalElementAttributes& aElementAttributes) const {
     42  SanitizerElementNamespaceWithAttributes result;
     43  SetSanitizerName(this, result);
     44  if (aElementAttributes.mAttributes) {
     45    result.mAttributes.Construct(
     46        ToSanitizerAttributes(*aElementAttributes.mAttributes));
     47  }
     48  if (aElementAttributes.mRemoveAttributes) {
     49    result.mRemoveAttributes.Construct(
     50        ToSanitizerAttributes(*aElementAttributes.mRemoveAttributes));
     51  }
     52  return result;
     53 }
     54 
     55 template <typename CanonicalName>
     56 static std::ostream& Write(std::ostream& aStream, const CanonicalName& aName) {
     57  nsAutoCString localName;
     58  aName.LocalName()->ToUTF8String(localName);
     59  aStream << '"' << localName << '"';
     60  if (nsAtom* ns = aName.GetNamespace()) {
     61    nsAutoCString nameSpace;
     62    ns->ToUTF8String(nameSpace);
     63    return aStream << " (namespace: \"" << nameSpace << "\")";
     64  }
     65  return aStream << " (namespace: null)";
     66 }
     67 
     68 std::ostream& operator<<(std::ostream& aStream,
     69                         const CanonicalAttribute& aName) {
     70  return Write(aStream, aName);
     71 }
     72 
     73 std::ostream& operator<<(std::ostream& aStream, const CanonicalElement& aName) {
     74  return Write(aStream, aName);
     75 }
     76 
     77 bool CanonicalElementAttributes::Equals(
     78    const CanonicalElementAttributes& aOther) const {
     79  if (mAttributes.isSome() != aOther.mAttributes.isSome() ||
     80      mRemoveAttributes.isSome() != aOther.mRemoveAttributes.isSome()) {
     81    return false;
     82  }
     83 
     84  if (mAttributes) {
     85    if (mAttributes->Count() != aOther.mAttributes->Count()) {
     86      return false;
     87    }
     88 
     89    for (const CanonicalAttribute& attr : *mAttributes) {
     90      if (!aOther.mAttributes->Contains(attr)) {
     91        return false;
     92      }
     93    }
     94  }
     95 
     96  if (mRemoveAttributes) {
     97    if (mRemoveAttributes->Count() != aOther.mRemoveAttributes->Count()) {
     98      return false;
     99    }
    100 
    101    for (const CanonicalAttribute& attr : *mRemoveAttributes) {
    102      if (!aOther.mRemoveAttributes->Contains(attr)) {
    103        return false;
    104      }
    105    }
    106  }
    107 
    108  return true;
    109 }
    110 
    111 nsTArray<OwningStringOrSanitizerAttributeNamespace> ToSanitizerAttributes(
    112    const CanonicalAttributeSet& aSet) {
    113  nsTArray<OwningStringOrSanitizerAttributeNamespace> attributes;
    114  for (const CanonicalAttribute& canonical : aSet) {
    115    OwningStringOrSanitizerAttributeNamespace owning;
    116    owning.SetAsSanitizerAttributeNamespace() =
    117        canonical.ToSanitizerAttributeNamespace();
    118    attributes.InsertElementSorted(owning,
    119                                   SanitizerComparator<decltype(owning)>());
    120  }
    121  return attributes;
    122 }
    123 
    124 }  // namespace mozilla::dom::sanitizer