The Tor Browser: layout/style/CSSVariableResolver.cpp@7e26c7da4463 (annotated)

layout/style/CSSVariableResolver.cpp@7e26c7da4463 (annotated)

layout/style/CSSVariableResolver.cpp

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
 /* 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/. */
 /* object that resolves CSS variables using specified and inherited variable
  * values
  */
 #include "CSSVariableResolver.h"
 #include "CSSVariableDeclarations.h"
 #include "CSSVariableValues.h"
 #include "mozilla/PodOperations.h"
 #include <algorithm>
 namespace mozilla {
 /**
  * Data used by the EnumerateVariableReferences callback.  Reset must be called
  * on it before it is used.
  */
 class EnumerateVariableReferencesData
 {
 public:
   EnumerateVariableReferencesData(CSSVariableResolver& aResolver)
     : mResolver(aResolver)
     , mReferences(new bool[aResolver.mVariables.Length()])
   {
   }
   /**
    * Resets the data so that it can be passed to another call of
    * EnumerateVariableReferences for a different variable.
    */
   void Reset()
   {
     PodZero(mReferences.get(), mResolver.mVariables.Length());
     mReferencesNonExistentVariable = false;
   }
   void RecordVariableReference(const nsAString& aVariableName)
   {
     size_t id;
     if (mResolver.mVariableIDs.Get(aVariableName, &id)) {
       mReferences[id] = true;
     } else {
       mReferencesNonExistentVariable = true;
     }
   }
   bool HasReferenceToVariable(size_t aID) const
   {
     return mReferences[aID];
   }
   bool ReferencesNonExistentVariable() const
   {
    return mReferencesNonExistentVariable;
   }
 private:
   CSSVariableResolver& mResolver;
   // Array of booleans, where each index is a variable ID.  If an element is
   // true, it indicates that the variable we have called
   // EnumerateVariableReferences for has a reference to the variable with
   // that ID.
   nsAutoArrayPtr<bool> mReferences;
   // Whether the variable we have called EnumerateVariableReferences for
   // references a variable that does not exist in the resolver.
   bool mReferencesNonExistentVariable;
 };
 static void
 RecordVariableReference(const nsAString& aVariableName,
                         void* aData)
 {
   static_cast<EnumerateVariableReferencesData*>(aData)->
     RecordVariableReference(aVariableName);
 }
 void
 CSSVariableResolver::RemoveCycles(size_t v)
 {
   mVariables[v].mIndex = mNextIndex;
   mVariables[v].mLowLink = mNextIndex;
   mVariables[v].mInStack = true;
   mStack.AppendElement(v);
   mNextIndex++;
   for (size_t i = 0, n = mReferences[v].Length(); i < n; i++) {
     size_t w = mReferences[v][i];
     if (!mVariables[w].mIndex) {
       RemoveCycles(w);
       mVariables[v].mLowLink = std::min(mVariables[v].mLowLink,
                                         mVariables[w].mLowLink);
     } else if (mVariables[w].mInStack) {
       mVariables[v].mLowLink = std::min(mVariables[v].mLowLink,
                                         mVariables[w].mIndex);
     }
   }
   if (mVariables[v].mLowLink == mVariables[v].mIndex) {
     if (mStack.LastElement() == v) {
       // A strongly connected component consisting of a single variable is not
       // necessarily invalid.  We handle variables that reference themselves
       // earlier, in CSSVariableResolver::Resolve.
       mVariables[mStack.LastElement()].mInStack = false;
       mStack.TruncateLength(mStack.Length() - 1);
     } else {
       size_t w;
       do {
         w = mStack.LastElement();
         mVariables[w].mValue.Truncate(0);
         mVariables[w].mInStack = false;
         mStack.TruncateLength(mStack.Length() - 1);
       } while (w != v);
     }
   }
 }
 void
 CSSVariableResolver::ResolveVariable(size_t aID)
 {
   if (mVariables[aID].mValue.IsEmpty() || mVariables[aID].mWasInherited) {
     // The variable is invalid or was inherited.   We can just copy the value
     // and its first/last token information across.
     mOutput->Put(mVariables[aID].mVariableName,
                  mVariables[aID].mValue,
                  mVariables[aID].mFirstToken,
                  mVariables[aID].mLastToken);
   } else {
     // Otherwise we need to resolve the variable references, after resolving
     // all of our dependencies first.  We do this even for variables that we
     // know do not reference other variables so that we can find their
     // first/last token.
     //
     // XXX We might want to do this first/last token finding during
     // EnumerateVariableReferences, so that we can avoid calling
     // ResolveVariableValue and parsing the value again.
     for (size_t i = 0, n = mReferences[aID].Length(); i < n; i++) {
       size_t j = mReferences[aID][i];
       if (aID != j && !mVariables[j].mResolved) {
         ResolveVariable(j);
       }
     }
     nsString resolvedValue;
     nsCSSTokenSerializationType firstToken, lastToken;
     if (!mParser.ResolveVariableValue(mVariables[aID].mValue, mOutput,
                                       resolvedValue, firstToken, lastToken)) {
       resolvedValue.Truncate(0);
     }
     mOutput->Put(mVariables[aID].mVariableName, resolvedValue,
                  firstToken, lastToken);
   }
   mVariables[aID].mResolved = true;
 }
 void
 CSSVariableResolver::Resolve(const CSSVariableValues* aInherited,
                              const CSSVariableDeclarations* aSpecified)
 {
   MOZ_ASSERT(!mResolved);
   // The only time we would be worried about having a null aInherited is
   // for the root, but in that case nsRuleNode::ComputeVariablesData will
   // happen to pass in whatever we're using as mOutput for aInherited,
   // which will initially be empty.
   MOZ_ASSERT(aInherited);
   MOZ_ASSERT(aSpecified);
   aInherited->AddVariablesToResolver(this);
   aSpecified->AddVariablesToResolver(this);
   // First we look at each variable's value and record which other variables
   // it references.
   size_t n = mVariables.Length();
   mReferences.SetLength(n);
   EnumerateVariableReferencesData data(*this);
   for (size_t id = 0; id < n; id++) {
     data.Reset();
     if (!mVariables[id].mWasInherited &&
         !mVariables[id].mValue.IsEmpty()) {
       if (mParser.EnumerateVariableReferences(mVariables[id].mValue,
                                               RecordVariableReference,
                                               &data)) {
         // Convert the boolean array of dependencies in |data| to a list
         // of dependencies.
         for (size_t i = 0; i < n; i++) {
           if (data.HasReferenceToVariable(i)) {
             mReferences[id].AppendElement(i);
           }
         }
         // If a variable references itself, it is invalid.  (RemoveCycles
         // does not check for cycles consisting of a single variable, so we
         // check here.)
         if (data.HasReferenceToVariable(id)) {
           mVariables[id].mValue.Truncate();
         }
         // Also record whether it referenced any variables that don't exist
         // in the resolver, so that we can ensure we still resolve its value
         // in ResolveVariable, even though its mReferences list is empty.
         mVariables[id].mReferencesNonExistentVariable =
           data.ReferencesNonExistentVariable();
       } else {
         MOZ_ASSERT(false, "EnumerateVariableReferences should not have failed "
                           "if we previously parsed the specified value");
         mVariables[id].mValue.Truncate(0);
       }
     }
   }
   // Next we remove any cycles in variable references using Tarjan's strongly
   // connected components finding algorithm, setting variables in cycles to
   // have an invalid value.
   mNextIndex = 1;
   for (size_t id = 0; id < n; id++) {
     if (!mVariables[id].mIndex) {
       RemoveCycles(id);
       MOZ_ASSERT(mStack.IsEmpty());
     }
   }
   // Finally we construct the computed value for the variable by substituting
   // any variable references.
   for (size_t id = 0; id < n; id++) {
     if (!mVariables[id].mResolved) {
       ResolveVariable(id);
     }
   }
   mResolved = true;
 }
 void
 CSSVariableResolver::Put(const nsAString& aVariableName,
                          nsString aValue,
                          nsCSSTokenSerializationType aFirstToken,
                          nsCSSTokenSerializationType aLastToken,
                          bool aWasInherited)
 {
   MOZ_ASSERT(!mResolved);
   size_t id;
   if (mVariableIDs.Get(aVariableName, &id)) {
     MOZ_ASSERT(mVariables[id].mWasInherited && !aWasInherited,
                "should only overwrite inherited variables with specified "
                "variables");
     mVariables[id].mValue = aValue;
     mVariables[id].mFirstToken = aFirstToken;
     mVariables[id].mLastToken = aLastToken;
     mVariables[id].mWasInherited = aWasInherited;
   } else {
     id = mVariables.Length();
     mVariableIDs.Put(aVariableName, id);
     mVariables.AppendElement(Variable(aVariableName, aValue,
                                       aFirstToken, aLastToken, aWasInherited));
   }
 }
 }

The Tor Browser / annotate

layout/style/CSSVariableResolver.cpp@7e26c7da4463 (annotated)

layout/style/CSSVariableResolver.cpp