The Tor Browser: layout/style/nsRuleNode.cpp@deefc01c0e14

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.)

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* vim: set ts=2 et sw=2 tw=78: */

     3 /* This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     7 /*

     8  * a node in the lexicographic tree of rules that match an element,

     9  * responsible for converting the rules' information into computed style

    10  */

    12 #include <algorithm>

    14 #include "mozilla/ArrayUtils.h"

    15 #include "mozilla/Assertions.h"

    16 #include "mozilla/DebugOnly.h"

    17 #include "mozilla/Likely.h"

    18 #include "mozilla/LookAndFeel.h"

    20 #include "nsRuleNode.h"

    21 #include "nscore.h"

    22 #include "nsIWidget.h"

    23 #include "nsIPresShell.h"

    24 #include "nsFontMetrics.h"

    25 #include "gfxFont.h"

    26 #include "nsCSSPseudoElements.h"

    27 #include "nsThemeConstants.h"

    28 #include "pldhash.h"

    29 #include "nsStyleContext.h"

    30 #include "nsStyleSet.h"

    31 #include "nsStyleStruct.h"

    32 #include "nsSize.h"

    33 #include "nsRuleData.h"

    34 #include "gfxUserFontSet.h"

    35 #include "nsIStyleRule.h"

    36 #include "nsBidiUtils.h"

    37 #include "nsStyleStructInlines.h"

    38 #include "nsCSSProps.h"

    39 #include "nsTArray.h"

    40 #include "nsContentUtils.h"

    41 #include "CSSCalc.h"

    42 #include "nsPrintfCString.h"

    43 #include "nsRenderingContext.h"

    44 #include "nsStyleUtil.h"

    45 #include "nsIDocument.h"

    46 #include "prtime.h"

    47 #include "CSSVariableResolver.h"

    48 #include "nsCSSParser.h"

    50 #if defined(_MSC_VER) || defined(__MINGW32__)

    51 #include <malloc.h>

    52 #ifdef _MSC_VER

    53 #define alloca _alloca

    54 #endif

    55 #endif

    56 #ifdef SOLARIS

    57 #include <alloca.h>

    58 #endif

    60 using std::max;

    61 using std::min;

    62 using namespace mozilla;

    63 using namespace mozilla::dom;

    65 #define NS_SET_IMAGE_REQUEST(method_, context_, request_)                   \

    66   if ((context_)->PresContext()->IsDynamic()) {                               \

    67     method_(request_);                                                      \

    68   } else {                                                                  \

    69     nsRefPtr<imgRequestProxy> req = nsContentUtils::GetStaticRequest(request_); \

    70     method_(req);                                                           \

    71   }

    73 #define NS_SET_IMAGE_REQUEST_WITH_DOC(method_, context_, requestgetter_)      \

    74   {                                                                           \

    75     nsIDocument* doc = (context_)->PresContext()->Document();                 \

    76     NS_SET_IMAGE_REQUEST(method_, context_, requestgetter_(doc))              \

    77   }

    79 /*

    80  * For storage of an |nsRuleNode|'s children in a PLDHashTable.

    81  */

    83 struct ChildrenHashEntry : public PLDHashEntryHdr {

    84   // key is |mRuleNode->GetKey()|

    85   nsRuleNode *mRuleNode;

    86 };

    88 /* static */ PLDHashNumber

    89 nsRuleNode::ChildrenHashHashKey(PLDHashTable *aTable, const void *aKey)

    90 {

    91   const nsRuleNode::Key *key =

    92     static_cast<const nsRuleNode::Key*>(aKey);

    93   // Disagreement on importance and level for the same rule is extremely

    94   // rare, so hash just on the rule.

    95   return PL_DHashVoidPtrKeyStub(aTable, key->mRule);

    96 }

    98 /* static */ bool

    99 nsRuleNode::ChildrenHashMatchEntry(PLDHashTable *aTable,

   100                                    const PLDHashEntryHdr *aHdr,

   101                                    const void *aKey)

   102 {

   103   const ChildrenHashEntry *entry =

   104     static_cast<const ChildrenHashEntry*>(aHdr);

   105   const nsRuleNode::Key *key =

   106     static_cast<const nsRuleNode::Key*>(aKey);

   107   return entry->mRuleNode->GetKey() == *key;

   108 }

   110 /* static */ const PLDHashTableOps

   111 nsRuleNode::ChildrenHashOps = {

   112   // It's probably better to allocate the table itself using malloc and

   113   // free rather than the pres shell's arena because the table doesn't

   114   // grow very often and the pres shell's arena doesn't recycle very

   115   // large size allocations.

   116   PL_DHashAllocTable,

   117   PL_DHashFreeTable,

   118   ChildrenHashHashKey,

   119   ChildrenHashMatchEntry,

   120   PL_DHashMoveEntryStub,

   121   PL_DHashClearEntryStub,

   122   PL_DHashFinalizeStub,

   123   nullptr

   124 };

   127 // EnsureBlockDisplay:

   128 //  - if the display value (argument) is not a block-type

   129 //    then we set it to a valid block display value

   130 //  - For enforcing the floated/positioned element CSS2 rules

   131 //  - We allow the behavior of "list-item" to be customized.

   132 //    CSS21 says that position/float do not convert 'list-item' to 'block',

   133 //    but it explicitly does not define whether 'list-item' should be

   134 //    converted to block *on the root node*. To allow for flexibility

   135 //    (so that we don't have to support a list-item root node), this method

   136 //    lets the caller pick either behavior, using the 'aConvertListItem' arg.

   137 //    Reference: http://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo

   138 /* static */

   139 void

   140 nsRuleNode::EnsureBlockDisplay(uint8_t& display,

   141                                bool aConvertListItem /* = false */)

   142 {

   143   // see if the display value is already a block

   144   switch (display) {

   145   case NS_STYLE_DISPLAY_LIST_ITEM :

   146     if (aConvertListItem) {

   147       display = NS_STYLE_DISPLAY_BLOCK;

   148       break;

   149     } // else, fall through to share the 'break' for non-changing display vals

   150   case NS_STYLE_DISPLAY_NONE :

   151     // never change display:none *ever*

   152   case NS_STYLE_DISPLAY_TABLE :

   153   case NS_STYLE_DISPLAY_BLOCK :

   154   case NS_STYLE_DISPLAY_FLEX :

   155   case NS_STYLE_DISPLAY_GRID :

   156     // do not muck with these at all - already blocks

   157     // This is equivalent to nsStyleDisplay::IsBlockOutside.  (XXX Maybe we

   158     // should just call that?)

   159     // This needs to match the check done in

   160     // nsCSSFrameConstructor::FindMathMLData for <math>.

   161     break;

   163   case NS_STYLE_DISPLAY_INLINE_TABLE :

   164     // make inline tables into tables

   165     display = NS_STYLE_DISPLAY_TABLE;

   166     break;

   168   case NS_STYLE_DISPLAY_INLINE_FLEX:

   169     // make inline flex containers into flex containers

   170     display = NS_STYLE_DISPLAY_FLEX;

   171     break;

   173   case NS_STYLE_DISPLAY_INLINE_GRID:

   174     // make inline grid containers into grid containers

   175     display = NS_STYLE_DISPLAY_GRID;

   176     break;

   178   default :

   179     // make it a block

   180     display = NS_STYLE_DISPLAY_BLOCK;

   181   }

   182 }

   184 static nscoord CalcLengthWith(const nsCSSValue& aValue,

   185                               nscoord aFontSize,

   186                               const nsStyleFont* aStyleFont,

   187                               nsStyleContext* aStyleContext,

   188                               nsPresContext* aPresContext,

   189                               bool aUseProvidedRootEmSize,

   190                               bool aUseUserFontSet,

   191                               bool& aCanStoreInRuleTree);

   193 struct CalcLengthCalcOps : public css::BasicCoordCalcOps,

   194                            public css::NumbersAlreadyNormalizedOps

   195 {

   196   // All of the parameters to CalcLengthWith except aValue.

   197   const nscoord mFontSize;

   198   const nsStyleFont* const mStyleFont;

   199   nsStyleContext* const mStyleContext;

   200   nsPresContext* const mPresContext;

   201   const bool mUseProvidedRootEmSize;

   202   const bool mUseUserFontSet;

   203   bool& mCanStoreInRuleTree;

   205   CalcLengthCalcOps(nscoord aFontSize, const nsStyleFont* aStyleFont,

   206                     nsStyleContext* aStyleContext, nsPresContext* aPresContext,

   207                     bool aUseProvidedRootEmSize, bool aUseUserFontSet,

   208                     bool& aCanStoreInRuleTree)

   209     : mFontSize(aFontSize),

   210       mStyleFont(aStyleFont),

   211       mStyleContext(aStyleContext),

   212       mPresContext(aPresContext),

   213       mUseProvidedRootEmSize(aUseProvidedRootEmSize),

   214       mUseUserFontSet(aUseUserFontSet),

   215       mCanStoreInRuleTree(aCanStoreInRuleTree)

   216   {

   217   }

   219   result_type ComputeLeafValue(const nsCSSValue& aValue)

   220   {

   221     return CalcLengthWith(aValue, mFontSize, mStyleFont,

   222                           mStyleContext, mPresContext, mUseProvidedRootEmSize,

   223                           mUseUserFontSet, mCanStoreInRuleTree);

   224   }

   225 };

   227 static inline nscoord ScaleCoord(const nsCSSValue &aValue, float factor)

   228 {

   229   return NSToCoordRoundWithClamp(aValue.GetFloatValue() * factor);

   230 }

   232 already_AddRefed<nsFontMetrics>

   233 GetMetricsFor(nsPresContext* aPresContext,

   234               nsStyleContext* aStyleContext,

   235               const nsStyleFont* aStyleFont,

   236               nscoord aFontSize, // overrides value from aStyleFont

   237               bool aUseUserFontSet)

   238 {

   239   nsFont font = aStyleFont->mFont;

   240   font.size = aFontSize;

   241   gfxUserFontSet *fs = nullptr;

   242   if (aUseUserFontSet) {

   243     fs = aPresContext->GetUserFontSet();

   244   }

   245   gfxTextPerfMetrics *tp = aPresContext->GetTextPerfMetrics();

   246   nsRefPtr<nsFontMetrics> fm;

   247   aPresContext->DeviceContext()->GetMetricsFor(font,

   248                                                aStyleFont->mLanguage,

   249                                                fs, tp, *getter_AddRefs(fm));

   250   return fm.forget();

   251 }

   254 static nsSize CalcViewportUnitsScale(nsPresContext* aPresContext)

   255 {

   256   // The caller is making use of viewport units, so notify the pres context

   257   // that it will need to rebuild the rule tree if the size of the viewport

   258   // changes.

   259   aPresContext->SetUsesViewportUnits(true);

   261   // The default (when we have 'overflow: auto' on the root element, or

   262   // trivially for 'overflow: hidden' since we never have scrollbars in that

   263   // case) is to define the scale of the viewport units without considering

   264   // scrollbars.

   265   nsSize viewportSize(aPresContext->GetVisibleArea().Size());

   267   // Check for 'overflow: scroll' styles on the root scroll frame. If we find

   268   // any, the standard requires us to take scrollbars into account.

   269   nsIScrollableFrame* scrollFrame =

   270     aPresContext->PresShell()->GetRootScrollFrameAsScrollable();

   271   if (scrollFrame) {

   272     ScrollbarStyles styles(scrollFrame->GetScrollbarStyles());

   274     if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL ||

   275         styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {

   276       // Gather scrollbar size information.

   277       nsRefPtr<nsRenderingContext> context =

   278         aPresContext->PresShell()->CreateReferenceRenderingContext();

   279       nsMargin sizes(scrollFrame->GetDesiredScrollbarSizes(aPresContext, context));

   281       if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {

   282         // 'overflow-x: scroll' means we must consider the horizontal scrollbar,

   283         // which affects the scale of viewport height units.

   284         viewportSize.height -= sizes.TopBottom();

   285       }

   287       if (styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {

   288         // 'overflow-y: scroll' means we must consider the vertical scrollbar,

   289         // which affects the scale of viewport width units.

   290         viewportSize.width -= sizes.LeftRight();

   291       }

   292     }

   293   }

   295   return viewportSize;

   296 }

   298 static nscoord CalcLengthWith(const nsCSSValue& aValue,

   299                               nscoord aFontSize,

   300                               const nsStyleFont* aStyleFont,

   301                               nsStyleContext* aStyleContext,

   302                               nsPresContext* aPresContext,

   303                               bool aUseProvidedRootEmSize,

   304                               // aUseUserFontSet should always be true

   305                               // except when called from

   306                               // CalcLengthWithInitialFont.

   307                               bool aUseUserFontSet,

   308                               bool& aCanStoreInRuleTree)

   309 {

   310   NS_ASSERTION(aValue.IsLengthUnit() || aValue.IsCalcUnit(),

   311                "not a length or calc unit");

   312   NS_ASSERTION(aStyleFont || aStyleContext,

   313                "Must have style data");

   314   NS_ASSERTION(!aStyleFont || !aStyleContext,

   315                "Duplicate sources of data");

   316   NS_ASSERTION(aPresContext, "Must have prescontext");

   318   if (aValue.IsFixedLengthUnit()) {

   319     return aValue.GetFixedLength(aPresContext);

   320   }

   321   if (aValue.IsPixelLengthUnit()) {

   322     return aValue.GetPixelLength();

   323   }

   324   if (aValue.IsCalcUnit()) {

   325     // For properties for which lengths are the *only* units accepted in

   326     // calc(), we can handle calc() here and just compute a final

   327     // result.  We ensure that we don't get to this code for other

   328     // properties by not calling CalcLength in those cases:  SetCoord

   329     // only calls CalcLength for a calc when it is appropriate to do so.

   330     CalcLengthCalcOps ops(aFontSize, aStyleFont,

   331                           aStyleContext, aPresContext,

   332                           aUseProvidedRootEmSize, aUseUserFontSet,

   333                           aCanStoreInRuleTree);

   334     return css::ComputeCalc(aValue, ops);

   335   }

   336   switch (aValue.GetUnit()) {

   337     // nsPresContext::SetVisibleArea and

   338     // nsPresContext::MediaFeatureValuesChanged handle dynamic changes

   339     // of the basis for viewport units by rebuilding the rule tree and

   340     // style context tree.  Not caching them in the rule tree wouldn't

   341     // be sufficient to handle these changes because we also need a way

   342     // to get rid of cached values in the style context tree without any

   343     // changes in specified style.  We can either do this by not caching

   344     // in the rule tree and then throwing away the style context tree

   345     // for dynamic viewport size changes, or by allowing caching in the

   346     // rule tree and using the existing rebuild style data path that

   347     // throws away the style context and the rule tree.

   348     // Thus we do cache viewport units in the rule tree.  This allows us

   349     // to benefit from the performance advantages of the rule tree

   350     // (e.g., faster dynamic changes on other things, like transforms)

   351     // and allows us not to need an additional code path, in exchange

   352     // for an increased cost to dynamic changes to the viewport size

   353     // when viewport units are in use.

   354     case eCSSUnit_ViewportWidth: {

   355       return ScaleCoord(aValue, 0.01f * CalcViewportUnitsScale(aPresContext).width);

   356     }

   357     case eCSSUnit_ViewportHeight: {

   358       return ScaleCoord(aValue, 0.01f * CalcViewportUnitsScale(aPresContext).height);

   359     }

   360     case eCSSUnit_ViewportMin: {

   361       nsSize vuScale(CalcViewportUnitsScale(aPresContext));

   362       return ScaleCoord(aValue, 0.01f * min(vuScale.width, vuScale.height));

   363     }

   364     case eCSSUnit_ViewportMax: {

   365       nsSize vuScale(CalcViewportUnitsScale(aPresContext));

   366       return ScaleCoord(aValue, 0.01f * max(vuScale.width, vuScale.height));

   367     }

   368     // While we could deal with 'rem' units correctly by simply not

   369     // caching any data that uses them in the rule tree, it's valuable

   370     // to store them in the rule tree (for faster dynamic changes of

   371     // other things).  And since the font size of the root element

   372     // changes rarely, we instead handle dynamic changes to the root

   373     // element's font size by rebuilding all style data in

   374     // nsCSSFrameConstructor::RestyleElement.

   375     case eCSSUnit_RootEM: {

   376       aPresContext->SetUsesRootEMUnits(true);

   377       nscoord rootFontSize;

   379       // NOTE: Be very careful with |styleFont|, since we haven't set

   380       // aCanStoreInRuleTree to false yet, so we don't want to introduce

   381       // any dependencies on aStyleContext's data here.

   382       const nsStyleFont *styleFont =

   383         aStyleFont ? aStyleFont : aStyleContext->StyleFont();

   385       if (aUseProvidedRootEmSize) {

   386         // We should use the provided aFontSize as the reference length to

   387         // scale. This only happens when we are calculating font-size or

   388         // an equivalent (scriptminsize or CalcLengthWithInitialFont) on

   389         // the root element, in which case aFontSize is already the

   390         // value we want.

   391         if (aFontSize == -1) {

   392           // XXX Should this be styleFont->mSize instead to avoid taking

   393           // minfontsize prefs into account?

   394           aFontSize = styleFont->mFont.size;

   395         }

   396         rootFontSize = aFontSize;

   397       } else if (aStyleContext && !aStyleContext->GetParent()) {

   398         // This is the root element (XXX we don't really know this, but

   399         // nsRuleNode::SetFont makes the same assumption!), so we should

   400         // use StyleFont on this context to get the root element's

   401         // font size.

   402         rootFontSize = styleFont->mFont.size;

   403       } else {

   404         // This is not the root element or we are calculating something other

   405         // than font size, so rem is relative to the root element's font size.

   406         nsRefPtr<nsStyleContext> rootStyle;

   407         const nsStyleFont *rootStyleFont = styleFont;

   408         Element* docElement = aPresContext->Document()->GetRootElement();

   410         if (docElement) {

   411           rootStyle = aPresContext->StyleSet()->ResolveStyleFor(docElement,

   412                                                                 nullptr);

   413           rootStyleFont = rootStyle->StyleFont();

   414         }

   416         rootFontSize = rootStyleFont->mFont.size;

   417       }

   419       return ScaleCoord(aValue, float(rootFontSize));

   420     }

   421     default:

   422       // Fall through to the code for units that can't be stored in the

   423       // rule tree because they depend on font data.

   424       break;

   425   }

   426   // Common code for units that depend on the element's font data and

   427   // thus can't be stored in the rule tree:

   428   aCanStoreInRuleTree = false;

   429   const nsStyleFont *styleFont =

   430     aStyleFont ? aStyleFont : aStyleContext->StyleFont();

   431   if (aFontSize == -1) {

   432     // XXX Should this be styleFont->mSize instead to avoid taking minfontsize

   433     // prefs into account?

   434     aFontSize = styleFont->mFont.size;

   435   }

   436   switch (aValue.GetUnit()) {

   437     case eCSSUnit_EM: {

   438       // CSS2.1 specifies that this unit scales to the computed font

   439       // size, not the em-width in the font metrics, despite the name.

   440       return ScaleCoord(aValue, float(aFontSize));

   441     }

   442     case eCSSUnit_XHeight: {

   443       nsRefPtr<nsFontMetrics> fm =

   444         GetMetricsFor(aPresContext, aStyleContext, styleFont,

   445                       aFontSize, aUseUserFontSet);

   446       return ScaleCoord(aValue, float(fm->XHeight()));

   447     }

   448     case eCSSUnit_Char: {

   449       nsRefPtr<nsFontMetrics> fm =

   450         GetMetricsFor(aPresContext, aStyleContext, styleFont,

   451                       aFontSize, aUseUserFontSet);

   452       gfxFloat zeroWidth = (fm->GetThebesFontGroup()->GetFontAt(0)

   453                             ->GetMetrics().zeroOrAveCharWidth);

   455       return ScaleCoord(aValue, ceil(aPresContext->AppUnitsPerDevPixel() *

   456                                      zeroWidth));

   457     }

   458     default:

   459       NS_NOTREACHED("unexpected unit");

   460       break;

   461   }

   462   return 0;

   463 }

   465 /* static */ nscoord

   466 nsRuleNode::CalcLength(const nsCSSValue& aValue,

   467                        nsStyleContext* aStyleContext,

   468                        nsPresContext* aPresContext,

   469                        bool& aCanStoreInRuleTree)

   470 {

   471   NS_ASSERTION(aStyleContext, "Must have style data");

   473   return CalcLengthWith(aValue, -1, nullptr,

   474                         aStyleContext, aPresContext,

   475                         false, true, aCanStoreInRuleTree);

   476 }

   478 /* Inline helper function to redirect requests to CalcLength. */

   479 static inline nscoord CalcLength(const nsCSSValue& aValue,

   480                                  nsStyleContext* aStyleContext,

   481                                  nsPresContext* aPresContext,

   482                                  bool& aCanStoreInRuleTree)

   483 {

   484   return nsRuleNode::CalcLength(aValue, aStyleContext,

   485                                 aPresContext, aCanStoreInRuleTree);

   486 }

   488 /* static */ nscoord

   489 nsRuleNode::CalcLengthWithInitialFont(nsPresContext* aPresContext,

   490                                       const nsCSSValue& aValue)

   491 {

   492   nsStyleFont defaultFont(aPresContext); // FIXME: best language?

   493   bool canStoreInRuleTree;

   494   return CalcLengthWith(aValue, -1, &defaultFont,

   495                         nullptr, aPresContext,

   496                         true, false, canStoreInRuleTree);

   497 }

   499 struct LengthPercentPairCalcOps : public css::NumbersAlreadyNormalizedOps

   500 {

   501   typedef nsRuleNode::ComputedCalc result_type;

   503   LengthPercentPairCalcOps(nsStyleContext* aContext,

   504                            nsPresContext* aPresContext,

   505                            bool& aCanStoreInRuleTree)

   506     : mContext(aContext),

   507       mPresContext(aPresContext),

   508       mCanStoreInRuleTree(aCanStoreInRuleTree),

   509       mHasPercent(false) {}

   511   nsStyleContext* mContext;

   512   nsPresContext* mPresContext;

   513   bool& mCanStoreInRuleTree;

   514   bool mHasPercent;

   516   result_type ComputeLeafValue(const nsCSSValue& aValue)

   517   {

   518     if (aValue.GetUnit() == eCSSUnit_Percent) {

   519       mHasPercent = true;

   520       return result_type(0, aValue.GetPercentValue());

   521     }

   522     return result_type(CalcLength(aValue, mContext, mPresContext,

   523                                   mCanStoreInRuleTree),

   524                        0.0f);

   525   }

   527   result_type

   528   MergeAdditive(nsCSSUnit aCalcFunction,

   529                 result_type aValue1, result_type aValue2)

   530   {

   531     if (aCalcFunction == eCSSUnit_Calc_Plus) {

   532       return result_type(NSCoordSaturatingAdd(aValue1.mLength,

   533                                               aValue2.mLength),

   534                          aValue1.mPercent + aValue2.mPercent);

   535     }

   536     NS_ABORT_IF_FALSE(aCalcFunction == eCSSUnit_Calc_Minus,

   537                       "min() and max() are not allowed in calc() on "

   538                       "transform");

   539     return result_type(NSCoordSaturatingSubtract(aValue1.mLength,

   540                                                  aValue2.mLength, 0),

   541                        aValue1.mPercent - aValue2.mPercent);

   542   }

   544   result_type

   545   MergeMultiplicativeL(nsCSSUnit aCalcFunction,

   546                        float aValue1, result_type aValue2)

   547   {

   548     NS_ABORT_IF_FALSE(aCalcFunction == eCSSUnit_Calc_Times_L,

   549                       "unexpected unit");

   550     return result_type(NSCoordSaturatingMultiply(aValue2.mLength, aValue1),

   551                        aValue1 * aValue2.mPercent);

   552   }

   554   result_type

   555   MergeMultiplicativeR(nsCSSUnit aCalcFunction,

   556                        result_type aValue1, float aValue2)

   557   {

   558     NS_ABORT_IF_FALSE(aCalcFunction == eCSSUnit_Calc_Times_R ||

   559                       aCalcFunction == eCSSUnit_Calc_Divided,

   560                       "unexpected unit");

   561     if (aCalcFunction == eCSSUnit_Calc_Divided) {

   562       aValue2 = 1.0f / aValue2;

   563     }

   564     return result_type(NSCoordSaturatingMultiply(aValue1.mLength, aValue2),

   565                        aValue1.mPercent * aValue2);

   566   }

   568 };

   570 static void

   571 SpecifiedCalcToComputedCalc(const nsCSSValue& aValue, nsStyleCoord& aCoord,

   572                             nsStyleContext* aStyleContext,

   573                             bool& aCanStoreInRuleTree)

   574 {

   575   LengthPercentPairCalcOps ops(aStyleContext, aStyleContext->PresContext(),

   576                                aCanStoreInRuleTree);

   577   nsRuleNode::ComputedCalc vals = ComputeCalc(aValue, ops);

   579   nsStyleCoord::Calc *calcObj =

   580     new (aStyleContext->Alloc(sizeof(nsStyleCoord::Calc))) nsStyleCoord::Calc;

   581   // Because we use aStyleContext->Alloc(), we have to store the result

   582   // on the style context and not in the rule tree.

   583   aCanStoreInRuleTree = false;

   585   calcObj->mLength = vals.mLength;

   586   calcObj->mPercent = vals.mPercent;

   587   calcObj->mHasPercent = ops.mHasPercent;

   589   aCoord.SetCalcValue(calcObj);

   590 }

   592 /* static */ nsRuleNode::ComputedCalc

   593 nsRuleNode::SpecifiedCalcToComputedCalc(const nsCSSValue& aValue,

   594                                         nsStyleContext* aStyleContext,

   595                                         nsPresContext* aPresContext,

   596                                         bool& aCanStoreInRuleTree)

   597 {

   598   LengthPercentPairCalcOps ops(aStyleContext, aPresContext,

   599                                aCanStoreInRuleTree);

   600   return ComputeCalc(aValue, ops);

   601 }

   603 // This is our public API for handling calc() expressions that involve

   604 // percentages.

   605 /* static */ nscoord

   606 nsRuleNode::ComputeComputedCalc(const nsStyleCoord& aValue,

   607                                 nscoord aPercentageBasis)

   608 {

   609   nsStyleCoord::Calc *calc = aValue.GetCalcValue();

   610   return calc->mLength +

   611          NSToCoordFloorClamped(aPercentageBasis * calc->mPercent);

   612 }

   614 /* static */ nscoord

   615 nsRuleNode::ComputeCoordPercentCalc(const nsStyleCoord& aCoord,

   616                                     nscoord aPercentageBasis)

   617 {

   618   switch (aCoord.GetUnit()) {

   619     case eStyleUnit_Coord:

   620       return aCoord.GetCoordValue();

   621     case eStyleUnit_Percent:

   622       return NSToCoordFloorClamped(aPercentageBasis * aCoord.GetPercentValue());

   623     case eStyleUnit_Calc:

   624       return ComputeComputedCalc(aCoord, aPercentageBasis);

   625     default:

   626       NS_ABORT_IF_FALSE(false, "unexpected unit");

   627       return 0;

   628   }

   629 }

   631 /* Given an enumerated value that represents a box position, converts it to

   632  * a float representing the percentage of the box it corresponds to.  For

   633  * example, "center" becomes 0.5f.

   634  *

   635  * @param aEnumValue The enumerated value.

   636  * @return The float percent it corresponds to.

   637  */

   638 static float

   639 GetFloatFromBoxPosition(int32_t aEnumValue)

   640 {

   641   switch (aEnumValue) {

   642   case NS_STYLE_BG_POSITION_LEFT:

   643   case NS_STYLE_BG_POSITION_TOP:

   644     return 0.0f;

   645   case NS_STYLE_BG_POSITION_RIGHT:

   646   case NS_STYLE_BG_POSITION_BOTTOM:

   647     return 1.0f;

   648   default:

   649     NS_NOTREACHED("unexpected value");

   650     // fall through

   651   case NS_STYLE_BG_POSITION_CENTER:

   652     return 0.5f;

   653   }

   654 }

   656 #define SETCOORD_NORMAL                 0x01   // N

   657 #define SETCOORD_AUTO                   0x02   // A

   658 #define SETCOORD_INHERIT                0x04   // H

   659 #define SETCOORD_PERCENT                0x08   // P

   660 #define SETCOORD_FACTOR                 0x10   // F

   661 #define SETCOORD_LENGTH                 0x20   // L

   662 #define SETCOORD_INTEGER                0x40   // I

   663 #define SETCOORD_ENUMERATED             0x80   // E

   664 #define SETCOORD_NONE                   0x100  // O

   665 #define SETCOORD_INITIAL_ZERO           0x200

   666 #define SETCOORD_INITIAL_AUTO           0x400

   667 #define SETCOORD_INITIAL_NONE           0x800

   668 #define SETCOORD_INITIAL_NORMAL         0x1000

   669 #define SETCOORD_INITIAL_HALF           0x2000

   670 #define SETCOORD_INITIAL_HUNDRED_PCT    0x00004000

   671 #define SETCOORD_INITIAL_FACTOR_ONE     0x00008000

   672 #define SETCOORD_INITIAL_FACTOR_ZERO    0x00010000

   673 #define SETCOORD_CALC_LENGTH_ONLY       0x00020000

   674 #define SETCOORD_CALC_CLAMP_NONNEGATIVE 0x00040000 // modifier for CALC_LENGTH_ONLY

   675 #define SETCOORD_STORE_CALC             0x00080000

   676 #define SETCOORD_BOX_POSITION           0x00100000 // exclusive with _ENUMERATED

   677 #define SETCOORD_ANGLE                  0x00200000

   678 #define SETCOORD_UNSET_INHERIT          0x00400000

   679 #define SETCOORD_UNSET_INITIAL          0x00800000

   681 #define SETCOORD_LP     (SETCOORD_LENGTH | SETCOORD_PERCENT)

   682 #define SETCOORD_LH     (SETCOORD_LENGTH | SETCOORD_INHERIT)

   683 #define SETCOORD_AH     (SETCOORD_AUTO | SETCOORD_INHERIT)

   684 #define SETCOORD_LAH    (SETCOORD_AUTO | SETCOORD_LENGTH | SETCOORD_INHERIT)

   685 #define SETCOORD_LPH    (SETCOORD_LP | SETCOORD_INHERIT)

   686 #define SETCOORD_LPAH   (SETCOORD_LP | SETCOORD_AH)

   687 #define SETCOORD_LPE    (SETCOORD_LP | SETCOORD_ENUMERATED)

   688 #define SETCOORD_LPEH   (SETCOORD_LPE | SETCOORD_INHERIT)

   689 #define SETCOORD_LPAEH  (SETCOORD_LPAH | SETCOORD_ENUMERATED)

   690 #define SETCOORD_LPO    (SETCOORD_LP | SETCOORD_NONE)

   691 #define SETCOORD_LPOH   (SETCOORD_LPH | SETCOORD_NONE)

   692 #define SETCOORD_LPOEH  (SETCOORD_LPOH | SETCOORD_ENUMERATED)

   693 #define SETCOORD_LE     (SETCOORD_LENGTH | SETCOORD_ENUMERATED)

   694 #define SETCOORD_LEH    (SETCOORD_LE | SETCOORD_INHERIT)

   695 #define SETCOORD_IA     (SETCOORD_INTEGER | SETCOORD_AUTO)

   696 #define SETCOORD_LAE    (SETCOORD_LENGTH | SETCOORD_AUTO | SETCOORD_ENUMERATED)

   698 // changes aCoord iff it returns true

   699 static bool SetCoord(const nsCSSValue& aValue, nsStyleCoord& aCoord,

   700                        const nsStyleCoord& aParentCoord,

   701                        int32_t aMask, nsStyleContext* aStyleContext,

   702                        nsPresContext* aPresContext,

   703                        bool& aCanStoreInRuleTree)

   704 {

   705   bool result = true;

   706   if (aValue.GetUnit() == eCSSUnit_Null) {

   707     result = false;

   708   }

   709   else if ((((aMask & SETCOORD_LENGTH) != 0) &&

   710             aValue.IsLengthUnit()) ||

   711            (((aMask & SETCOORD_CALC_LENGTH_ONLY) != 0) &&

   712             aValue.IsCalcUnit())) {

   713     nscoord len = CalcLength(aValue, aStyleContext, aPresContext,

   714                              aCanStoreInRuleTree);

   715     if ((aMask & SETCOORD_CALC_CLAMP_NONNEGATIVE) && len < 0) {

   716       NS_ASSERTION(aValue.IsCalcUnit(),

   717                    "parser should have ensured no nonnegative lengths");

   718       len = 0;

   719     }

   720     aCoord.SetCoordValue(len);

   721   }

   722   else if (((aMask & SETCOORD_PERCENT) != 0) &&

   723            (aValue.GetUnit() == eCSSUnit_Percent)) {

   724     aCoord.SetPercentValue(aValue.GetPercentValue());

   725   }

   726   else if (((aMask & SETCOORD_INTEGER) != 0) &&

   727            (aValue.GetUnit() == eCSSUnit_Integer)) {

   728     aCoord.SetIntValue(aValue.GetIntValue(), eStyleUnit_Integer);

   729   }

   730   else if (((aMask & SETCOORD_ENUMERATED) != 0) &&

   731            (aValue.GetUnit() == eCSSUnit_Enumerated)) {

   732     aCoord.SetIntValue(aValue.GetIntValue(), eStyleUnit_Enumerated);

   733   }

   734   else if (((aMask & SETCOORD_BOX_POSITION) != 0) &&

   735            (aValue.GetUnit() == eCSSUnit_Enumerated)) {

   736     aCoord.SetPercentValue(GetFloatFromBoxPosition(aValue.GetIntValue()));

   737   }

   738   else if (((aMask & SETCOORD_AUTO) != 0) &&

   739            (aValue.GetUnit() == eCSSUnit_Auto)) {

   740     aCoord.SetAutoValue();

   741   }

   742   else if ((((aMask & SETCOORD_INHERIT) != 0) &&

   743             aValue.GetUnit() == eCSSUnit_Inherit) ||

   744            (((aMask & SETCOORD_UNSET_INHERIT) != 0) &&

   745             aValue.GetUnit() == eCSSUnit_Unset)) {

   746     aCoord = aParentCoord;  // just inherit value from parent

   747     aCanStoreInRuleTree = false;

   748   }

   749   else if (((aMask & SETCOORD_NORMAL) != 0) &&

   750            (aValue.GetUnit() == eCSSUnit_Normal)) {

   751     aCoord.SetNormalValue();

   752   }

   753   else if (((aMask & SETCOORD_NONE) != 0) &&

   754            (aValue.GetUnit() == eCSSUnit_None)) {

   755     aCoord.SetNoneValue();

   756   }

   757   else if (((aMask & SETCOORD_FACTOR) != 0) &&

   758            (aValue.GetUnit() == eCSSUnit_Number)) {

   759     aCoord.SetFactorValue(aValue.GetFloatValue());

   760   }

   761   else if (((aMask & SETCOORD_STORE_CALC) != 0) &&

   762            (aValue.IsCalcUnit())) {

   763     SpecifiedCalcToComputedCalc(aValue, aCoord, aStyleContext,

   764                                 aCanStoreInRuleTree);

   765   }

   766   else if (aValue.GetUnit() == eCSSUnit_Initial ||

   767            (aValue.GetUnit() == eCSSUnit_Unset &&

   768             ((aMask & SETCOORD_UNSET_INITIAL) != 0))) {

   769     if ((aMask & SETCOORD_INITIAL_AUTO) != 0) {

   770       aCoord.SetAutoValue();

   771     }

   772     else if ((aMask & SETCOORD_INITIAL_ZERO) != 0) {

   773       aCoord.SetCoordValue(0);

   774     }

   775     else if ((aMask & SETCOORD_INITIAL_FACTOR_ZERO) != 0) {

   776       aCoord.SetFactorValue(0.0f);

   777     }

   778     else if ((aMask & SETCOORD_INITIAL_NONE) != 0) {

   779       aCoord.SetNoneValue();

   780     }

   781     else if ((aMask & SETCOORD_INITIAL_NORMAL) != 0) {

   782       aCoord.SetNormalValue();

   783     }

   784     else if ((aMask & SETCOORD_INITIAL_HALF) != 0) {

   785       aCoord.SetPercentValue(0.5f);

   786     }

   787     else if ((aMask & SETCOORD_INITIAL_HUNDRED_PCT) != 0) {

   788       aCoord.SetPercentValue(1.0f);

   789     }

   790     else if ((aMask & SETCOORD_INITIAL_FACTOR_ONE) != 0) {

   791       aCoord.SetFactorValue(1.0f);

   792     }

   793     else {

   794       result = false;  // didn't set anything

   795     }

   796   }

   797   else if ((aMask & SETCOORD_ANGLE) != 0 &&

   798            (aValue.IsAngularUnit())) {

   799     nsStyleUnit unit;

   800     switch (aValue.GetUnit()) {

   801       case eCSSUnit_Degree: unit = eStyleUnit_Degree; break;

   802       case eCSSUnit_Grad:   unit = eStyleUnit_Grad; break;

   803       case eCSSUnit_Radian: unit = eStyleUnit_Radian; break;

   804       case eCSSUnit_Turn:   unit = eStyleUnit_Turn; break;

   805       default: NS_NOTREACHED("unrecognized angular unit");

   806         unit = eStyleUnit_Degree;

   807     }

   808     aCoord.SetAngleValue(aValue.GetAngleValue(), unit);

   809   }

   810   else {

   811     result = false;  // didn't set anything

   812   }

   813   return result;

   814 }

   816 // This inline function offers a shortcut for SetCoord() by refusing to accept

   817 // SETCOORD_LENGTH, SETCOORD_INHERIT and SETCOORD_UNSET_* masks.

   818 static inline bool SetAbsCoord(const nsCSSValue& aValue,

   819                                  nsStyleCoord& aCoord,

   820                                  int32_t aMask)

   821 {

   822   NS_ABORT_IF_FALSE((aMask & (SETCOORD_LH | SETCOORD_UNSET_INHERIT |

   823                               SETCOORD_UNSET_INITIAL)) == 0,

   824                     "does not handle SETCOORD_LENGTH, SETCOORD_INHERIT and "

   825                     "SETCOORD_UNSET_*");

   827   // The values of the following variables will never be used; so it does not

   828   // matter what to set.

   829   const nsStyleCoord dummyParentCoord;

   830   nsStyleContext* dummyStyleContext = nullptr;

   831   nsPresContext* dummyPresContext = nullptr;

   832   bool dummyCanStoreInRuleTree = true;

   834   bool rv = SetCoord(aValue, aCoord, dummyParentCoord, aMask,

   835                        dummyStyleContext, dummyPresContext,

   836                        dummyCanStoreInRuleTree);

   837   NS_ABORT_IF_FALSE(dummyCanStoreInRuleTree,

   838                     "SetCoord() should not modify dummyCanStoreInRuleTree.");

   840   return rv;

   841 }

   843 /* Given a specified value that might be a pair value, call SetCoord twice,

   844  * either using each member of the pair, or using the unpaired value twice.

   845  */

   846 static bool

   847 SetPairCoords(const nsCSSValue& aValue,

   848               nsStyleCoord& aCoordX, nsStyleCoord& aCoordY,

   849               const nsStyleCoord& aParentX, const nsStyleCoord& aParentY,

   850               int32_t aMask, nsStyleContext* aStyleContext,

   851               nsPresContext* aPresContext, bool& aCanStoreInRuleTree)

   852 {

   853   const nsCSSValue& valX =

   854     aValue.GetUnit() == eCSSUnit_Pair ? aValue.GetPairValue().mXValue : aValue;

   855   const nsCSSValue& valY =

   856     aValue.GetUnit() == eCSSUnit_Pair ? aValue.GetPairValue().mYValue : aValue;

   858   bool cX = SetCoord(valX, aCoordX, aParentX, aMask, aStyleContext,

   859                        aPresContext, aCanStoreInRuleTree);

   860   mozilla::DebugOnly<bool> cY = SetCoord(valY, aCoordY, aParentY, aMask,

   861                        aStyleContext, aPresContext, aCanStoreInRuleTree);

   862   NS_ABORT_IF_FALSE(cX == cY, "changed one but not the other");

   863   return cX;

   864 }

   866 static bool SetColor(const nsCSSValue& aValue, const nscolor aParentColor,

   867                        nsPresContext* aPresContext, nsStyleContext *aContext,

   868                        nscolor& aResult, bool& aCanStoreInRuleTree)

   869 {

   870   bool    result = false;

   871   nsCSSUnit unit = aValue.GetUnit();

   873   if (aValue.IsNumericColorUnit()) {

   874     aResult = aValue.GetColorValue();

   875     result = true;

   876   }

   877   else if (eCSSUnit_Ident == unit) {

   878     nsAutoString  value;

   879     aValue.GetStringValue(value);

   880     nscolor rgba;

   881     if (NS_ColorNameToRGB(value, &rgba)) {

   882       aResult = rgba;

   883       result = true;

   884     }

   885   }

   886   else if (eCSSUnit_EnumColor == unit) {

   887     int32_t intValue = aValue.GetIntValue();

   888     if (0 <= intValue) {

   889       LookAndFeel::ColorID colorID = (LookAndFeel::ColorID) intValue;

   890       bool useStandinsForNativeColors = aPresContext &&

   891                                         !aPresContext->IsChrome();

   892       if (NS_SUCCEEDED(LookAndFeel::GetColor(colorID,

   893                                     useStandinsForNativeColors, &aResult))) {

   894         result = true;

   895       }

   896     }

   897     else {

   898       aResult = NS_RGB(0, 0, 0);

   899       result = false;

   900       switch (intValue) {

   901         case NS_COLOR_MOZ_HYPERLINKTEXT:

   902           if (aPresContext) {

   903             aResult = aPresContext->DefaultLinkColor();

   904             result = true;

   905           }

   906           break;

   907         case NS_COLOR_MOZ_VISITEDHYPERLINKTEXT:

   908           if (aPresContext) {

   909             aResult = aPresContext->DefaultVisitedLinkColor();

   910             result = true;

   911           }

   912           break;

   913         case NS_COLOR_MOZ_ACTIVEHYPERLINKTEXT:

   914           if (aPresContext) {

   915             aResult = aPresContext->DefaultActiveLinkColor();

   916             result = true;

   917           }

   918           break;

   919         case NS_COLOR_CURRENTCOLOR:

   920           // The data computed from this can't be shared in the rule tree

   921           // because they could be used on a node with a different color

   922           aCanStoreInRuleTree = false;

   923           if (aContext) {

   924             aResult = aContext->StyleColor()->mColor;

   925             result = true;

   926           }

   927           break;

   928         case NS_COLOR_MOZ_DEFAULT_COLOR:

   929           if (aPresContext) {

   930             aResult = aPresContext->DefaultColor();

   931             result = true;

   932           }

   933           break;

   934         case NS_COLOR_MOZ_DEFAULT_BACKGROUND_COLOR:

   935           if (aPresContext) {

   936             aResult = aPresContext->DefaultBackgroundColor();

   937             result = true;

   938           }

   939           break;

   940         default:

   941           NS_NOTREACHED("Should never have an unknown negative colorID.");

   942           break;

   943       }

   944     }

   945   }

   946   else if (eCSSUnit_Inherit == unit) {

   947     aResult = aParentColor;

   948     result = true;

   949     aCanStoreInRuleTree = false;

   950   }

   951   else if (eCSSUnit_Enumerated == unit &&

   952            aValue.GetIntValue() == NS_STYLE_COLOR_INHERIT_FROM_BODY) {

   953     NS_ASSERTION(aPresContext->CompatibilityMode() == eCompatibility_NavQuirks,

   954                  "Should only get this value in quirks mode");

   955     // We just grab the color from the prescontext, and rely on the fact that

   956     // if the body color ever changes all its descendants will get new style

   957     // contexts (but NOT necessarily new rulenodes).

   958     aResult = aPresContext->BodyTextColor();

   959     result = true;

   960     aCanStoreInRuleTree = false;

   961   }

   962   return result;

   963 }

   965 static void SetGradientCoord(const nsCSSValue& aValue, nsPresContext* aPresContext,

   966                              nsStyleContext* aContext, nsStyleCoord& aResult,

   967                              bool& aCanStoreInRuleTree)

   968 {

   969   // OK to pass bad aParentCoord since we're not passing SETCOORD_INHERIT

   970   if (!SetCoord(aValue, aResult, nsStyleCoord(),

   971                 SETCOORD_LPO | SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC,

   972                 aContext, aPresContext, aCanStoreInRuleTree)) {

   973     NS_NOTREACHED("unexpected unit for gradient anchor point");

   974     aResult.SetNoneValue();

   975   }

   976 }

   978 static void SetGradient(const nsCSSValue& aValue, nsPresContext* aPresContext,

   979                         nsStyleContext* aContext, nsStyleGradient& aResult,

   980                         bool& aCanStoreInRuleTree)

   981 {

   982   NS_ABORT_IF_FALSE(aValue.GetUnit() == eCSSUnit_Gradient,

   983                     "The given data is not a gradient");

   985   const nsCSSValueGradient* gradient = aValue.GetGradientValue();

   987   if (gradient->mIsExplicitSize) {

   988     SetCoord(gradient->GetRadiusX(), aResult.mRadiusX, nsStyleCoord(),

   989              SETCOORD_LP | SETCOORD_STORE_CALC,

   990              aContext, aPresContext, aCanStoreInRuleTree);

   991     if (gradient->GetRadiusY().GetUnit() != eCSSUnit_None) {

   992       SetCoord(gradient->GetRadiusY(), aResult.mRadiusY, nsStyleCoord(),

   993                SETCOORD_LP | SETCOORD_STORE_CALC,

   994                aContext, aPresContext, aCanStoreInRuleTree);

   995       aResult.mShape = NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL;

   996     } else {

   997       aResult.mRadiusY = aResult.mRadiusX;

   998       aResult.mShape = NS_STYLE_GRADIENT_SHAPE_CIRCULAR;

   999     }

  1000     aResult.mSize = NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE;

  1001   } else if (gradient->mIsRadial) {

  1002     if (gradient->GetRadialShape().GetUnit() == eCSSUnit_Enumerated) {

  1003       aResult.mShape = gradient->GetRadialShape().GetIntValue();

  1004     } else {

  1005       NS_ASSERTION(gradient->GetRadialShape().GetUnit() == eCSSUnit_None,

  1006                    "bad unit for radial shape");

  1007       aResult.mShape = NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL;

  1008     }

  1009     if (gradient->GetRadialSize().GetUnit() == eCSSUnit_Enumerated) {

  1010       aResult.mSize = gradient->GetRadialSize().GetIntValue();

  1011     } else {

  1012       NS_ASSERTION(gradient->GetRadialSize().GetUnit() == eCSSUnit_None,

  1013                    "bad unit for radial shape");

  1014       aResult.mSize = NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER;

  1015     }

  1016   } else {

  1017     NS_ASSERTION(gradient->GetRadialShape().GetUnit() == eCSSUnit_None,

  1018                  "bad unit for linear shape");

  1019     NS_ASSERTION(gradient->GetRadialSize().GetUnit() == eCSSUnit_None,

  1020                  "bad unit for linear size");

  1021     aResult.mShape = NS_STYLE_GRADIENT_SHAPE_LINEAR;

  1022     aResult.mSize = NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER;

  1023   }

  1025   aResult.mLegacySyntax = gradient->mIsLegacySyntax;

  1027   // bg-position

  1028   SetGradientCoord(gradient->mBgPos.mXValue, aPresContext, aContext,

  1029                    aResult.mBgPosX, aCanStoreInRuleTree);

  1031   SetGradientCoord(gradient->mBgPos.mYValue, aPresContext, aContext,

  1032                    aResult.mBgPosY, aCanStoreInRuleTree);

  1034   aResult.mRepeating = gradient->mIsRepeating;

  1036   // angle

  1037   const nsStyleCoord dummyParentCoord;

  1038   if (!SetCoord(gradient->mAngle, aResult.mAngle, dummyParentCoord, SETCOORD_ANGLE,

  1039                 aContext, aPresContext, aCanStoreInRuleTree)) {

  1040     NS_ASSERTION(gradient->mAngle.GetUnit() == eCSSUnit_None,

  1041                  "bad unit for gradient angle");

  1042     aResult.mAngle.SetNoneValue();

  1043   }

  1045   // stops

  1046   for (uint32_t i = 0; i < gradient->mStops.Length(); i++) {

  1047     nsStyleGradientStop stop;

  1048     const nsCSSValueGradientStop &valueStop = gradient->mStops[i];

  1050     if (!SetCoord(valueStop.mLocation, stop.mLocation,

  1051                   nsStyleCoord(), SETCOORD_LPO | SETCOORD_STORE_CALC,

  1052                   aContext, aPresContext, aCanStoreInRuleTree)) {

  1053       NS_NOTREACHED("unexpected unit for gradient stop location");

  1054     }

  1056     // inherit is not a valid color for stops, so we pass in a dummy

  1057     // parent color

  1058     NS_ASSERTION(valueStop.mColor.GetUnit() != eCSSUnit_Inherit,

  1059                  "inherit is not a valid color for gradient stops");

  1060     SetColor(valueStop.mColor, NS_RGB(0, 0, 0), aPresContext,

  1061              aContext, stop.mColor, aCanStoreInRuleTree);

  1063     aResult.mStops.AppendElement(stop);

  1064   }

  1065 }

  1067 // -moz-image-rect(<uri>, <top>, <right>, <bottom>, <left>)

  1068 static void SetStyleImageToImageRect(nsStyleContext* aStyleContext,

  1069                                      const nsCSSValue& aValue,

  1070                                      nsStyleImage& aResult)

  1071 {

  1072   NS_ABORT_IF_FALSE(aValue.GetUnit() == eCSSUnit_Function &&

  1073                     aValue.EqualsFunction(eCSSKeyword__moz_image_rect),

  1074                     "the value is not valid -moz-image-rect()");

  1076   nsCSSValue::Array* arr = aValue.GetArrayValue();

  1077   NS_ABORT_IF_FALSE(arr && arr->Count() == 6, "invalid number of arguments");

  1079   // <uri>

  1080   if (arr->Item(1).GetUnit() == eCSSUnit_Image) {

  1081     NS_SET_IMAGE_REQUEST_WITH_DOC(aResult.SetImageData,

  1082                                   aStyleContext,

  1083                                   arr->Item(1).GetImageValue)

  1084   } else {

  1085     NS_WARNING("nsCSSValue::Image::Image() failed?");

  1086   }

  1088   // <top>, <right>, <bottom>, <left>

  1089   nsStyleSides cropRect;

  1090   NS_FOR_CSS_SIDES(side) {

  1091     nsStyleCoord coord;

  1092     const nsCSSValue& val = arr->Item(2 + side);

  1094 #ifdef DEBUG

  1095     bool unitOk =

  1096 #endif

  1097       SetAbsCoord(val, coord, SETCOORD_FACTOR | SETCOORD_PERCENT);

  1098     NS_ABORT_IF_FALSE(unitOk, "Incorrect data structure created by CSS parser");

  1099     cropRect.Set(side, coord);

  1100   }

  1101   aResult.SetCropRect(&cropRect);

  1102 }

  1104 static void SetStyleImage(nsStyleContext* aStyleContext,

  1105                           const nsCSSValue& aValue,

  1106                           nsStyleImage& aResult,

  1107                           bool& aCanStoreInRuleTree)

  1108 {

  1109   if (aValue.GetUnit() == eCSSUnit_Null) {

  1110     return;

  1111   }

  1113   aResult.SetNull();

  1115   switch (aValue.GetUnit()) {

  1116     case eCSSUnit_Image:

  1117       NS_SET_IMAGE_REQUEST_WITH_DOC(aResult.SetImageData,

  1118                                     aStyleContext,

  1119                                     aValue.GetImageValue)

  1120       break;

  1121     case eCSSUnit_Function:

  1122       if (aValue.EqualsFunction(eCSSKeyword__moz_image_rect)) {

  1123         SetStyleImageToImageRect(aStyleContext, aValue, aResult);

  1124       } else {

  1125         NS_NOTREACHED("-moz-image-rect() is the only expected function");

  1126       }

  1127       break;

  1128     case eCSSUnit_Gradient:

  1129     {

  1130       nsStyleGradient* gradient = new nsStyleGradient();

  1131       if (gradient) {

  1132         SetGradient(aValue, aStyleContext->PresContext(), aStyleContext,

  1133                     *gradient, aCanStoreInRuleTree);

  1134         aResult.SetGradientData(gradient);

  1135       }

  1136       break;

  1137     }

  1138     case eCSSUnit_Element:

  1139       aResult.SetElementId(aValue.GetStringBufferValue());

  1140       break;

  1141     case eCSSUnit_Initial:

  1142     case eCSSUnit_Unset:

  1143     case eCSSUnit_None:

  1144       break;

  1145     default:

  1146       // We might have eCSSUnit_URL values for if-visited style

  1147       // contexts, which we can safely treat like 'none'.  Otherwise

  1148       // this is an unexpected unit.

  1149       NS_ASSERTION(aStyleContext->IsStyleIfVisited() &&

  1150                    aValue.GetUnit() == eCSSUnit_URL,

  1151                    "unexpected unit; maybe nsCSSValue::Image::Image() failed?");

  1152       break;

  1153   }

  1154 }

  1156 // flags for SetDiscrete - align values with SETCOORD_* constants

  1157 // where possible

  1159 #define SETDSC_NORMAL                 0x01   // N

  1160 #define SETDSC_AUTO                   0x02   // A

  1161 #define SETDSC_INTEGER                0x40   // I

  1162 #define SETDSC_ENUMERATED             0x80   // E

  1163 #define SETDSC_NONE                   0x100  // O

  1164 #define SETDSC_SYSTEM_FONT            0x2000

  1165 #define SETDSC_UNSET_INHERIT          0x00400000

  1166 #define SETDSC_UNSET_INITIAL          0x00800000

  1168 // no caller cares whether aField was changed or not

  1169 template <typename FieldT,

  1170           typename T1, typename T2, typename T3, typename T4, typename T5>

  1171 static void

  1172 SetDiscrete(const nsCSSValue& aValue, FieldT & aField,

  1173             bool& aCanStoreInRuleTree, uint32_t aMask,

  1174             FieldT aParentValue,

  1175             T1 aInitialValue,

  1176             T2 aAutoValue,

  1177             T3 aNoneValue,

  1178             T4 aNormalValue,

  1179             T5 aSystemFontValue)

  1180 {

  1181   switch (aValue.GetUnit()) {

  1182   case eCSSUnit_Null:

  1183     return;

  1185     // every caller of SetDiscrete provides inherit and initial

  1186     // alternatives, so we don't require them to say so in the mask

  1187   case eCSSUnit_Inherit:

  1188     aCanStoreInRuleTree = false;

  1189     aField = aParentValue;

  1190     return;

  1192   case eCSSUnit_Initial:

  1193     aField = aInitialValue;

  1194     return;

  1196     // every caller provides one or other of these alternatives,

  1197     // but they have to say which

  1198   case eCSSUnit_Enumerated:

  1199     if (aMask & SETDSC_ENUMERATED) {

  1200       aField = aValue.GetIntValue();

  1201       return;

  1202     }

  1203     break;

  1205   case eCSSUnit_Integer:

  1206     if (aMask & SETDSC_INTEGER) {

  1207       aField = aValue.GetIntValue();

  1208       return;

  1209     }

  1210     break;

  1212     // remaining possibilities in descending order of frequency of use

  1213   case eCSSUnit_Auto:

  1214     if (aMask & SETDSC_AUTO) {

  1215       aField = aAutoValue;

  1216       return;

  1217     }

  1218     break;

  1220   case eCSSUnit_None:

  1221     if (aMask & SETDSC_NONE) {

  1222       aField = aNoneValue;

  1223       return;

  1224     }

  1225     break;

  1227   case eCSSUnit_Normal:

  1228     if (aMask & SETDSC_NORMAL) {

  1229       aField = aNormalValue;

  1230       return;

  1231     }

  1232     break;

  1234   case eCSSUnit_System_Font:

  1235     if (aMask & SETDSC_SYSTEM_FONT) {

  1236       aField = aSystemFontValue;

  1237       return;

  1238     }

  1239     break;

  1241   case eCSSUnit_Unset:

  1242     if (aMask & SETDSC_UNSET_INHERIT) {

  1243       aCanStoreInRuleTree = false;

  1244       aField = aParentValue;

  1245       return;

  1246     }

  1247     if (aMask & SETDSC_UNSET_INITIAL) {

  1248       aField = aInitialValue;

  1249       return;

  1250     }

  1251     break;

  1253   default:

  1254     break;

  1255   }

  1257   NS_NOTREACHED("SetDiscrete: inappropriate unit");

  1258 }

  1260 // flags for SetFactor

  1261 #define SETFCT_POSITIVE 0x01        // assert value is >= 0.0f

  1262 #define SETFCT_OPACITY  0x02        // clamp value to [0.0f .. 1.0f]

  1263 #define SETFCT_NONE     0x04        // allow _None (uses aInitialValue).

  1264 #define SETFCT_UNSET_INHERIT  0x00400000

  1265 #define SETFCT_UNSET_INITIAL  0x00800000

  1267 static void

  1268 SetFactor(const nsCSSValue& aValue, float& aField, bool& aCanStoreInRuleTree,

  1269           float aParentValue, float aInitialValue, uint32_t aFlags = 0)

  1270 {

  1271   switch (aValue.GetUnit()) {

  1272   case eCSSUnit_Null:

  1273     return;

  1275   case eCSSUnit_Number:

  1276     aField = aValue.GetFloatValue();

  1277     if (aFlags & SETFCT_POSITIVE) {

  1278       NS_ASSERTION(aField >= 0.0f, "negative value for positive-only property");

  1279       if (aField < 0.0f)

  1280         aField = 0.0f;

  1281     }

  1282     if (aFlags & SETFCT_OPACITY) {

  1283       if (aField < 0.0f)

  1284         aField = 0.0f;

  1285       if (aField > 1.0f)

  1286         aField = 1.0f;

  1287     }

  1288     return;

  1290   case eCSSUnit_Inherit:

  1291     aCanStoreInRuleTree = false;

  1292     aField = aParentValue;

  1293     return;

  1295   case eCSSUnit_Initial:

  1296     aField = aInitialValue;

  1297     return;

  1299   case eCSSUnit_None:

  1300     if (aFlags & SETFCT_NONE) {

  1301       aField = aInitialValue;

  1302       return;

  1303     }

  1304     break;

  1306   case eCSSUnit_Unset:

  1307     if (aFlags & SETFCT_UNSET_INHERIT) {

  1308       aCanStoreInRuleTree = false;

  1309       aField = aParentValue;

  1310       return;

  1311     }

  1312     if (aFlags & SETFCT_UNSET_INITIAL) {

  1313       aField = aInitialValue;

  1314       return;

  1315     }

  1316     break;

  1318   default:

  1319     break;

  1320   }

  1322   NS_NOTREACHED("SetFactor: inappropriate unit");

  1323 }

  1325 // Overloaded new operator. Initializes the memory to 0 and relies on an arena

  1326 // (which comes from the presShell) to perform the allocation.

  1327 void*

  1328 nsRuleNode::operator new(size_t sz, nsPresContext* aPresContext) CPP_THROW_NEW

  1329 {

  1330   // Check the recycle list first.

  1331   return aPresContext->PresShell()->AllocateByObjectID(nsPresArena::nsRuleNode_id, sz);

  1332 }

  1334 /* static */ PLDHashOperator

  1335 nsRuleNode::EnqueueRuleNodeChildren(PLDHashTable *table, PLDHashEntryHdr *hdr,

  1336                                     uint32_t number, void *arg)

  1337 {

  1338   ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(hdr);

  1339   nsRuleNode ***destroyQueueTail = static_cast<nsRuleNode***>(arg);

  1340   **destroyQueueTail = entry->mRuleNode;

  1341   *destroyQueueTail = &entry->mRuleNode->mNextSibling;

  1342   return PL_DHASH_NEXT;

  1343 }

  1345 // Overridden to prevent the global delete from being called, since the memory

  1346 // came out of an nsIArena instead of the global delete operator's heap.

  1347 void

  1348 nsRuleNode::DestroyInternal(nsRuleNode ***aDestroyQueueTail)

  1349 {

  1350   nsRuleNode *destroyQueue, **destroyQueueTail;

  1351   if (aDestroyQueueTail) {

  1352     destroyQueueTail = *aDestroyQueueTail;

  1353   } else {

  1354     destroyQueue = nullptr;

  1355     destroyQueueTail = &destroyQueue;

  1356   }

  1358   if (ChildrenAreHashed()) {

  1359     PLDHashTable *children = ChildrenHash();

  1360     PL_DHashTableEnumerate(children, EnqueueRuleNodeChildren,

  1361                            &destroyQueueTail);

  1362     *destroyQueueTail = nullptr; // ensure null-termination

  1363     PL_DHashTableDestroy(children);

  1364   } else if (HaveChildren()) {

  1365     *destroyQueueTail = ChildrenList();

  1366     do {

  1367       destroyQueueTail = &(*destroyQueueTail)->mNextSibling;

  1368     } while (*destroyQueueTail);

  1369   }

  1370   mChildren.asVoid = nullptr;

  1372   if (aDestroyQueueTail) {

  1373     // Our caller destroys the queue.

  1374     *aDestroyQueueTail = destroyQueueTail;

  1375   } else {

  1376     // We have to do destroy the queue.  When we destroy each node, it

  1377     // will add its children to the queue.

  1378     while (destroyQueue) {

  1379       nsRuleNode *cur = destroyQueue;

  1380       destroyQueue = destroyQueue->mNextSibling;

  1381       if (!destroyQueue) {

  1382         NS_ASSERTION(destroyQueueTail == &cur->mNextSibling, "mangled list");

  1383         destroyQueueTail = &destroyQueue;

  1384       }

  1385       cur->DestroyInternal(&destroyQueueTail);

  1386     }

  1387   }

  1389   // Destroy ourselves.

  1390   this->~nsRuleNode();

  1392   // Don't let the memory be freed, since it will be recycled

  1393   // instead. Don't call the global operator delete.

  1394   mPresContext->PresShell()->FreeByObjectID(nsPresArena::nsRuleNode_id, this);

  1395 }

  1397 nsRuleNode* nsRuleNode::CreateRootNode(nsPresContext* aPresContext)

  1398 {

  1399   return new (aPresContext)

  1400     nsRuleNode(aPresContext, nullptr, nullptr, 0xff, false);

  1401 }

  1403 nsRuleNode::nsRuleNode(nsPresContext* aContext, nsRuleNode* aParent,

  1404                        nsIStyleRule* aRule, uint8_t aLevel,

  1405                        bool aIsImportant)

  1406   : mPresContext(aContext),

  1407     mParent(aParent),

  1408     mRule(aRule),

  1409     mDependentBits((uint32_t(aLevel) << NS_RULE_NODE_LEVEL_SHIFT) |

  1410                    (aIsImportant ? NS_RULE_NODE_IS_IMPORTANT : 0)),

  1411     mNoneBits(0),

  1412     mRefCnt(0)

  1413 {

  1414   MOZ_ASSERT(aContext);

  1415   NS_ABORT_IF_FALSE(IsRoot() == !aRule,

  1416                     "non-root rule nodes must have a rule");

  1418   mChildren.asVoid = nullptr;

  1419   MOZ_COUNT_CTOR(nsRuleNode);

  1421   if (mRule) {

  1422     mRule->AddRef();

  1423   }

  1425   NS_ASSERTION(IsRoot() || GetLevel() == aLevel, "not enough bits");

  1426   NS_ASSERTION(IsRoot() || IsImportantRule() == aIsImportant, "yikes");

  1427   /* If IsRoot(), then aContext->StyleSet() is typically null at this

  1428      point.  In any case, we don't want to treat the root rulenode as

  1429      unused.  */

  1430   if (!IsRoot()) {

  1431     mParent->AddRef();

  1432     aContext->StyleSet()->RuleNodeUnused();

  1433   }

  1435   // nsStyleSet::GetContext depends on there being only one animation

  1436   // rule.

  1437   NS_ABORT_IF_FALSE(IsRoot() || GetLevel() != nsStyleSet::eAnimationSheet ||

  1438                     mParent->IsRoot() ||

  1439                     mParent->GetLevel() != nsStyleSet::eAnimationSheet,

  1440                     "must be only one rule at animation level");

  1441 }

  1443 nsRuleNode::~nsRuleNode()

  1444 {

  1445   MOZ_COUNT_DTOR(nsRuleNode);

  1446   if (mStyleData.mResetData || mStyleData.mInheritedData)

  1447     mStyleData.Destroy(mDependentBits, mPresContext);

  1448   if (mRule) {

  1449     mRule->Release();

  1450   }

  1451 }

  1453 nsRuleNode*

  1454 nsRuleNode::Transition(nsIStyleRule* aRule, uint8_t aLevel,

  1455                        bool aIsImportantRule)

  1456 {

  1457   nsRuleNode* next = nullptr;

  1458   nsRuleNode::Key key(aRule, aLevel, aIsImportantRule);

  1460   if (HaveChildren() && !ChildrenAreHashed()) {

  1461     int32_t numKids = 0;

  1462     nsRuleNode* curr = ChildrenList();

  1463     while (curr && curr->GetKey() != key) {

  1464       curr = curr->mNextSibling;

  1465       ++numKids;

  1466     }

  1467     if (curr)

  1468       next = curr;

  1469     else if (numKids >= kMaxChildrenInList)

  1470       ConvertChildrenToHash();

  1471   }

  1473   if (ChildrenAreHashed()) {

  1474     ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>

  1475                                           (PL_DHashTableOperate(ChildrenHash(), &key, PL_DHASH_ADD));

  1476     if (!entry) {

  1477       NS_WARNING("out of memory");

  1478       return this;

  1479     }

  1480     if (entry->mRuleNode)

  1481       next = entry->mRuleNode;

  1482     else {

  1483       next = entry->mRuleNode = new (mPresContext)

  1484         nsRuleNode(mPresContext, this, aRule, aLevel, aIsImportantRule);

  1485       if (!next) {

  1486         PL_DHashTableRawRemove(ChildrenHash(), entry);

  1487         NS_WARNING("out of memory");

  1488         return this;

  1489       }

  1490     }

  1491   } else if (!next) {

  1492     // Create the new entry in our list.

  1493     next = new (mPresContext)

  1494       nsRuleNode(mPresContext, this, aRule, aLevel, aIsImportantRule);

  1495     if (!next) {

  1496       NS_WARNING("out of memory");

  1497       return this;

  1498     }

  1499     next->mNextSibling = ChildrenList();

  1500     SetChildrenList(next);

  1501   }

  1503   return next;

  1504 }

  1506 void nsRuleNode::SetUsedDirectly()

  1507 {

  1508   mDependentBits |= NS_RULE_NODE_USED_DIRECTLY;

  1510   // Maintain the invariant that any rule node that is used directly has

  1511   // all structs that live in the rule tree cached (which

  1512   // nsRuleNode::GetStyleData depends on for speed).

  1513   if (mDependentBits & NS_STYLE_INHERIT_MASK) {

  1514     for (nsStyleStructID sid = nsStyleStructID(0); sid < nsStyleStructID_Length;

  1515          sid = nsStyleStructID(sid + 1)) {

  1516       uint32_t bit = nsCachedStyleData::GetBitForSID(sid);

  1517       if (mDependentBits & bit) {

  1518         nsRuleNode *source = mParent;

  1519         while ((source->mDependentBits & bit) && !source->IsUsedDirectly()) {

  1520           source = source->mParent;

  1521         }

  1522         void *data = source->mStyleData.GetStyleData(sid);

  1523         NS_ASSERTION(data, "unexpected null struct");

  1524         mStyleData.SetStyleData(sid, mPresContext, data);

  1525       }

  1526     }

  1527   }

  1528 }

  1530 void

  1531 nsRuleNode::ConvertChildrenToHash()

  1532 {

  1533   NS_ASSERTION(!ChildrenAreHashed() && HaveChildren(),

  1534                "must have a non-empty list of children");

  1535   PLDHashTable *hash = PL_NewDHashTable(&ChildrenHashOps, nullptr,

  1536                                         sizeof(ChildrenHashEntry),

  1537                                         kMaxChildrenInList * 4);

  1538   if (!hash)

  1539     return;

  1540   for (nsRuleNode* curr = ChildrenList(); curr; curr = curr->mNextSibling) {

  1541     // This will never fail because of the initial size we gave the table.

  1542     ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(

  1543       PL_DHashTableOperate(hash, curr->mRule, PL_DHASH_ADD));

  1544     NS_ASSERTION(!entry->mRuleNode, "duplicate entries in list");

  1545     entry->mRuleNode = curr;

  1546   }

  1547   SetChildrenHash(hash);

  1548 }

  1550 inline void

  1551 nsRuleNode::PropagateNoneBit(uint32_t aBit, nsRuleNode* aHighestNode)

  1552 {

  1553   nsRuleNode* curr = this;

  1554   for (;;) {

  1555     NS_ASSERTION(!(curr->mNoneBits & aBit), "propagating too far");

  1556     curr->mNoneBits |= aBit;

  1557     if (curr == aHighestNode)

  1558       break;

  1559     curr = curr->mParent;

  1560   }

  1561 }

  1563 inline void

  1564 nsRuleNode::PropagateDependentBit(nsStyleStructID aSID, nsRuleNode* aHighestNode,

  1565                                   void* aStruct)

  1566 {

  1567   NS_ASSERTION(aStruct, "expected struct");

  1569   uint32_t bit = nsCachedStyleData::GetBitForSID(aSID);

  1570   for (nsRuleNode* curr = this; curr != aHighestNode; curr = curr->mParent) {

  1571     if (curr->mDependentBits & bit) {

  1572 #ifdef DEBUG

  1573       while (curr != aHighestNode) {

  1574         NS_ASSERTION(curr->mDependentBits & bit, "bit not set");

  1575         curr = curr->mParent;

  1576       }

  1577 #endif

  1578       break;

  1579     }

  1581     curr->mDependentBits |= bit;

  1583     if (curr->IsUsedDirectly()) {

  1584       curr->mStyleData.SetStyleData(aSID, mPresContext, aStruct);

  1585     }

  1586   }

  1587 }

  1589 /*

  1590  * The following "Check" functions are used for determining what type of

  1591  * sharing can be used for the data on this rule node.  MORE HERE...

  1592  */

  1594 /*

  1595  * a callback function that that can revise the result of

  1596  * CheckSpecifiedProperties before finishing; aResult is the current

  1597  * result, and it returns the revised one.

  1598  */

  1599 typedef nsRuleNode::RuleDetail

  1600   (* CheckCallbackFn)(const nsRuleData* aRuleData,

  1601                       nsRuleNode::RuleDetail aResult);

  1603 /**

  1604  * @param aValue the value being examined

  1605  * @param aSpecifiedCount to be incremented by one if the value is specified

  1606  * @param aInheritedCount to be incremented by one if the value is set to inherit

  1607  * @param aUnsetCount to be incremented by one if the value is set to unset

  1608  */

  1609 inline void

  1610 ExamineCSSValue(const nsCSSValue& aValue,

  1611                 uint32_t& aSpecifiedCount,

  1612                 uint32_t& aInheritedCount,

  1613                 uint32_t& aUnsetCount)

  1614 {

  1615   if (aValue.GetUnit() != eCSSUnit_Null) {

  1616     ++aSpecifiedCount;

  1617     if (aValue.GetUnit() == eCSSUnit_Inherit) {

  1618       ++aInheritedCount;

  1619     } else if (aValue.GetUnit() == eCSSUnit_Unset) {

  1620       ++aUnsetCount;

  1621     }

  1622   }

  1623 }

  1625 static nsRuleNode::RuleDetail

  1626 CheckFontCallback(const nsRuleData* aRuleData,

  1627                   nsRuleNode::RuleDetail aResult)

  1628 {

  1629   // em, ex, percent, 'larger', and 'smaller' values on font-size depend

  1630   // on the parent context's font-size

  1631   // Likewise, 'lighter' and 'bolder' values of 'font-weight', and 'wider'

  1632   // and 'narrower' values of 'font-stretch' depend on the parent.

  1633   const nsCSSValue& size = *aRuleData->ValueForFontSize();

  1634   const nsCSSValue& weight = *aRuleData->ValueForFontWeight();

  1635   if ((size.IsRelativeLengthUnit() && size.GetUnit() != eCSSUnit_RootEM) ||

  1636       size.GetUnit() == eCSSUnit_Percent ||

  1637       (size.GetUnit() == eCSSUnit_Enumerated &&

  1638        (size.GetIntValue() == NS_STYLE_FONT_SIZE_SMALLER ||

  1639         size.GetIntValue() == NS_STYLE_FONT_SIZE_LARGER)) ||

  1640       aRuleData->ValueForScriptLevel()->GetUnit() == eCSSUnit_Integer ||

  1641       (weight.GetUnit() == eCSSUnit_Enumerated &&

  1642        (weight.GetIntValue() == NS_STYLE_FONT_WEIGHT_BOLDER ||

  1643         weight.GetIntValue() == NS_STYLE_FONT_WEIGHT_LIGHTER))) {

  1644     NS_ASSERTION(aResult == nsRuleNode::eRulePartialReset ||

  1645                  aResult == nsRuleNode::eRuleFullReset ||

  1646                  aResult == nsRuleNode::eRulePartialMixed ||

  1647                  aResult == nsRuleNode::eRuleFullMixed,

  1648                  "we know we already have a reset-counted property");

  1649     // Promote reset to mixed since we have something that depends on

  1650     // the parent.  But never promote to inherited since that could

  1651     // cause inheritance of the exact value.

  1652     if (aResult == nsRuleNode::eRulePartialReset)

  1653       aResult = nsRuleNode::eRulePartialMixed;

  1654     else if (aResult == nsRuleNode::eRuleFullReset)

  1655       aResult = nsRuleNode::eRuleFullMixed;

  1656   }

  1658   return aResult;

  1659 }

  1661 static nsRuleNode::RuleDetail

  1662 CheckColorCallback(const nsRuleData* aRuleData,

  1663                    nsRuleNode::RuleDetail aResult)

  1664 {

  1665   // currentColor values for color require inheritance

  1666   const nsCSSValue* colorValue = aRuleData->ValueForColor();

  1667   if (colorValue->GetUnit() == eCSSUnit_EnumColor &&

  1668       colorValue->GetIntValue() == NS_COLOR_CURRENTCOLOR) {

  1669     NS_ASSERTION(aResult == nsRuleNode::eRuleFullReset,

  1670                  "we should already be counted as full-reset");

  1671     aResult = nsRuleNode::eRuleFullInherited;

  1672   }

  1674   return aResult;

  1675 }

  1677 static nsRuleNode::RuleDetail

  1678 CheckTextCallback(const nsRuleData* aRuleData,

  1679                   nsRuleNode::RuleDetail aResult)

  1680 {

  1681   const nsCSSValue* textAlignValue = aRuleData->ValueForTextAlign();

  1682   if (textAlignValue->GetUnit() == eCSSUnit_Enumerated &&

  1683       textAlignValue->GetIntValue() ==

  1684         NS_STYLE_TEXT_ALIGN_MOZ_CENTER_OR_INHERIT) {

  1685     // Promote reset to mixed since we have something that depends on

  1686     // the parent.

  1687     if (aResult == nsRuleNode::eRulePartialReset)

  1688       aResult = nsRuleNode::eRulePartialMixed;

  1689     else if (aResult == nsRuleNode::eRuleFullReset)

  1690       aResult = nsRuleNode::eRuleFullMixed;

  1691   }

  1693   return aResult;

  1694 }

  1696 static nsRuleNode::RuleDetail

  1697 CheckVariablesCallback(const nsRuleData* aRuleData,

  1698                        nsRuleNode::RuleDetail aResult)

  1699 {

  1700   // We don't actually have any properties on nsStyleVariables, so we do

  1701   // all of the RuleDetail calculation in here.

  1702   if (aRuleData->mVariables) {

  1703     return nsRuleNode::eRulePartialMixed;

  1704   }

  1705   return nsRuleNode::eRuleNone;

  1706 }

  1708 #define FLAG_DATA_FOR_PROPERTY(name_, id_, method_, flags_, pref_,          \

  1709                                parsevariant_, kwtable_, stylestructoffset_, \

  1710                                animtype_)                                   \

  1711   flags_,

  1713 // The order here must match the enums in *CheckCounter in nsCSSProps.cpp.

  1715 static const uint32_t gFontFlags[] = {

  1716 #define CSS_PROP_FONT FLAG_DATA_FOR_PROPERTY

  1717 #include "nsCSSPropList.h"

  1718 #undef CSS_PROP_FONT

  1719 };

  1721 static const uint32_t gDisplayFlags[] = {

  1722 #define CSS_PROP_DISPLAY FLAG_DATA_FOR_PROPERTY

  1723 #include "nsCSSPropList.h"

  1724 #undef CSS_PROP_DISPLAY

  1725 };

  1727 static const uint32_t gVisibilityFlags[] = {

  1728 #define CSS_PROP_VISIBILITY FLAG_DATA_FOR_PROPERTY

  1729 #include "nsCSSPropList.h"

  1730 #undef CSS_PROP_VISIBILITY

  1731 };

  1733 static const uint32_t gMarginFlags[] = {

  1734 #define CSS_PROP_MARGIN FLAG_DATA_FOR_PROPERTY

  1735 #include "nsCSSPropList.h"

  1736 #undef CSS_PROP_MARGIN

  1737 };

  1739 static const uint32_t gBorderFlags[] = {

  1740 #define CSS_PROP_BORDER FLAG_DATA_FOR_PROPERTY

  1741 #include "nsCSSPropList.h"

  1742 #undef CSS_PROP_BORDER

  1743 };

  1745 static const uint32_t gPaddingFlags[] = {

  1746 #define CSS_PROP_PADDING FLAG_DATA_FOR_PROPERTY

  1747 #include "nsCSSPropList.h"

  1748 #undef CSS_PROP_PADDING

  1749 };

  1751 static const uint32_t gOutlineFlags[] = {

  1752 #define CSS_PROP_OUTLINE FLAG_DATA_FOR_PROPERTY

  1753 #include "nsCSSPropList.h"

  1754 #undef CSS_PROP_OUTLINE

  1755 };

  1757 static const uint32_t gListFlags[] = {

  1758 #define CSS_PROP_LIST FLAG_DATA_FOR_PROPERTY

  1759 #include "nsCSSPropList.h"

  1760 #undef CSS_PROP_LIST

  1761 };

  1763 static const uint32_t gColorFlags[] = {

  1764 #define CSS_PROP_COLOR FLAG_DATA_FOR_PROPERTY

  1765 #include "nsCSSPropList.h"

  1766 #undef CSS_PROP_COLOR

  1767 };

  1769 static const uint32_t gBackgroundFlags[] = {

  1770 #define CSS_PROP_BACKGROUND FLAG_DATA_FOR_PROPERTY

  1771 #include "nsCSSPropList.h"

  1772 #undef CSS_PROP_BACKGROUND

  1773 };

  1775 static const uint32_t gPositionFlags[] = {

  1776 #define CSS_PROP_POSITION FLAG_DATA_FOR_PROPERTY

  1777 #include "nsCSSPropList.h"

  1778 #undef CSS_PROP_POSITION

  1779 };

  1781 static const uint32_t gTableFlags[] = {

  1782 #define CSS_PROP_TABLE FLAG_DATA_FOR_PROPERTY

  1783 #include "nsCSSPropList.h"

  1784 #undef CSS_PROP_TABLE

  1785 };

  1787 static const uint32_t gTableBorderFlags[] = {

  1788 #define CSS_PROP_TABLEBORDER FLAG_DATA_FOR_PROPERTY

  1789 #include "nsCSSPropList.h"

  1790 #undef CSS_PROP_TABLEBORDER

  1791 };

  1793 static const uint32_t gContentFlags[] = {

  1794 #define CSS_PROP_CONTENT FLAG_DATA_FOR_PROPERTY

  1795 #include "nsCSSPropList.h"

  1796 #undef CSS_PROP_CONTENT

  1797 };

  1799 static const uint32_t gQuotesFlags[] = {

  1800 #define CSS_PROP_QUOTES FLAG_DATA_FOR_PROPERTY

  1801 #include "nsCSSPropList.h"

  1802 #undef CSS_PROP_QUOTES

  1803 };

  1805 static const uint32_t gTextFlags[] = {

  1806 #define CSS_PROP_TEXT FLAG_DATA_FOR_PROPERTY

  1807 #include "nsCSSPropList.h"

  1808 #undef CSS_PROP_TEXT

  1809 };

  1811 static const uint32_t gTextResetFlags[] = {

  1812 #define CSS_PROP_TEXTRESET FLAG_DATA_FOR_PROPERTY

  1813 #include "nsCSSPropList.h"

  1814 #undef CSS_PROP_TEXTRESET

  1815 };

  1817 static const uint32_t gUserInterfaceFlags[] = {

  1818 #define CSS_PROP_USERINTERFACE FLAG_DATA_FOR_PROPERTY

  1819 #include "nsCSSPropList.h"

  1820 #undef CSS_PROP_USERINTERFACE

  1821 };

  1823 static const uint32_t gUIResetFlags[] = {

  1824 #define CSS_PROP_UIRESET FLAG_DATA_FOR_PROPERTY

  1825 #include "nsCSSPropList.h"

  1826 #undef CSS_PROP_UIRESET

  1827 };

  1829 static const uint32_t gXULFlags[] = {

  1830 #define CSS_PROP_XUL FLAG_DATA_FOR_PROPERTY

  1831 #include "nsCSSPropList.h"

  1832 #undef CSS_PROP_XUL

  1833 };

  1835 static const uint32_t gSVGFlags[] = {

  1836 #define CSS_PROP_SVG FLAG_DATA_FOR_PROPERTY

  1837 #include "nsCSSPropList.h"

  1838 #undef CSS_PROP_SVG

  1839 };

  1841 static const uint32_t gSVGResetFlags[] = {

  1842 #define CSS_PROP_SVGRESET FLAG_DATA_FOR_PROPERTY

  1843 #include "nsCSSPropList.h"

  1844 #undef CSS_PROP_SVGRESET

  1845 };

  1847 static const uint32_t gColumnFlags[] = {

  1848 #define CSS_PROP_COLUMN FLAG_DATA_FOR_PROPERTY

  1849 #include "nsCSSPropList.h"

  1850 #undef CSS_PROP_COLUMN

  1851 };

  1853 // There are no properties in nsStyleVariables, but we can't have a

  1854 // zero length array.

  1855 static const uint32_t gVariablesFlags[] = {

  1856   0,

  1857 #define CSS_PROP_VARIABLES FLAG_DATA_FOR_PROPERTY

  1858 #include "nsCSSPropList.h"

  1859 #undef CSS_PROP_VARIABLES

  1860 };

  1861 static_assert(sizeof(gVariablesFlags) == sizeof(uint32_t),

  1862               "if nsStyleVariables has properties now you can remove the dummy "

  1863               "gVariablesFlags entry");

  1865 #undef FLAG_DATA_FOR_PROPERTY

  1867 static const uint32_t* gFlagsByStruct[] = {

  1869 #define STYLE_STRUCT(name, checkdata_cb) \

  1870   g##name##Flags,

  1871 #include "nsStyleStructList.h"

  1872 #undef STYLE_STRUCT

  1874 };

  1876 static const CheckCallbackFn gCheckCallbacks[] = {

  1878 #define STYLE_STRUCT(name, checkdata_cb) \

  1879   checkdata_cb,

  1880 #include "nsStyleStructList.h"

  1881 #undef STYLE_STRUCT

  1883 };

  1885 #ifdef DEBUG

  1886 static bool

  1887 AreAllMathMLPropertiesUndefined(const nsRuleData* aRuleData)

  1888 {

  1889   return

  1890     aRuleData->ValueForScriptLevel()->GetUnit() == eCSSUnit_Null &&

  1891     aRuleData->ValueForScriptSizeMultiplier()->GetUnit() == eCSSUnit_Null &&

  1892     aRuleData->ValueForScriptMinSize()->GetUnit() == eCSSUnit_Null &&

  1893     aRuleData->ValueForMathVariant()->GetUnit() == eCSSUnit_Null &&

  1894     aRuleData->ValueForMathDisplay()->GetUnit() == eCSSUnit_Null;

  1895 }

  1896 #endif

  1898 inline nsRuleNode::RuleDetail

  1899 nsRuleNode::CheckSpecifiedProperties(const nsStyleStructID aSID,

  1900                                      const nsRuleData* aRuleData)

  1901 {

  1902   // Build a count of the:

  1903   uint32_t total = 0,      // total number of props in the struct

  1904            specified = 0,  // number that were specified for this node

  1905            inherited = 0,  // number that were 'inherit' (and not

  1906                            //   eCSSUnit_Inherit) for this node

  1907            unset = 0;      // number that were 'unset'

  1909   // See comment in nsRuleData.h above mValueOffsets.

  1910   NS_ABORT_IF_FALSE(aRuleData->mValueOffsets[aSID] == 0,

  1911                     "we assume the value offset is zero instead of adding it");

  1912   for (nsCSSValue *values = aRuleData->mValueStorage,

  1913               *values_end = values + nsCSSProps::PropertyCountInStruct(aSID);

  1914        values != values_end; ++values) {

  1915     ++total;

  1916     ExamineCSSValue(*values, specified, inherited, unset);

  1917   }

  1919   if (!nsCachedStyleData::IsReset(aSID)) {

  1920     // For inherited properties, 'unset' means the same as 'inherit'.

  1921     inherited += unset;

  1922     unset = 0;

  1923   }

  1925 #if 0

  1926   printf("CheckSpecifiedProperties: SID=%d total=%d spec=%d inh=%d.\n",

  1927          aSID, total, specified, inherited);

  1928 #endif

  1930   NS_ASSERTION(aSID != eStyleStruct_Font ||

  1931                mPresContext->Document()->GetMathMLEnabled() ||

  1932                AreAllMathMLPropertiesUndefined(aRuleData),

  1933                "MathML style property was defined even though MathML is disabled");

  1935   /*

  1936    * Return the most specific information we can: prefer None or Full

  1937    * over Partial, and Reset or Inherited over Mixed, since we can

  1938    * optimize based on the edge cases and not the in-between cases.

  1939    */

  1940   nsRuleNode::RuleDetail result;

  1941   if (inherited == total)

  1942     result = eRuleFullInherited;

  1943   else if (specified == total

  1944            // MathML defines 5 properties in Font that will never be set when

  1945            // MathML is not in use. Therefore if all but five

  1946            // properties have been set, and MathML is not enabled, we can treat

  1947            // this as fully specified. Code in nsMathMLElementFactory will

  1948            // rebuild the rule tree and style data when MathML is first enabled

  1949            // (see nsMathMLElement::BindToTree).

  1950            || (aSID == eStyleStruct_Font && specified + 5 == total &&

  1951                !mPresContext->Document()->GetMathMLEnabled())

  1952           ) {

  1953     if (inherited == 0)

  1954       result = eRuleFullReset;

  1955     else

  1956       result = eRuleFullMixed;

  1957   } else if (specified == 0)

  1958     result = eRuleNone;

  1959   else if (specified == inherited)

  1960     result = eRulePartialInherited;

  1961   else if (inherited == 0)

  1962     result = eRulePartialReset;

  1963   else

  1964     result = eRulePartialMixed;

  1966   CheckCallbackFn cb = gCheckCallbacks[aSID];

  1967   if (cb) {

  1968     result = (*cb)(aRuleData, result);

  1969   }

  1971   return result;

  1972 }

  1974 // If we need to restrict which properties apply to the style context,

  1975 // return the bit to check in nsCSSProp's flags table.  Otherwise,

  1976 // return 0.

  1977 inline uint32_t

  1978 GetPseudoRestriction(nsStyleContext *aContext)

  1979 {

  1980   // This needs to match nsStyleSet::WalkRestrictionRule.

  1981   uint32_t pseudoRestriction = 0;

  1982   nsIAtom *pseudoType = aContext->GetPseudo();

  1983   if (pseudoType) {

  1984     if (pseudoType == nsCSSPseudoElements::firstLetter) {

  1985       pseudoRestriction = CSS_PROPERTY_APPLIES_TO_FIRST_LETTER;

  1986     } else if (pseudoType == nsCSSPseudoElements::firstLine) {

  1987       pseudoRestriction = CSS_PROPERTY_APPLIES_TO_FIRST_LINE;

  1988     } else if (pseudoType == nsCSSPseudoElements::mozPlaceholder) {

  1989       pseudoRestriction = CSS_PROPERTY_APPLIES_TO_PLACEHOLDER;

  1990     }

  1991   }

  1992   return pseudoRestriction;

  1993 }

  1995 static void

  1996 UnsetPropertiesWithoutFlags(const nsStyleStructID aSID,

  1997                             nsRuleData* aRuleData,

  1998                             uint32_t aFlags)

  1999 {

  2000   NS_ASSERTION(aFlags != 0, "aFlags must be nonzero");

  2002   const uint32_t *flagData = gFlagsByStruct[aSID];

  2004   // See comment in nsRuleData.h above mValueOffsets.

  2005   NS_ABORT_IF_FALSE(aRuleData->mValueOffsets[aSID] == 0,

  2006                     "we assume the value offset is zero instead of adding it");

  2007   nsCSSValue *values = aRuleData->mValueStorage;

  2009   for (size_t i = 0, i_end = nsCSSProps::PropertyCountInStruct(aSID);

  2010        i != i_end; ++i) {

  2011     if ((flagData[i] & aFlags) != aFlags)

  2012       values[i].Reset();

  2013   }

  2014 }

  2016 /**

  2017  * We allocate arrays of CSS values with alloca.  (These arrays are a

  2018  * fixed size per style struct, but we don't want to waste the

  2019  * allocation and construction/destruction costs of the big structs when

  2020  * we're handling much smaller ones.)  Since the lifetime of an alloca

  2021  * allocation is the life of the calling function, the caller must call

  2022  * alloca.  However, to ensure that constructors and destructors are

  2023  * balanced, we do the constructor and destructor calling from this RAII

  2024  * class, AutoCSSValueArray.

  2025  */

  2026 struct AutoCSSValueArray {

  2027   /**

  2028    * aStorage must be the result of alloca(aCount * sizeof(nsCSSValue))

  2029    */

  2030   AutoCSSValueArray(void* aStorage, size_t aCount) {

  2031     NS_ABORT_IF_FALSE(size_t(aStorage) % NS_ALIGNMENT_OF(nsCSSValue) == 0,

  2032                       "bad alignment from alloca");

  2033     mCount = aCount;

  2034     // Don't use placement new[], since it might store extra data

  2035     // for the count (on Windows!).

  2036     mArray = static_cast<nsCSSValue*>(aStorage);

  2037     for (size_t i = 0; i < mCount; ++i) {

  2038       new (mArray + i) nsCSSValue();

  2039     }

  2040   }

  2042   ~AutoCSSValueArray() {

  2043     for (size_t i = 0; i < mCount; ++i) {

  2044       mArray[i].~nsCSSValue();

  2045     }

  2046   }

  2048   nsCSSValue* get() { return mArray; }

  2050 private:

  2051   nsCSSValue *mArray;

  2052   size_t mCount;

  2053 };

  2055 /* static */ bool

  2056 nsRuleNode::ResolveVariableReferences(const nsStyleStructID aSID,

  2057                                       nsRuleData* aRuleData,

  2058                                       nsStyleContext* aContext)

  2059 {

  2060   MOZ_ASSERT(aSID != eStyleStruct_Variables);

  2061   MOZ_ASSERT(aRuleData->mSIDs & nsCachedStyleData::GetBitForSID(aSID));

  2062   MOZ_ASSERT(aRuleData->mValueOffsets[aSID] == 0);

  2064   nsCSSParser parser;

  2065   bool anyTokenStreams = false;

  2067   // Look at each property in the nsRuleData for the given style struct.

  2068   size_t nprops = nsCSSProps::PropertyCountInStruct(aSID);

  2069   for (nsCSSValue* value = aRuleData->mValueStorage,

  2070                   *values_end = aRuleData->mValueStorage + nprops;

  2071        value != values_end; value++) {

  2072     if (value->GetUnit() != eCSSUnit_TokenStream) {

  2073       continue;

  2074     }

  2076     const CSSVariableValues* variables =

  2077       &aContext->StyleVariables()->mVariables;

  2078     nsCSSValueTokenStream* tokenStream = value->GetTokenStreamValue();

  2080     // Note that ParsePropertyWithVariableReferences relies on the fact

  2081     // that the nsCSSValue in aRuleData for the property we are re-parsing

  2082     // is still the token stream value.  When

  2083     // ParsePropertyWithVariableReferences calls

  2084     // nsCSSExpandedDataBlock::MapRuleInfoInto, that function will add

  2085     // the ImageValue that is created into the token stream object's

  2086     // mImageValues table; see the comment above mImageValues for why.

  2088     // XXX Should pass in sheet here (see bug 952338).

  2089     parser.ParsePropertyWithVariableReferences(

  2090         tokenStream->mPropertyID, tokenStream->mShorthandPropertyID,

  2091         tokenStream->mTokenStream, variables, aRuleData,

  2092         tokenStream->mSheetURI, tokenStream->mBaseURI,

  2093         tokenStream->mSheetPrincipal, nullptr,

  2094         tokenStream->mLineNumber, tokenStream->mLineOffset);

  2095     aRuleData->mCanStoreInRuleTree = false;

  2096     anyTokenStreams = true;

  2097   }

  2099   return anyTokenStreams;

  2100 }

  2102 const void*

  2103 nsRuleNode::WalkRuleTree(const nsStyleStructID aSID,

  2104                          nsStyleContext* aContext)

  2105 {

  2106   // use placement new[] on the result of alloca() to allocate a

  2107   // variable-sized stack array, including execution of constructors,

  2108   // and use an RAII class to run the destructors too.

  2109   size_t nprops = nsCSSProps::PropertyCountInStruct(aSID);

  2110   void* dataStorage = alloca(nprops * sizeof(nsCSSValue));

  2111   AutoCSSValueArray dataArray(dataStorage, nprops);

  2113   nsRuleData ruleData(nsCachedStyleData::GetBitForSID(aSID),

  2114                       dataArray.get(), mPresContext, aContext);

  2115   ruleData.mValueOffsets[aSID] = 0;

  2117   // We start at the most specific rule in the tree.

  2118   void* startStruct = nullptr;

  2120   nsRuleNode* ruleNode = this;

  2121   nsRuleNode* highestNode = nullptr; // The highest node in the rule tree

  2122                                     // that has the same properties

  2123                                     // specified for struct |aSID| as

  2124                                     // |this| does.

  2125   nsRuleNode* rootNode = this; // After the loop below, this will be the

  2126                                // highest node that we've walked without

  2127                                // finding cached data on the rule tree.

  2128                                // If we don't find any cached data, it

  2129                                // will be the root.  (XXX misnamed)

  2130   RuleDetail detail = eRuleNone;

  2131   uint32_t bit = nsCachedStyleData::GetBitForSID(aSID);

  2133   while (ruleNode) {

  2134     // See if this rule node has cached the fact that the remaining

  2135     // nodes along this path specify no data whatsoever.

  2136     if (ruleNode->mNoneBits & bit)

  2137       break;

  2139     // If the dependent bit is set on a rule node for this struct, that

  2140     // means its rule won't have any information to add, so skip it.

  2141     // NOTE: If we exit the loop because of the !IsUsedDirectly() check,

  2142     // then we're guaranteed to break immediately afterwards due to a

  2143     // non-null startStruct.

  2144     while ((ruleNode->mDependentBits & bit) && !ruleNode->IsUsedDirectly()) {

  2145       NS_ASSERTION(ruleNode->mStyleData.GetStyleData(aSID) == nullptr,

  2146                    "dependent bit with cached data makes no sense");

  2147       // Climb up to the next rule in the tree (a less specific rule).

  2148       rootNode = ruleNode;

  2149       ruleNode = ruleNode->mParent;

  2150       NS_ASSERTION(!(ruleNode->mNoneBits & bit), "can't have both bits set");

  2151     }

  2153     // Check for cached data after the inner loop above -- otherwise

  2154     // we'll miss it.

  2155     startStruct = ruleNode->mStyleData.GetStyleData(aSID);

  2156     if (startStruct)

  2157       break; // We found a rule with fully specified data.  We don't

  2158              // need to go up the tree any further, since the remainder

  2159              // of this branch has already been computed.

  2161     // Ask the rule to fill in the properties that it specifies.

  2162     nsIStyleRule *rule = ruleNode->mRule;

  2163     if (rule) {

  2164       ruleData.mLevel = ruleNode->GetLevel();

  2165       ruleData.mIsImportantRule = ruleNode->IsImportantRule();

  2166       rule->MapRuleInfoInto(&ruleData);

  2167     }

  2169     // Now we check to see how many properties have been specified by

  2170     // the rules we've examined so far.

  2171     RuleDetail oldDetail = detail;

  2172     detail = CheckSpecifiedProperties(aSID, &ruleData);

  2174     if (oldDetail == eRuleNone && detail != eRuleNone)

  2175       highestNode = ruleNode;

  2177     if (detail == eRuleFullReset ||

  2178         detail == eRuleFullMixed ||

  2179         detail == eRuleFullInherited)

  2180       break; // We don't need to examine any more rules.  All properties

  2181              // have been fully specified.

  2183     // Climb up to the next rule in the tree (a less specific rule).

  2184     rootNode = ruleNode;

  2185     ruleNode = ruleNode->mParent;

  2186   }

  2188   bool recomputeDetail = false;

  2190   // If we are computing a style struct other than nsStyleVariables, and

  2191   // ruleData has any properties with variable references (nsCSSValues of

  2192   // type eCSSUnit_TokenStream), then we need to resolve these.

  2193   if (aSID != eStyleStruct_Variables) {

  2194     // A property's value might have became 'inherit' after resolving

  2195     // variable references.  (This happens when an inherited property

  2196     // fails to parse its resolved value.)  We need to recompute

  2197     // |detail| in case this happened.

  2198     recomputeDetail = ResolveVariableReferences(aSID, &ruleData, aContext);

  2199   }

  2201   // If needed, unset the properties that don't have a flag that allows

  2202   // them to be set for this style context.  (For example, only some

  2203   // properties apply to :first-line and :first-letter.)

  2204   uint32_t pseudoRestriction = GetPseudoRestriction(aContext);

  2205   if (pseudoRestriction) {

  2206     UnsetPropertiesWithoutFlags(aSID, &ruleData, pseudoRestriction);

  2208     // We need to recompute |detail| based on the restrictions we just applied.

  2209     // We can adjust |detail| arbitrarily because of the restriction

  2210     // rule added in nsStyleSet::WalkRestrictionRule.

  2211     recomputeDetail = true;

  2212   }

  2214   if (recomputeDetail) {

  2215     detail = CheckSpecifiedProperties(aSID, &ruleData);

  2216   }

  2218   NS_ASSERTION(!startStruct || (detail != eRuleFullReset &&

  2219                                 detail != eRuleFullMixed &&

  2220                                 detail != eRuleFullInherited),

  2221                "can't have start struct and be fully specified");

  2223   bool isReset = nsCachedStyleData::IsReset(aSID);

  2224   if (!highestNode)

  2225     highestNode = rootNode;

  2227   if (!ruleData.mCanStoreInRuleTree)

  2228     detail = eRulePartialMixed; // Treat as though some data is specified to avoid

  2229                                 // the optimizations and force data computation.

  2231   if (detail == eRuleNone && startStruct) {

  2232     // We specified absolutely no rule information, but a parent rule in the tree

  2233     // specified all the rule information.  We set a bit along the branch from our

  2234     // node in the tree to the node that specified the data that tells nodes on that

  2235     // branch that they never need to examine their rules for this particular struct type

  2236     // ever again.

  2237     PropagateDependentBit(aSID, ruleNode, startStruct);

  2238     return startStruct;

  2239   }

  2240   if ((!startStruct && !isReset &&

  2241        (detail == eRuleNone || detail == eRulePartialInherited)) ||

  2242       detail == eRuleFullInherited) {

  2243     // We specified no non-inherited information and neither did any of

  2244     // our parent rules.

  2246     // We set a bit along the branch from the highest node (ruleNode)

  2247     // down to our node (this) indicating that no non-inherited data was

  2248     // specified.  This bit is guaranteed to be set already on the path

  2249     // from the highest node to the root node in the case where

  2250     // (detail == eRuleNone), which is the most common case here.

  2251     // We must check |!isReset| because the Compute*Data functions for

  2252     // reset structs wouldn't handle none bits correctly.

  2253     if (highestNode != this && !isReset)

  2254       PropagateNoneBit(bit, highestNode);

  2256     // All information must necessarily be inherited from our parent style context.

  2257     // In the absence of any computed data in the rule tree and with

  2258     // no rules specified that didn't have values of 'inherit', we should check our parent.

  2259     nsStyleContext* parentContext = aContext->GetParent();

  2260     if (isReset) {

  2261       /* Reset structs don't inherit from first-line. */

  2262       /* See similar code in COMPUTE_START_RESET */

  2263       while (parentContext &&

  2264              parentContext->GetPseudo() == nsCSSPseudoElements::firstLine) {

  2265         parentContext = parentContext->GetParent();

  2266       }

  2267     }

  2268     if (parentContext) {

  2269       // We have a parent, and so we should just inherit from the parent.

  2270       // Set the inherit bits on our context.  These bits tell the style context that

  2271       // it never has to go back to the rule tree for data.  Instead the style context tree

  2272       // should be walked to find the data.

  2273       const void* parentStruct = parentContext->StyleData(aSID);

  2274       aContext->AddStyleBit(bit); // makes const_cast OK.

  2275       aContext->SetStyle(aSID, const_cast<void*>(parentStruct));

  2276       return parentStruct;

  2277     }

  2278     else

  2279       // We are the root.  In the case of fonts, the default values just

  2280       // come from the pres context.

  2281       return SetDefaultOnRoot(aSID, aContext);

  2282   }

  2284   // We need to compute the data from the information that the rules specified.

  2285   const void* res;

  2286 #define STYLE_STRUCT_TEST aSID

  2287 #define STYLE_STRUCT(name, checkdata_cb)                                      \

  2288   res = Compute##name##Data(startStruct, &ruleData, aContext,                 \

  2289                             highestNode, detail, ruleData.mCanStoreInRuleTree);

  2290 #include "nsStyleStructList.h"

  2291 #undef STYLE_STRUCT

  2292 #undef STYLE_STRUCT_TEST

  2294   // Now return the result.

  2295   return res;

  2296 }

  2298 const void*

  2299 nsRuleNode::SetDefaultOnRoot(const nsStyleStructID aSID, nsStyleContext* aContext)

  2300 {

  2301   switch (aSID) {

  2302     case eStyleStruct_Font:

  2303     {

  2304       nsStyleFont* fontData = new (mPresContext) nsStyleFont(mPresContext);

  2305       nscoord minimumFontSize = mPresContext->MinFontSize(fontData->mLanguage);

  2307       if (minimumFontSize > 0 && !mPresContext->IsChrome()) {

  2308         fontData->mFont.size = std::max(fontData->mSize, minimumFontSize);

  2309       }

  2310       else {

  2311         fontData->mFont.size = fontData->mSize;

  2312       }

  2313       aContext->SetStyle(eStyleStruct_Font, fontData);

  2314       return fontData;

  2315     }

  2316     case eStyleStruct_Display:

  2317     {

  2318       nsStyleDisplay* disp = new (mPresContext) nsStyleDisplay();

  2319       aContext->SetStyle(eStyleStruct_Display, disp);

  2320       return disp;

  2321     }

  2322     case eStyleStruct_Visibility:

  2323     {

  2324       nsStyleVisibility* vis = new (mPresContext) nsStyleVisibility(mPresContext);

  2325       aContext->SetStyle(eStyleStruct_Visibility, vis);

  2326       return vis;

  2327     }

  2328     case eStyleStruct_Text:

  2329     {

  2330       nsStyleText* text = new (mPresContext) nsStyleText();

  2331       aContext->SetStyle(eStyleStruct_Text, text);

  2332       return text;

  2333     }

  2334     case eStyleStruct_TextReset:

  2335     {

  2336       nsStyleTextReset* text = new (mPresContext) nsStyleTextReset();

  2337       aContext->SetStyle(eStyleStruct_TextReset, text);

  2338       return text;

  2339     }

  2340     case eStyleStruct_Color:

  2341     {

  2342       nsStyleColor* color = new (mPresContext) nsStyleColor(mPresContext);

  2343       aContext->SetStyle(eStyleStruct_Color, color);

  2344       return color;

  2345     }

  2346     case eStyleStruct_Background:

  2347     {

  2348       nsStyleBackground* bg = new (mPresContext) nsStyleBackground();

  2349       aContext->SetStyle(eStyleStruct_Background, bg);

  2350       return bg;

  2351     }

  2352     case eStyleStruct_Margin:

  2353     {

  2354       nsStyleMargin* margin = new (mPresContext) nsStyleMargin();

  2355       aContext->SetStyle(eStyleStruct_Margin, margin);

  2356       return margin;

  2357     }

  2358     case eStyleStruct_Border:

  2359     {

  2360       nsStyleBorder* border = new (mPresContext) nsStyleBorder(mPresContext);

  2361       aContext->SetStyle(eStyleStruct_Border, border);

  2362       return border;

  2363     }

  2364     case eStyleStruct_Padding:

  2365     {

  2366       nsStylePadding* padding = new (mPresContext) nsStylePadding();

  2367       aContext->SetStyle(eStyleStruct_Padding, padding);

  2368       return padding;

  2369     }

  2370     case eStyleStruct_Outline:

  2371     {

  2372       nsStyleOutline* outline = new (mPresContext) nsStyleOutline(mPresContext);

  2373       aContext->SetStyle(eStyleStruct_Outline, outline);

  2374       return outline;

  2375     }

  2376     case eStyleStruct_List:

  2377     {

  2378       nsStyleList* list = new (mPresContext) nsStyleList();

  2379       aContext->SetStyle(eStyleStruct_List, list);

  2380       return list;

  2381     }

  2382     case eStyleStruct_Position:

  2383     {

  2384       nsStylePosition* pos = new (mPresContext) nsStylePosition();

  2385       aContext->SetStyle(eStyleStruct_Position, pos);

  2386       return pos;

  2387     }

  2388     case eStyleStruct_Table:

  2389     {

  2390       nsStyleTable* table = new (mPresContext) nsStyleTable();

  2391       aContext->SetStyle(eStyleStruct_Table, table);

  2392       return table;

  2393     }

  2394     case eStyleStruct_TableBorder:

  2395     {

  2396       nsStyleTableBorder* table = new (mPresContext) nsStyleTableBorder(mPresContext);

  2397       aContext->SetStyle(eStyleStruct_TableBorder, table);

  2398       return table;

  2399     }

  2400     case eStyleStruct_Content:

  2401     {

  2402       nsStyleContent* content = new (mPresContext) nsStyleContent();

  2403       aContext->SetStyle(eStyleStruct_Content, content);

  2404       return content;

  2405     }

  2406     case eStyleStruct_Quotes:

  2407     {

  2408       nsStyleQuotes* quotes = new (mPresContext) nsStyleQuotes();

  2409       aContext->SetStyle(eStyleStruct_Quotes, quotes);

  2410       return quotes;

  2411     }

  2412     case eStyleStruct_UserInterface:

  2413     {

  2414       nsStyleUserInterface* ui = new (mPresContext) nsStyleUserInterface();

  2415       aContext->SetStyle(eStyleStruct_UserInterface, ui);

  2416       return ui;

  2417     }

  2418     case eStyleStruct_UIReset:

  2419     {

  2420       nsStyleUIReset* ui = new (mPresContext) nsStyleUIReset();

  2421       aContext->SetStyle(eStyleStruct_UIReset, ui);

  2422       return ui;

  2423     }

  2424     case eStyleStruct_XUL:

  2425     {

  2426       nsStyleXUL* xul = new (mPresContext) nsStyleXUL();

  2427       aContext->SetStyle(eStyleStruct_XUL, xul);

  2428       return xul;

  2429     }

  2430     case eStyleStruct_Column:

  2431     {

  2432       nsStyleColumn* column = new (mPresContext) nsStyleColumn(mPresContext);

  2433       aContext->SetStyle(eStyleStruct_Column, column);

  2434       return column;

  2435     }

  2436     case eStyleStruct_SVG:

  2437     {

  2438       nsStyleSVG* svg = new (mPresContext) nsStyleSVG();

  2439       aContext->SetStyle(eStyleStruct_SVG, svg);

  2440       return svg;

  2441     }

  2442     case eStyleStruct_SVGReset:

  2443     {

  2444       nsStyleSVGReset* svgReset = new (mPresContext) nsStyleSVGReset();

  2445       aContext->SetStyle(eStyleStruct_SVGReset, svgReset);

  2446       return svgReset;

  2447     }

  2448     case eStyleStruct_Variables:

  2449     {

  2450       nsStyleVariables* vars = new (mPresContext) nsStyleVariables();

  2451       aContext->SetStyle(eStyleStruct_Variables, vars);

  2452       return vars;

  2453     }

  2454     default:

  2455       /*

  2456        * unhandled case: nsStyleStructID_Length.

  2457        * last item of nsStyleStructID, to know its length.

  2458        */

  2459       NS_ABORT_IF_FALSE(false, "unexpected SID");

  2460       return nullptr;

  2461   }

  2462   return nullptr;

  2463 }

  2465 /*

  2466  * This function handles cascading of *-left or *-right box properties

  2467  * against *-start (which is L for LTR and R for RTL) or *-end (which is

  2468  * R for LTR and L for RTL).

  2469  *

  2470  * Cascading these properties correctly is hard because we need to

  2471  * cascade two properties as one, but which two properties depends on a

  2472  * third property ('direction').  We solve this by treating each of

  2473  * these properties (say, 'margin-start') as a shorthand that sets a

  2474  * property containing the value of the property specified

  2475  * ('margin-start-value') and sets a pair of properties

  2476  * ('margin-left-ltr-source' and 'margin-right-rtl-source') saying which

  2477  * of the properties we use.  Thus, when we want to compute the value of

  2478  * 'margin-left' when 'direction' is 'ltr', we look at the value of

  2479  * 'margin-left-ltr-source', which tells us whether to use the highest

  2480  * 'margin-left' in the cascade or the highest 'margin-start'.

  2481  *

  2482  * Finally, since we can compute the normal (*-left and *-right)

  2483  * properties in a loop, this function works by modifying the data we

  2484  * will use in that loop (which the caller must copy from the const

  2485  * input).

  2486  */

  2487 void

  2488 nsRuleNode::AdjustLogicalBoxProp(nsStyleContext* aContext,

  2489                                  const nsCSSValue& aLTRSource,

  2490                                  const nsCSSValue& aRTLSource,

  2491                                  const nsCSSValue& aLTRLogicalValue,

  2492                                  const nsCSSValue& aRTLLogicalValue,

  2493                                  mozilla::css::Side aSide,

  2494                                  nsCSSRect& aValueRect,

  2495                                  bool& aCanStoreInRuleTree)

  2496 {

  2497   bool LTRlogical = aLTRSource.GetUnit() == eCSSUnit_Enumerated &&

  2498                       aLTRSource.GetIntValue() == NS_BOXPROP_SOURCE_LOGICAL;

  2499   bool RTLlogical = aRTLSource.GetUnit() == eCSSUnit_Enumerated &&

  2500                       aRTLSource.GetIntValue() == NS_BOXPROP_SOURCE_LOGICAL;

  2501   if (LTRlogical || RTLlogical) {

  2502     // We can't cache anything on the rule tree if we use any data from

  2503     // the style context, since data cached in the rule tree could be

  2504     // used with a style context with a different value.

  2505     aCanStoreInRuleTree = false;

  2506     uint8_t dir = aContext->StyleVisibility()->mDirection;

  2508     if (dir == NS_STYLE_DIRECTION_LTR) {

  2509       if (LTRlogical)

  2510         aValueRect.*(nsCSSRect::sides[aSide]) = aLTRLogicalValue;

  2511     } else {

  2512       if (RTLlogical)

  2513         aValueRect.*(nsCSSRect::sides[aSide]) = aRTLLogicalValue;

  2514     }

  2515   } else if (aLTRLogicalValue.GetUnit() == eCSSUnit_Inherit ||

  2516              aRTLLogicalValue.GetUnit() == eCSSUnit_Inherit) {

  2517     // It actually is valid to store this in the ruletree, since

  2518     // LTRlogical and RTLlogical are both false, but doing that will

  2519     // trigger asserts.  Silence those.

  2520     aCanStoreInRuleTree = false;

  2521   }

  2522 }

  2524 /**

  2525  * Begin an nsRuleNode::Compute*Data function for an inherited struct.

  2526  *

  2527  * @param type_ The nsStyle* type this function computes.

  2528  * @param ctorargs_ The arguments used for the default nsStyle* constructor.

  2529  * @param data_ Variable (declared here) holding the result of this

  2530  *              function.

  2531  * @param parentdata_ Variable (declared here) holding the parent style

  2532  *                    context's data for this struct.

  2533  */

  2534 #define COMPUTE_START_INHERITED(type_, ctorargs_, data_, parentdata_)         \

  2535   NS_ASSERTION(aRuleDetail != eRuleFullInherited,                             \

  2536                "should not have bothered calling Compute*Data");              \

  2537                                                                               \

  2538   nsStyleContext* parentContext = aContext->GetParent();                      \

  2539                                                                               \

  2540   nsStyle##type_* data_ = nullptr;                                            \

  2541   mozilla::Maybe<nsStyle##type_> maybeFakeParentData;                         \

  2542   const nsStyle##type_* parentdata_ = nullptr;                                \

  2543   bool canStoreInRuleTree = aCanStoreInRuleTree;                              \

  2544                                                                               \

  2545   /* If |canStoreInRuleTree| might be true by the time we're done, we */      \

  2546   /* can't call parentContext->Style##type_() since it could recur into */    \

  2547   /* setting the same struct on the same rule node, causing a leak. */        \

  2548   if (aRuleDetail != eRuleFullReset &&                                        \

  2549       (!aStartStruct || (aRuleDetail != eRulePartialReset &&                  \

  2550                          aRuleDetail != eRuleNone))) {                        \

  2551     if (parentContext) {                                                      \

  2552       parentdata_ = parentContext->Style##type_();                            \

  2553     } else {                                                                  \

  2554       maybeFakeParentData.construct ctorargs_;                                \

  2555       parentdata_ = maybeFakeParentData.addr();                               \

  2556     }                                                                         \

  2557   }                                                                           \

  2558   if (aStartStruct)                                                           \

  2559     /* We only need to compute the delta between this computed data and */    \

  2560     /* our computed data. */                                                  \

  2561     data_ = new (mPresContext)                                                \

  2562             nsStyle##type_(*static_cast<nsStyle##type_*>(aStartStruct));      \

  2563   else {                                                                      \

  2564     if (aRuleDetail != eRuleFullMixed && aRuleDetail != eRuleFullReset) {     \

  2565       /* No question. We will have to inherit. Go ahead and init */           \

  2566       /* with inherited vals from parent. */                                  \

  2567       canStoreInRuleTree = false;                                          \

  2568       if (parentdata_)                                                        \

  2569         data_ = new (mPresContext) nsStyle##type_(*parentdata_);              \

  2570       else                                                                    \

  2571         data_ = new (mPresContext) nsStyle##type_ ctorargs_;                  \

  2572     }                                                                         \

  2573     else                                                                      \

  2574       data_ = new (mPresContext) nsStyle##type_ ctorargs_;                    \

  2575   }                                                                           \

  2576                                                                               \

  2577   if (!parentdata_)                                                           \

  2578     parentdata_ = data_;

  2580 /**

  2581  * Begin an nsRuleNode::Compute*Data function for a reset struct.

  2582  *

  2583  * @param type_ The nsStyle* type this function computes.

  2584  * @param ctorargs_ The arguments used for the default nsStyle* constructor.

  2585  * @param data_ Variable (declared here) holding the result of this

  2586  *              function.

  2587  * @param parentdata_ Variable (declared here) holding the parent style

  2588  *                    context's data for this struct.

  2589  */

  2590 #define COMPUTE_START_RESET(type_, ctorargs_, data_, parentdata_)             \

  2591   NS_ASSERTION(aRuleDetail != eRuleFullInherited,                             \

  2592                "should not have bothered calling Compute*Data");              \

  2593                                                                               \

  2594   nsStyleContext* parentContext = aContext->GetParent();                      \

  2595   /* Reset structs don't inherit from first-line */                           \

  2596   /* See similar code in WalkRuleTree */                                      \

  2597   while (parentContext &&                                                     \

  2598          parentContext->GetPseudo() == nsCSSPseudoElements::firstLine) {      \

  2599     parentContext = parentContext->GetParent();                               \

  2600   }                                                                           \

  2601                                                                               \

  2602   nsStyle##type_* data_;                                                      \

  2603   if (aStartStruct)                                                           \

  2604     /* We only need to compute the delta between this computed data and */    \

  2605     /* our computed data. */                                                  \

  2606     data_ = new (mPresContext)                                                \

  2607             nsStyle##type_(*static_cast<nsStyle##type_*>(aStartStruct));      \

  2608   else                                                                        \

  2609     data_ = new (mPresContext) nsStyle##type_ ctorargs_;                      \

  2610                                                                               \

  2611   /* If |canStoreInRuleTree| might be true by the time we're done, we */      \

  2612   /* can't call parentContext->Style##type_() since it could recur into */    \

  2613   /* setting the same struct on the same rule node, causing a leak. */        \

  2614   mozilla::Maybe<nsStyle##type_> maybeFakeParentData;                         \

  2615   const nsStyle##type_* parentdata_ = data_;                                  \

  2616   if (aRuleDetail != eRuleFullReset &&                                        \

  2617       aRuleDetail != eRulePartialReset &&                                     \

  2618       aRuleDetail != eRuleNone) {                                             \

  2619     if (parentContext) {                                                      \

  2620       parentdata_ = parentContext->Style##type_();                            \

  2621     } else {                                                                  \

  2622       maybeFakeParentData.construct ctorargs_;                                \

  2623       parentdata_ = maybeFakeParentData.addr();                               \

  2624     }                                                                         \

  2625   }                                                                           \

  2626   bool canStoreInRuleTree = aCanStoreInRuleTree;

  2628 /**

  2629  * End an nsRuleNode::Compute*Data function for an inherited struct.

  2630  *

  2631  * @param type_ The nsStyle* type this function computes.

  2632  * @param data_ Variable holding the result of this function.

  2633  */

  2634 #define COMPUTE_END_INHERITED(type_, data_)                                   \

  2635   NS_POSTCONDITION(!canStoreInRuleTree || aRuleDetail == eRuleFullReset ||    \

  2636                    (aStartStruct && aRuleDetail == eRulePartialReset),        \

  2637                    "canStoreInRuleTree must be false for inherited structs "  \

  2638                    "unless all properties have been specified with values "   \

  2639                    "other than inherit");                                     \

  2640   if (canStoreInRuleTree) {                                                   \

  2641     /* We were fully specified and can therefore be cached right on the */    \

  2642     /* rule node. */                                                          \

  2643     if (!aHighestNode->mStyleData.mInheritedData) {                           \

  2644       aHighestNode->mStyleData.mInheritedData =                               \

  2645         new (mPresContext) nsInheritedStyleData;                              \

  2646     }                                                                         \

  2647     NS_ASSERTION(!aHighestNode->mStyleData.mInheritedData->                   \

  2648                    mStyleStructs[eStyleStruct_##type_],                       \

  2649                  "Going to leak style data");                                 \

  2650     aHighestNode->mStyleData.mInheritedData->                                 \

  2651       mStyleStructs[eStyleStruct_##type_] = data_;                            \

  2652     /* Propagate the bit down. */                                             \

  2653     PropagateDependentBit(eStyleStruct_##type_, aHighestNode, data_);         \

  2654     /* Tell the style context that it doesn't own the data */                 \

  2655     aContext->                                                                \

  2656       AddStyleBit(nsCachedStyleData::GetBitForSID(eStyleStruct_##type_));     \

  2657   }                                                                           \

  2658   /* Always cache inherited data on the style context */                      \

  2659   aContext->SetStyle##type_(data_);                                           \

  2660                                                                               \

  2661   return data_;

  2663 /**

  2664  * End an nsRuleNode::Compute*Data function for a reset struct.

  2665  *

  2666  * @param type_ The nsStyle* type this function computes.

  2667  * @param data_ Variable holding the result of this function.

  2668  */

  2669 #define COMPUTE_END_RESET(type_, data_)                                       \

  2670   NS_POSTCONDITION(!canStoreInRuleTree ||                                     \

  2671                    aRuleDetail == eRuleNone ||                                \

  2672                    aRuleDetail == eRulePartialReset ||                        \

  2673                    aRuleDetail == eRuleFullReset,                             \

  2674                    "canStoreInRuleTree must be false for reset structs "      \

  2675                    "if any properties were specified as inherit");            \

  2676   if (!canStoreInRuleTree)                                                    \

  2677     /* We can't be cached in the rule node.  We have to be put right */       \

  2678     /* on the style context. */                                               \

  2679     aContext->SetStyle(eStyleStruct_##type_, data_);                          \

  2680   else {                                                                      \

  2681     /* We were fully specified and can therefore be cached right on the */    \

  2682     /* rule node. */                                                          \

  2683     if (!aHighestNode->mStyleData.mResetData) {                               \

  2684       aHighestNode->mStyleData.mResetData =                                   \

  2685         new (mPresContext) nsResetStyleData;                                  \

  2686     }                                                                         \

  2687     NS_ASSERTION(!aHighestNode->mStyleData.mResetData->                       \

  2688                    mStyleStructs[eStyleStruct_##type_],                       \

  2689                  "Going to leak style data");                                 \

  2690     aHighestNode->mStyleData.mResetData->                                     \

  2691       mStyleStructs[eStyleStruct_##type_] = data_;                            \

  2692     /* Propagate the bit down. */                                             \

  2693     PropagateDependentBit(eStyleStruct_##type_, aHighestNode, data_);         \

  2694   }                                                                           \

  2695                                                                               \

  2696   return data_;

  2698 // This function figures out how much scaling should be suppressed to

  2699 // satisfy scriptminsize. This is our attempt to implement

  2700 // http://www.w3.org/TR/MathML2/chapter3.html#id.3.3.4.2.2

  2701 // This is called after mScriptLevel, mScriptMinSize and mScriptSizeMultiplier

  2702 // have been set in aFont.

  2703 //

  2704 // Here are the invariants we enforce:

  2705 // 1) A decrease in size must not reduce the size below minscriptsize.

  2706 // 2) An increase in size must not increase the size above the size we would

  2707 // have if minscriptsize had not been applied anywhere.

  2708 // 3) The scriptlevel-induced size change must between 1.0 and the parent's

  2709 // scriptsizemultiplier^(new script level - old script level), as close to the

  2710 // latter as possible subject to constraints 1 and 2.

  2711 static nscoord

  2712 ComputeScriptLevelSize(const nsStyleFont* aFont, const nsStyleFont* aParentFont,

  2713                        nsPresContext* aPresContext, nscoord* aUnconstrainedSize)

  2714 {

  2715   int32_t scriptLevelChange =

  2716     aFont->mScriptLevel - aParentFont->mScriptLevel;

  2717   if (scriptLevelChange == 0) {

  2718     *aUnconstrainedSize = aParentFont->mScriptUnconstrainedSize;

  2719     // Constraint #3 says that we cannot change size, and #1 and #2 are always

  2720     // satisfied with no change. It's important this be fast because it covers

  2721     // all non-MathML content.

  2722     return aParentFont->mSize;

  2723   }

  2725   // Compute actual value of minScriptSize

  2726   nscoord minScriptSize = aParentFont->mScriptMinSize;

  2727   if (aFont->mAllowZoom) {

  2728     minScriptSize = nsStyleFont::ZoomText(aPresContext, minScriptSize);

  2729   }

  2731   double scriptLevelScale =

  2732     pow(aParentFont->mScriptSizeMultiplier, scriptLevelChange);

  2733   // Compute the size we would have had if minscriptsize had never been

  2734   // applied, also prevent overflow (bug 413274)

  2735   *aUnconstrainedSize =

  2736     NSToCoordRound(std::min(aParentFont->mScriptUnconstrainedSize*scriptLevelScale,

  2737                           double(nscoord_MAX)));

  2738   // Compute the size we could get via scriptlevel change

  2739   nscoord scriptLevelSize =

  2740     NSToCoordRound(std::min(aParentFont->mSize*scriptLevelScale,

  2741                           double(nscoord_MAX)));

  2742   if (scriptLevelScale <= 1.0) {

  2743     if (aParentFont->mSize <= minScriptSize) {

  2744       // We can't decrease the font size at all, so just stick to no change

  2745       // (authors are allowed to explicitly set the font size smaller than

  2746       // minscriptsize)

  2747       return aParentFont->mSize;

  2748     }

  2749     // We can decrease, so apply constraint #1

  2750     return std::max(minScriptSize, scriptLevelSize);

  2751   } else {

  2752     // scriptminsize can only make sizes larger than the unconstrained size

  2753     NS_ASSERTION(*aUnconstrainedSize <= scriptLevelSize, "How can this ever happen?");

  2754     // Apply constraint #2

  2755     return std::min(scriptLevelSize, std::max(*aUnconstrainedSize, minScriptSize));

  2756   }

  2757 }

  2760 /* static */ nscoord

  2761 nsRuleNode::CalcFontPointSize(int32_t aHTMLSize, int32_t aBasePointSize,

  2762                               nsPresContext* aPresContext,

  2763                               nsFontSizeType aFontSizeType)

  2764 {

  2765 #define sFontSizeTableMin  9

  2766 #define sFontSizeTableMax 16

  2768 // This table seems to be the one used by MacIE5. We hope its adoption in Mozilla

  2769 // and eventually in WinIE5.5 will help to establish a standard rendering across

  2770 // platforms and browsers. For now, it is used only in Strict mode. More can be read

  2771 // in the document written by Todd Farhner at:

  2772 // http://style.verso.com/font_size_intervals/altintervals.html

  2773 //

  2774   static int32_t sStrictFontSizeTable[sFontSizeTableMax - sFontSizeTableMin + 1][8] =

  2775   {

  2776       { 9,    9,     9,     9,    11,    14,    18,    27},

  2777       { 9,    9,     9,    10,    12,    15,    20,    30},

  2778       { 9,    9,    10,    11,    13,    17,    22,    33},

  2779       { 9,    9,    10,    12,    14,    18,    24,    36},

  2780       { 9,   10,    12,    13,    16,    20,    26,    39},

  2781       { 9,   10,    12,    14,    17,    21,    28,    42},

  2782       { 9,   10,    13,    15,    18,    23,    30,    45},

  2783       { 9,   10,    13,    16,    18,    24,    32,    48}

  2784   };

  2785 // HTML       1      2      3      4      5      6      7

  2786 // CSS  xxs   xs     s      m      l     xl     xxl

  2787 //                          |

  2788 //                      user pref

  2789 //

  2790 //------------------------------------------------------------

  2791 //

  2792 // This table gives us compatibility with WinNav4 for the default fonts only.

  2793 // In WinNav4, the default fonts were:

  2794 //

  2795 //     Times/12pt ==   Times/16px at 96ppi

  2796 //   Courier/10pt == Courier/13px at 96ppi

  2797 //

  2798 // The 2 lines below marked "anchored" have the exact pixel sizes used by

  2799 // WinNav4 for Times/12pt and Courier/10pt at 96ppi. As you can see, the

  2800 // HTML size 3 (user pref) for those 2 anchored lines is 13px and 16px.

  2801 //

  2802 // All values other than the anchored values were filled in by hand, never

  2803 // going below 9px, and maintaining a "diagonal" relationship. See for

  2804 // example the 13s -- they follow a diagonal line through the table.

  2805 //

  2806   static int32_t sQuirksFontSizeTable[sFontSizeTableMax - sFontSizeTableMin + 1][8] =

  2807   {

  2808       { 9,    9,     9,     9,    11,    14,    18,    28 },

  2809       { 9,    9,     9,    10,    12,    15,    20,    31 },

  2810       { 9,    9,     9,    11,    13,    17,    22,    34 },

  2811       { 9,    9,    10,    12,    14,    18,    24,    37 },

  2812       { 9,    9,    10,    13,    16,    20,    26,    40 }, // anchored (13)

  2813       { 9,    9,    11,    14,    17,    21,    28,    42 },

  2814       { 9,   10,    12,    15,    17,    23,    30,    45 },

  2815       { 9,   10,    13,    16,    18,    24,    32,    48 }  // anchored (16)

  2816   };

  2817 // HTML       1      2      3      4      5      6      7

  2818 // CSS  xxs   xs     s      m      l     xl     xxl

  2819 //                          |

  2820 //                      user pref

  2822 #if 0

  2823 //

  2824 // These are the exact pixel values used by WinIE5 at 96ppi.

  2825 //

  2826       { ?,    8,    11,    12,    13,    16,    21,    32 }, // smallest

  2827       { ?,    9,    12,    13,    16,    21,    27,    40 }, // smaller

  2828       { ?,   10,    13,    16,    18,    24,    32,    48 }, // medium

  2829       { ?,   13,    16,    19,    21,    27,    37,    ?? }, // larger

  2830       { ?,   16,    19,    21,    24,    32,    43,    ?? }  // largest

  2831 //

  2832 // HTML       1      2      3      4      5      6      7

  2833 // CSS  ?     ?      ?      ?      ?      ?      ?      ?

  2834 //

  2835 // (CSS not tested yet.)

  2836 //

  2837 #endif

  2839   static int32_t sFontSizeFactors[8] = { 60,75,89,100,120,150,200,300 };

  2841   static int32_t sCSSColumns[7]  = {0, 1, 2, 3, 4, 5, 6}; // xxs...xxl

  2842   static int32_t sHTMLColumns[7] = {1, 2, 3, 4, 5, 6, 7}; // 1...7

  2844   double dFontSize;

  2846   if (aFontSizeType == eFontSize_HTML) {

  2847     aHTMLSize--;    // input as 1-7

  2848   }

  2850   if (aHTMLSize < 0)

  2851     aHTMLSize = 0;

  2852   else if (aHTMLSize > 6)

  2853     aHTMLSize = 6;

  2855   int32_t* column;

  2856   switch (aFontSizeType)

  2857   {

  2858     case eFontSize_HTML: column = sHTMLColumns; break;

  2859     case eFontSize_CSS:  column = sCSSColumns;  break;

  2860   }

  2862   // Make special call specifically for fonts (needed PrintPreview)

  2863   int32_t fontSize = nsPresContext::AppUnitsToIntCSSPixels(aBasePointSize);

  2865   if ((fontSize >= sFontSizeTableMin) && (fontSize <= sFontSizeTableMax))

  2866   {

  2867     int32_t row = fontSize - sFontSizeTableMin;

  2869     if (aPresContext->CompatibilityMode() == eCompatibility_NavQuirks) {

  2870       dFontSize = nsPresContext::CSSPixelsToAppUnits(sQuirksFontSizeTable[row][column[aHTMLSize]]);

  2871     } else {

  2872       dFontSize = nsPresContext::CSSPixelsToAppUnits(sStrictFontSizeTable[row][column[aHTMLSize]]);

  2873     }

  2874   }

  2875   else

  2876   {

  2877     int32_t factor = sFontSizeFactors[column[aHTMLSize]];

  2878     dFontSize = (factor * aBasePointSize) / 100;

  2879   }

  2882   if (1.0 < dFontSize) {

  2883     return (nscoord)dFontSize;

  2884   }

  2885   return (nscoord)1;

  2886 }

  2889 //------------------------------------------------------------------------------

  2890 //

  2891 //------------------------------------------------------------------------------

  2893 /* static */ nscoord

  2894 nsRuleNode::FindNextSmallerFontSize(nscoord aFontSize, int32_t aBasePointSize,

  2895                                     nsPresContext* aPresContext,

  2896                                     nsFontSizeType aFontSizeType)

  2897 {

  2898   int32_t index;

  2899   int32_t indexMin;

  2900   int32_t indexMax;

  2901   float relativePosition;

  2902   nscoord smallerSize;

  2903   nscoord indexFontSize = aFontSize; // XXX initialize to quell a spurious gcc3.2 warning

  2904   nscoord smallestIndexFontSize;

  2905   nscoord largestIndexFontSize;

  2906   nscoord smallerIndexFontSize;

  2907   nscoord largerIndexFontSize;

  2909   nscoord onePx = nsPresContext::CSSPixelsToAppUnits(1);

  2911   if (aFontSizeType == eFontSize_HTML) {

  2912     indexMin = 1;

  2913     indexMax = 7;

  2914   } else {

  2915     indexMin = 0;

  2916     indexMax = 6;

  2917   }

  2919   smallestIndexFontSize = CalcFontPointSize(indexMin, aBasePointSize, aPresContext, aFontSizeType);

  2920   largestIndexFontSize = CalcFontPointSize(indexMax, aBasePointSize, aPresContext, aFontSizeType);

  2921   if (aFontSize > smallestIndexFontSize) {

  2922     if (aFontSize < NSToCoordRound(float(largestIndexFontSize) * 1.5)) { // smaller will be in HTML table

  2923       // find largest index smaller than current

  2924       for (index = indexMax; index >= indexMin; index--) {

  2925         indexFontSize = CalcFontPointSize(index, aBasePointSize, aPresContext, aFontSizeType);

  2926         if (indexFontSize < aFontSize)

  2927           break;

  2928       }

  2929       // set up points beyond table for interpolation purposes

  2930       if (indexFontSize == smallestIndexFontSize) {

  2931         smallerIndexFontSize = indexFontSize - onePx;

  2932         largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType);

  2933       } else if (indexFontSize == largestIndexFontSize) {

  2934         smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType);

  2935         largerIndexFontSize = NSToCoordRound(float(largestIndexFontSize) * 1.5);

  2936       } else {

  2937         smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType);

  2938         largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType);

  2939       }

  2940       // compute the relative position of the parent size between the two closest indexed sizes

  2941       relativePosition = float(aFontSize - indexFontSize) / float(largerIndexFontSize - indexFontSize);

  2942       // set the new size to have the same relative position between the next smallest two indexed sizes

  2943       smallerSize = smallerIndexFontSize + NSToCoordRound(relativePosition * (indexFontSize - smallerIndexFontSize));

  2944     }

  2945     else {  // larger than HTML table, drop by 33%

  2946       smallerSize = NSToCoordRound(float(aFontSize) / 1.5);

  2947     }

  2948   }

  2949   else { // smaller than HTML table, drop by 1px

  2950     smallerSize = std::max(aFontSize - onePx, onePx);

  2951   }

  2952   return smallerSize;

  2953 }

  2955 //------------------------------------------------------------------------------

  2956 //

  2957 //------------------------------------------------------------------------------

  2959 /* static */ nscoord

  2960 nsRuleNode::FindNextLargerFontSize(nscoord aFontSize, int32_t aBasePointSize,

  2961                                    nsPresContext* aPresContext,

  2962                                    nsFontSizeType aFontSizeType)

  2963 {

  2964   int32_t index;

  2965   int32_t indexMin;

  2966   int32_t indexMax;

  2967   float relativePosition;

  2968   nscoord adjustment;

  2969   nscoord largerSize;

  2970   nscoord indexFontSize = aFontSize; // XXX initialize to quell a spurious gcc3.2 warning

  2971   nscoord smallestIndexFontSize;

  2972   nscoord largestIndexFontSize;

  2973   nscoord smallerIndexFontSize;

  2974   nscoord largerIndexFontSize;

  2976   nscoord onePx = nsPresContext::CSSPixelsToAppUnits(1);

  2978   if (aFontSizeType == eFontSize_HTML) {

  2979     indexMin = 1;

  2980     indexMax = 7;

  2981   } else {

  2982     indexMin = 0;

  2983     indexMax = 6;

  2984   }

  2986   smallestIndexFontSize = CalcFontPointSize(indexMin, aBasePointSize, aPresContext, aFontSizeType);

  2987   largestIndexFontSize = CalcFontPointSize(indexMax, aBasePointSize, aPresContext, aFontSizeType);

  2988   if (aFontSize > (smallestIndexFontSize - onePx)) {

  2989     if (aFontSize < largestIndexFontSize) { // larger will be in HTML table

  2990       // find smallest index larger than current

  2991       for (index = indexMin; index <= indexMax; index++) {

  2992         indexFontSize = CalcFontPointSize(index, aBasePointSize, aPresContext, aFontSizeType);

  2993         if (indexFontSize > aFontSize)

  2994           break;

  2995       }

  2996       // set up points beyond table for interpolation purposes

  2997       if (indexFontSize == smallestIndexFontSize) {

  2998         smallerIndexFontSize = indexFontSize - onePx;

  2999         largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType);

  3000       } else if (indexFontSize == largestIndexFontSize) {

  3001         smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType);

  3002         largerIndexFontSize = NSCoordSaturatingMultiply(largestIndexFontSize, 1.5);

  3003       } else {

  3004         smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType);

  3005         largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType);

  3006       }

  3007       // compute the relative position of the parent size between the two closest indexed sizes

  3008       relativePosition = float(aFontSize - smallerIndexFontSize) / float(indexFontSize - smallerIndexFontSize);

  3009       // set the new size to have the same relative position between the next largest two indexed sizes

  3010       adjustment = NSCoordSaturatingNonnegativeMultiply(largerIndexFontSize - indexFontSize, relativePosition);

  3011       largerSize = NSCoordSaturatingAdd(indexFontSize, adjustment);

  3012     }

  3013     else {  // larger than HTML table, increase by 50%

  3014       largerSize = NSCoordSaturatingMultiply(aFontSize, 1.5);

  3015     }

  3016   }

  3017   else { // smaller than HTML table, increase by 1px

  3018     largerSize = NSCoordSaturatingAdd(aFontSize, onePx);

  3019   }

  3020   return largerSize;

  3021 }

  3023 struct SetFontSizeCalcOps : public css::BasicCoordCalcOps,

  3024                             public css::NumbersAlreadyNormalizedOps

  3025 {

  3026   // The parameters beyond aValue that we need for CalcLengthWith.

  3027   const nscoord mParentSize;

  3028   const nsStyleFont* const mParentFont;

  3029   nsPresContext* const mPresContext;

  3030   const bool mAtRoot;

  3031   bool& mCanStoreInRuleTree;

  3033   SetFontSizeCalcOps(nscoord aParentSize, const nsStyleFont* aParentFont,

  3034                      nsPresContext* aPresContext, bool aAtRoot,

  3035                      bool& aCanStoreInRuleTree)

  3036     : mParentSize(aParentSize),

  3037       mParentFont(aParentFont),

  3038       mPresContext(aPresContext),

  3039       mAtRoot(aAtRoot),

  3040       mCanStoreInRuleTree(aCanStoreInRuleTree)

  3041   {

  3042   }

  3044   result_type ComputeLeafValue(const nsCSSValue& aValue)

  3045   {

  3046     nscoord size;

  3047     if (aValue.IsLengthUnit()) {

  3048       // Note that font-based length units use the parent's size

  3049       // unadjusted for scriptlevel changes. A scriptlevel change

  3050       // between us and the parent is simply ignored.

  3051       size = CalcLengthWith(aValue, mParentSize,

  3052                             mParentFont,

  3053                             nullptr, mPresContext, mAtRoot,

  3054                             true, mCanStoreInRuleTree);

  3055       if (!aValue.IsRelativeLengthUnit() && mParentFont->mAllowZoom) {

  3056         size = nsStyleFont::ZoomText(mPresContext, size);

  3057       }

  3058     }

  3059     else if (eCSSUnit_Percent == aValue.GetUnit()) {

  3060       mCanStoreInRuleTree = false;

  3061       // Note that % units use the parent's size unadjusted for scriptlevel

  3062       // changes. A scriptlevel change between us and the parent is simply

  3063       // ignored.

  3064       // aValue.GetPercentValue() may be negative for, e.g., calc(-50%)

  3065       size = NSCoordSaturatingMultiply(mParentSize, aValue.GetPercentValue());

  3066     } else {

  3067       NS_ABORT_IF_FALSE(false, "unexpected value");

  3068       size = mParentSize;

  3069     }

  3071     return size;

  3072   }

  3073 };

  3075 /* static */ void

  3076 nsRuleNode::SetFontSize(nsPresContext* aPresContext,

  3077                         const nsRuleData* aRuleData,

  3078                         const nsStyleFont* aFont,

  3079                         const nsStyleFont* aParentFont,

  3080                         nscoord* aSize,

  3081                         const nsFont& aSystemFont,

  3082                         nscoord aParentSize,

  3083                         nscoord aScriptLevelAdjustedParentSize,

  3084                         bool aUsedStartStruct,

  3085                         bool aAtRoot,

  3086                         bool& aCanStoreInRuleTree)

  3087 {

  3088   // If false, means that *aSize has not been zoomed.  If true, means that

  3089   // *aSize has been zoomed iff aParentFont->mAllowZoom is true.

  3090   bool sizeIsZoomedAccordingToParent = false;

  3092   int32_t baseSize = (int32_t) aPresContext->

  3093     GetDefaultFont(aFont->mGenericID, aFont->mLanguage)->size;

  3094   const nsCSSValue* sizeValue = aRuleData->ValueForFontSize();

  3095   if (eCSSUnit_Enumerated == sizeValue->GetUnit()) {

  3096     int32_t value = sizeValue->GetIntValue();

  3098     if ((NS_STYLE_FONT_SIZE_XXSMALL <= value) &&

  3099         (value <= NS_STYLE_FONT_SIZE_XXLARGE)) {

  3100       *aSize = CalcFontPointSize(value, baseSize,

  3101                        aPresContext, eFontSize_CSS);

  3102     }

  3103     else if (NS_STYLE_FONT_SIZE_XXXLARGE == value) {

  3104       // <font size="7"> is not specified in CSS, so we don't use eFontSize_CSS.

  3105       *aSize = CalcFontPointSize(value, baseSize, aPresContext);

  3106     }

  3107     else if (NS_STYLE_FONT_SIZE_LARGER  == value ||

  3108              NS_STYLE_FONT_SIZE_SMALLER == value) {

  3109       aCanStoreInRuleTree = false;

  3111       // Un-zoom so we use the tables correctly.  We'll then rezoom due

  3112       // to the |zoom = true| above.

  3113       // Note that relative units here use the parent's size unadjusted

  3114       // for scriptlevel changes. A scriptlevel change between us and the parent

  3115       // is simply ignored.

  3116       nscoord parentSize = aParentSize;

  3117       if (aParentFont->mAllowZoom) {

  3118         parentSize = nsStyleFont::UnZoomText(aPresContext, parentSize);

  3119       }

  3121       if (NS_STYLE_FONT_SIZE_LARGER == value) {

  3122         *aSize = FindNextLargerFontSize(parentSize,

  3123                          baseSize, aPresContext, eFontSize_CSS);

  3125         NS_ASSERTION(*aSize >= parentSize,

  3126                      "FindNextLargerFontSize failed");

  3127       }

  3128       else {

  3129         *aSize = FindNextSmallerFontSize(parentSize,

  3130                          baseSize, aPresContext, eFontSize_CSS);

  3131         NS_ASSERTION(*aSize < parentSize ||

  3132                      parentSize <= nsPresContext::CSSPixelsToAppUnits(1),

  3133                      "FindNextSmallerFontSize failed");

  3134       }

  3135     } else {

  3136       NS_NOTREACHED("unexpected value");

  3137     }

  3138   }

  3139   else if (sizeValue->IsLengthUnit() ||

  3140            sizeValue->GetUnit() == eCSSUnit_Percent ||

  3141            sizeValue->IsCalcUnit()) {

  3142     SetFontSizeCalcOps ops(aParentSize, aParentFont,

  3143                            aPresContext, aAtRoot,

  3144                            aCanStoreInRuleTree);

  3145     *aSize = css::ComputeCalc(*sizeValue, ops);

  3146     if (*aSize < 0) {

  3147       NS_ABORT_IF_FALSE(sizeValue->IsCalcUnit(),

  3148                         "negative lengths and percents should be rejected "

  3149                         "by parser");

  3150       *aSize = 0;

  3151     }

  3152     // The calc ops will always zoom its result according to the value

  3153     // of aParentFont->mAllowZoom.

  3154     sizeIsZoomedAccordingToParent = true;

  3155   }

  3156   else if (eCSSUnit_System_Font == sizeValue->GetUnit()) {

  3157     // this becomes our cascading size

  3158     *aSize = aSystemFont.size;

  3159   }

  3160   else if (eCSSUnit_Inherit == sizeValue->GetUnit() ||

  3161            eCSSUnit_Unset == sizeValue->GetUnit()) {

  3162     aCanStoreInRuleTree = false;

  3163     // We apply scriptlevel change for this case, because the default is

  3164     // to inherit and we don't want explicit "inherit" to differ from the

  3165     // default.

  3166     *aSize = aScriptLevelAdjustedParentSize;

  3167     sizeIsZoomedAccordingToParent = true;

  3168   }

  3169   else if (eCSSUnit_Initial == sizeValue->GetUnit()) {

  3170     // The initial value is 'medium', which has magical sizing based on

  3171     // the generic font family, so do that here too.

  3172     *aSize = baseSize;

  3173   } else {

  3174     NS_ASSERTION(eCSSUnit_Null == sizeValue->GetUnit(),

  3175                  "What kind of font-size value is this?");

  3176     // if aUsedStartStruct is true, then every single property in the

  3177     // font struct is being set all at once. This means scriptlevel is not

  3178     // going to have any influence on the font size; there is no need to

  3179     // do anything here.

  3180     if (!aUsedStartStruct && aParentSize != aScriptLevelAdjustedParentSize) {

  3181       // There was no rule affecting the size but the size has been

  3182       // affected by the parent's size via scriptlevel change. So we cannot

  3183       // store the data in the rule tree.

  3184       aCanStoreInRuleTree = false;

  3185       *aSize = aScriptLevelAdjustedParentSize;

  3186       sizeIsZoomedAccordingToParent = true;

  3187     } else {

  3188       return;

  3189     }

  3190   }

  3192   // We want to zoom the cascaded size so that em-based measurements,

  3193   // line-heights, etc., work.

  3194   bool currentlyZoomed = sizeIsZoomedAccordingToParent &&

  3195                          aParentFont->mAllowZoom;

  3196   if (!currentlyZoomed && aFont->mAllowZoom) {

  3197     *aSize = nsStyleFont::ZoomText(aPresContext, *aSize);

  3198   } else if (currentlyZoomed && !aFont->mAllowZoom) {

  3199     *aSize = nsStyleFont::UnZoomText(aPresContext, *aSize);

  3200   }

  3201 }

  3203 static int8_t ClampTo8Bit(int32_t aValue) {

  3204   if (aValue < -128)

  3205     return -128;

  3206   if (aValue > 127)

  3207     return 127;

  3208   return int8_t(aValue);

  3209 }

  3211 /* static */ void

  3212 nsRuleNode::SetFont(nsPresContext* aPresContext, nsStyleContext* aContext,

  3213                     uint8_t aGenericFontID, const nsRuleData* aRuleData,

  3214                     const nsStyleFont* aParentFont,

  3215                     nsStyleFont* aFont, bool aUsedStartStruct,

  3216                     bool& aCanStoreInRuleTree)

  3217 {

  3218   bool atRoot = !aContext->GetParent();

  3220   // -x-text-zoom: none, inherit, initial

  3221   bool allowZoom;

  3222   const nsCSSValue* textZoomValue = aRuleData->ValueForTextZoom();

  3223   if (eCSSUnit_Null != textZoomValue->GetUnit()) {

  3224     if (eCSSUnit_Inherit == textZoomValue->GetUnit()) {

  3225       allowZoom = aParentFont->mAllowZoom;

  3226     } else if (eCSSUnit_None == textZoomValue->GetUnit()) {

  3227       allowZoom = false;

  3228     } else {

  3229       MOZ_ASSERT(eCSSUnit_Initial == textZoomValue->GetUnit(),

  3230                  "unexpected unit");

  3231       allowZoom = true;

  3232     }

  3233     aFont->EnableZoom(aPresContext, allowZoom);

  3234   }

  3236   // mLanguage must be set before before any of the CalcLengthWith calls

  3237   // (direct calls or calls via SetFontSize) for the cases where |aParentFont|

  3238   // is the same as |aFont|.

  3239   //

  3240   // -x-lang: string, inherit

  3241   // This is not a real CSS property, it is an HTML attribute mapped to CSS.

  3242   const nsCSSValue* langValue = aRuleData->ValueForLang();

  3243   if (eCSSUnit_Ident == langValue->GetUnit()) {

  3244     nsAutoString lang;

  3245     langValue->GetStringValue(lang);

  3247     nsContentUtils::ASCIIToLower(lang);

  3248     aFont->mLanguage = do_GetAtom(lang);

  3249     aFont->mExplicitLanguage = true;

  3250   }

  3252   const nsFont* defaultVariableFont =

  3253     aPresContext->GetDefaultFont(kPresContext_DefaultVariableFont_ID,

  3254                                  aFont->mLanguage);

  3256   // XXX: Bleh. Disable these somehow?

  3257   // -moz-system-font: enum (never inherit!)

  3258   static_assert(

  3259     NS_STYLE_FONT_CAPTION        == LookAndFeel::eFont_Caption &&

  3260     NS_STYLE_FONT_ICON           == LookAndFeel::eFont_Icon &&

  3261     NS_STYLE_FONT_MENU           == LookAndFeel::eFont_Menu &&

  3262     NS_STYLE_FONT_MESSAGE_BOX    == LookAndFeel::eFont_MessageBox &&

  3263     NS_STYLE_FONT_SMALL_CAPTION  == LookAndFeel::eFont_SmallCaption &&

  3264     NS_STYLE_FONT_STATUS_BAR     == LookAndFeel::eFont_StatusBar &&

  3265     NS_STYLE_FONT_WINDOW         == LookAndFeel::eFont_Window &&

  3266     NS_STYLE_FONT_DOCUMENT       == LookAndFeel::eFont_Document &&

  3267     NS_STYLE_FONT_WORKSPACE      == LookAndFeel::eFont_Workspace &&

  3268     NS_STYLE_FONT_DESKTOP        == LookAndFeel::eFont_Desktop &&

  3269     NS_STYLE_FONT_INFO           == LookAndFeel::eFont_Info &&

  3270     NS_STYLE_FONT_DIALOG         == LookAndFeel::eFont_Dialog &&

  3271     NS_STYLE_FONT_BUTTON         == LookAndFeel::eFont_Button &&

  3272     NS_STYLE_FONT_PULL_DOWN_MENU == LookAndFeel::eFont_PullDownMenu &&

  3273     NS_STYLE_FONT_LIST           == LookAndFeel::eFont_List &&

  3274     NS_STYLE_FONT_FIELD          == LookAndFeel::eFont_Field,

  3275     "LookAndFeel.h system-font constants out of sync with nsStyleConsts.h");

  3277   // Fall back to defaultVariableFont.

  3278   nsFont systemFont = *defaultVariableFont;

  3279   const nsCSSValue* systemFontValue = aRuleData->ValueForSystemFont();

  3280   if (eCSSUnit_Enumerated == systemFontValue->GetUnit()) {

  3281     gfxFontStyle fontStyle;

  3282     LookAndFeel::FontID fontID =

  3283       (LookAndFeel::FontID)systemFontValue->GetIntValue();

  3284     float devPerCSS =

  3285       (float)nsPresContext::AppUnitsPerCSSPixel() /

  3286       aPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();

  3287     if (LookAndFeel::GetFont(fontID, systemFont.name, fontStyle, devPerCSS)) {

  3288       systemFont.style = fontStyle.style;

  3289       systemFont.systemFont = fontStyle.systemFont;

  3290       systemFont.variant = NS_FONT_VARIANT_NORMAL;

  3291       systemFont.weight = fontStyle.weight;

  3292       systemFont.stretch = fontStyle.stretch;

  3293       systemFont.decorations = NS_FONT_DECORATION_NONE;

  3294       systemFont.size = NSFloatPixelsToAppUnits(fontStyle.size,

  3295                                                 aPresContext->DeviceContext()->

  3296                                                 UnscaledAppUnitsPerDevPixel());

  3297       //systemFont.langGroup = fontStyle.langGroup;

  3298       systemFont.sizeAdjust = fontStyle.sizeAdjust;

  3300 #ifdef XP_WIN

  3301       // XXXldb This platform-specific stuff should be in the

  3302       // LookAndFeel implementation, not here.

  3303       // XXXzw Should we even still *have* this code?  It looks to be making

  3304       // old, probably obsolete assumptions.

  3306       if (fontID == LookAndFeel::eFont_Field ||

  3307           fontID == LookAndFeel::eFont_Button ||

  3308           fontID == LookAndFeel::eFont_List) {

  3309         // As far as I can tell the system default fonts and sizes

  3310         // on MS-Windows for Buttons, Listboxes/Comboxes and Text Fields are

  3311         // all pre-determined and cannot be changed by either the control panel

  3312         // or programmatically.

  3313         // Fields (text fields)

  3314         // Button and Selects (listboxes/comboboxes)

  3315         //    We use whatever font is defined by the system. Which it appears

  3316         //    (and the assumption is) it is always a proportional font. Then we

  3317         //    always use 2 points smaller than what the browser has defined as

  3318         //    the default proportional font.

  3319         // Assumption: system defined font is proportional

  3320         systemFont.size =

  3321           std::max(defaultVariableFont->size -

  3322                  nsPresContext::CSSPointsToAppUnits(2), 0);

  3323       }

  3324 #endif

  3325     }

  3326   }

  3328   // font-family: string list, enum, inherit

  3329   const nsCSSValue* familyValue = aRuleData->ValueForFontFamily();

  3330   NS_ASSERTION(eCSSUnit_Enumerated != familyValue->GetUnit(),

  3331                "system fonts should not be in mFamily anymore");

  3332   if (eCSSUnit_Families == familyValue->GetUnit()) {

  3333     // set the correct font if we are using DocumentFonts OR we are overriding for XUL

  3334     // MJA: bug 31816

  3335     if (aGenericFontID == kGenericFont_NONE) {

  3336       // only bother appending fallback fonts if this isn't a fallback generic font itself

  3337       if (!aFont->mFont.name.IsEmpty())

  3338         aFont->mFont.name.Append((char16_t)',');

  3339       // defaultVariableFont.name should always be "serif" or "sans-serif".

  3340       aFont->mFont.name.Append(defaultVariableFont->name);

  3341     }

  3342     aFont->mFont.systemFont = false;

  3343     // Technically this is redundant with the code below, but it's good

  3344     // to have since we'll still want it once we get rid of

  3345     // SetGenericFont (bug 380915).

  3346     aFont->mGenericID = aGenericFontID;

  3347   }

  3348   else if (eCSSUnit_System_Font == familyValue->GetUnit()) {

  3349     aFont->mFont.name = systemFont.name;

  3350     aFont->mFont.systemFont = true;

  3351     aFont->mGenericID = kGenericFont_NONE;

  3352   }

  3353   else if (eCSSUnit_Inherit == familyValue->GetUnit() ||

  3354            eCSSUnit_Unset == familyValue->GetUnit()) {

  3355     aCanStoreInRuleTree = false;

  3356     aFont->mFont.name = aParentFont->mFont.name;

  3357     aFont->mFont.systemFont = aParentFont->mFont.systemFont;

  3358     aFont->mGenericID = aParentFont->mGenericID;

  3359   }

  3360   else if (eCSSUnit_Initial == familyValue->GetUnit()) {

  3361     aFont->mFont.name = defaultVariableFont->name;

  3362     aFont->mFont.systemFont = defaultVariableFont->systemFont;

  3363     aFont->mGenericID = kGenericFont_NONE;

  3364   }

  3366   // When we're in the loop in SetGenericFont, we must ensure that we

  3367   // always keep aFont->mFlags set to the correct generic.  But we have

  3368   // to be careful not to touch it when we're called directly from

  3369   // ComputeFontData, because we could have a start struct.

  3370   if (aGenericFontID != kGenericFont_NONE) {

  3371     aFont->mGenericID = aGenericFontID;

  3372   }

  3374   // -moz-math-variant: enum, inherit, initial

  3375   SetDiscrete(*aRuleData->ValueForMathVariant(), aFont->mMathVariant,

  3376               aCanStoreInRuleTree,

  3377               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  3378               aParentFont->mMathVariant, NS_MATHML_MATHVARIANT_NONE,

  3379               0, 0, 0, 0);

  3381   // -moz-math-display: enum, inherit, initial

  3382   SetDiscrete(*aRuleData->ValueForMathDisplay(), aFont->mMathDisplay,

  3383               aCanStoreInRuleTree,

  3384               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  3385               aParentFont->mMathDisplay, NS_MATHML_DISPLAYSTYLE_INLINE,

  3386               0, 0, 0, 0);

  3388   // font-smoothing: enum, inherit, initial

  3389   SetDiscrete(*aRuleData->ValueForOSXFontSmoothing(),

  3390               aFont->mFont.smoothing, aCanStoreInRuleTree,

  3391               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  3392               aParentFont->mFont.smoothing,

  3393               defaultVariableFont->smoothing,

  3394               0, 0, 0, 0);

  3396   // font-style: enum, inherit, initial, -moz-system-font

  3397   if (aFont->mMathVariant != NS_MATHML_MATHVARIANT_NONE) {

  3398     // -moz-math-variant overrides font-style

  3399     aFont->mFont.style = NS_FONT_STYLE_NORMAL;

  3400   } else {

  3401     SetDiscrete(*aRuleData->ValueForFontStyle(),

  3402                 aFont->mFont.style, aCanStoreInRuleTree,

  3403                 SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT | SETDSC_UNSET_INHERIT,

  3404                 aParentFont->mFont.style,

  3405                 defaultVariableFont->style,

  3406                 0, 0, 0, systemFont.style);

  3407   }

  3409   // font-variant: enum, inherit, initial, -moz-system-font

  3410   SetDiscrete(*aRuleData->ValueForFontVariant(),

  3411               aFont->mFont.variant, aCanStoreInRuleTree,

  3412               SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT | SETDSC_UNSET_INHERIT,

  3413               aParentFont->mFont.variant,

  3414               defaultVariableFont->variant,

  3415               0, 0, 0, systemFont.variant);

  3417   // font-weight: int, enum, inherit, initial, -moz-system-font

  3418   // special handling for enum

  3419   const nsCSSValue* weightValue = aRuleData->ValueForFontWeight();

  3420   if (aFont->mMathVariant != NS_MATHML_MATHVARIANT_NONE) {

  3421     // -moz-math-variant overrides font-weight

  3422     aFont->mFont.weight = NS_FONT_WEIGHT_NORMAL;

  3423   } else if (eCSSUnit_Enumerated == weightValue->GetUnit()) {

  3424     int32_t value = weightValue->GetIntValue();

  3425     switch (value) {

  3426       case NS_STYLE_FONT_WEIGHT_NORMAL:

  3427       case NS_STYLE_FONT_WEIGHT_BOLD:

  3428         aFont->mFont.weight = value;

  3429         break;

  3430       case NS_STYLE_FONT_WEIGHT_BOLDER: {

  3431         aCanStoreInRuleTree = false;

  3432         int32_t inheritedValue = aParentFont->mFont.weight;

  3433         if (inheritedValue <= 300) {

  3434           aFont->mFont.weight = 400;

  3435         } else if (inheritedValue <= 500) {

  3436           aFont->mFont.weight = 700;

  3437         } else {

  3438           aFont->mFont.weight = 900;

  3439         }

  3440         break;

  3441       }

  3442       case NS_STYLE_FONT_WEIGHT_LIGHTER: {

  3443         aCanStoreInRuleTree = false;

  3444         int32_t inheritedValue = aParentFont->mFont.weight;

  3445         if (inheritedValue < 600) {

  3446           aFont->mFont.weight = 100;

  3447         } else if (inheritedValue < 800) {

  3448           aFont->mFont.weight = 400;

  3449         } else {

  3450           aFont->mFont.weight = 700;

  3451         }

  3452         break;

  3453       }

  3454     }

  3455   } else

  3456     SetDiscrete(*weightValue, aFont->mFont.weight, aCanStoreInRuleTree,

  3457                 SETDSC_INTEGER | SETDSC_SYSTEM_FONT | SETDSC_UNSET_INHERIT,

  3458                 aParentFont->mFont.weight,

  3459                 defaultVariableFont->weight,

  3460                 0, 0, 0, systemFont.weight);

  3462   // font-stretch: enum, inherit, initial, -moz-system-font

  3463   SetDiscrete(*aRuleData->ValueForFontStretch(),

  3464               aFont->mFont.stretch, aCanStoreInRuleTree,

  3465               SETDSC_SYSTEM_FONT | SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  3466               aParentFont->mFont.stretch,

  3467               defaultVariableFont->stretch,

  3468               0, 0, 0, systemFont.stretch);

  3470   // Compute scriptlevel, scriptminsize and scriptsizemultiplier now so

  3471   // they're available for font-size computation.

  3473   // -moz-script-min-size: length

  3474   const nsCSSValue* scriptMinSizeValue = aRuleData->ValueForScriptMinSize();

  3475   if (scriptMinSizeValue->IsLengthUnit()) {

  3476     // scriptminsize in font units (em, ex) has to be interpreted relative

  3477     // to the parent font, or the size definitions are circular and we

  3478     //

  3479     aFont->mScriptMinSize =

  3480       CalcLengthWith(*scriptMinSizeValue, aParentFont->mSize,

  3481                      aParentFont,

  3482                      nullptr, aPresContext, atRoot, true,

  3483                      aCanStoreInRuleTree);

  3484   }

  3486   // -moz-script-size-multiplier: factor, inherit, initial

  3487   SetFactor(*aRuleData->ValueForScriptSizeMultiplier(),

  3488             aFont->mScriptSizeMultiplier,

  3489             aCanStoreInRuleTree, aParentFont->mScriptSizeMultiplier,

  3490             NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER,

  3491             SETFCT_POSITIVE | SETFCT_UNSET_INHERIT);

  3493   // -moz-script-level: integer, number, inherit

  3494   const nsCSSValue* scriptLevelValue = aRuleData->ValueForScriptLevel();

  3495   if (eCSSUnit_Integer == scriptLevelValue->GetUnit()) {

  3496     // "relative"

  3497     aCanStoreInRuleTree = false;

  3498     aFont->mScriptLevel = ClampTo8Bit(aParentFont->mScriptLevel + scriptLevelValue->GetIntValue());

  3499   }

  3500   else if (eCSSUnit_Number == scriptLevelValue->GetUnit()) {

  3501     // "absolute"

  3502     aFont->mScriptLevel = ClampTo8Bit(int32_t(scriptLevelValue->GetFloatValue()));

  3503   }

  3504   else if (eCSSUnit_Auto == scriptLevelValue->GetUnit()) {

  3505     // auto

  3506     aCanStoreInRuleTree = false;

  3507     aFont->mScriptLevel = ClampTo8Bit(aParentFont->mScriptLevel +

  3508                                       (aParentFont->mMathDisplay ==

  3509                                        NS_MATHML_DISPLAYSTYLE_INLINE ? 1 : 0));

  3510   }

  3511   else if (eCSSUnit_Inherit == scriptLevelValue->GetUnit() ||

  3512            eCSSUnit_Unset == scriptLevelValue->GetUnit()) {

  3513     aCanStoreInRuleTree = false;

  3514     aFont->mScriptLevel = aParentFont->mScriptLevel;

  3515   }

  3516   else if (eCSSUnit_Initial == scriptLevelValue->GetUnit()) {

  3517     aFont->mScriptLevel = 0;

  3518   }

  3520   // font-kerning: none, enum, inherit, initial, -moz-system-font

  3521   SetDiscrete(*aRuleData->ValueForFontKerning(),

  3522               aFont->mFont.kerning, aCanStoreInRuleTree,

  3523               SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT | SETDSC_UNSET_INHERIT,

  3524               aParentFont->mFont.kerning,

  3525               defaultVariableFont->kerning,

  3526               0, 0, 0, systemFont.kerning);

  3528   // font-synthesis: none, enum (bit field), inherit, initial, -moz-system-font

  3529   SetDiscrete(*aRuleData->ValueForFontSynthesis(),

  3530               aFont->mFont.synthesis, aCanStoreInRuleTree,

  3531               SETDSC_NONE | SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT |

  3532                 SETDSC_UNSET_INHERIT,

  3533               aParentFont->mFont.synthesis,

  3534               defaultVariableFont->synthesis,

  3535               0, 0, 0, systemFont.synthesis);

  3537   // font-variant-alternates: normal, enum (bit field) + functions, inherit,

  3538   //                          initial, -moz-system-font

  3539   const nsCSSValue* variantAlternatesValue =

  3540     aRuleData->ValueForFontVariantAlternates();

  3541   int32_t variantAlternates = 0;

  3543   switch (variantAlternatesValue->GetUnit()) {

  3544   case eCSSUnit_Inherit:

  3545   case eCSSUnit_Unset:

  3546     aFont->mFont.CopyAlternates(aParentFont->mFont);

  3547     aCanStoreInRuleTree = false;

  3548     break;

  3550   case eCSSUnit_Initial:

  3551   case eCSSUnit_Normal:

  3552     aFont->mFont.variantAlternates = 0;

  3553     aFont->mFont.alternateValues.Clear();

  3554     aFont->mFont.featureValueLookup = nullptr;

  3555     break;

  3557   case eCSSUnit_Pair:

  3558     NS_ASSERTION(variantAlternatesValue->GetPairValue().mXValue.GetUnit() ==

  3559                    eCSSUnit_Enumerated, "strange unit for variantAlternates");

  3560     variantAlternates =

  3561       variantAlternatesValue->GetPairValue().mXValue.GetIntValue();

  3562     aFont->mFont.variantAlternates = variantAlternates;

  3564     if (variantAlternates & NS_FONT_VARIANT_ALTERNATES_FUNCTIONAL_MASK) {

  3565       // fetch the feature lookup object from the styleset

  3566       aFont->mFont.featureValueLookup =

  3567         aPresContext->StyleSet()->GetFontFeatureValuesLookup();

  3569       NS_ASSERTION(variantAlternatesValue->GetPairValue().mYValue.GetUnit() ==

  3570                    eCSSUnit_List, "function list not a list value");

  3571       nsStyleUtil::ComputeFunctionalAlternates(

  3572         variantAlternatesValue->GetPairValue().mYValue.GetListValue(),

  3573         aFont->mFont.alternateValues);

  3574     }

  3575     break;

  3577   default:

  3578     break;

  3579   }

  3581   // font-variant-caps: normal, enum, inherit, initial, -moz-system-font

  3582   SetDiscrete(*aRuleData->ValueForFontVariantCaps(),

  3583               aFont->mFont.variantCaps, aCanStoreInRuleTree,

  3584               SETDSC_NORMAL | SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT |

  3585                 SETDSC_UNSET_INHERIT,

  3586               aParentFont->mFont.variantCaps,

  3587               defaultVariableFont->variantCaps,

  3588               0, 0, 0, systemFont.variantCaps);

  3590   // font-variant-east-asian: normal, enum (bit field), inherit, initial,

  3591   //                          -moz-system-font

  3592   SetDiscrete(*aRuleData->ValueForFontVariantEastAsian(),

  3593               aFont->mFont.variantEastAsian, aCanStoreInRuleTree,

  3594               SETDSC_NORMAL | SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT |

  3595                 SETDSC_UNSET_INHERIT,

  3596               aParentFont->mFont.variantEastAsian,

  3597               defaultVariableFont->variantEastAsian,

  3598               0, 0, 0, systemFont.variantEastAsian);

  3600   // font-variant-ligatures: normal, enum (bit field), inherit, initial,

  3601   //                         -moz-system-font

  3602   SetDiscrete(*aRuleData->ValueForFontVariantLigatures(),

  3603               aFont->mFont.variantLigatures, aCanStoreInRuleTree,

  3604               SETDSC_NORMAL | SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT |

  3605                 SETDSC_UNSET_INHERIT,

  3606               aParentFont->mFont.variantLigatures,

  3607               defaultVariableFont->variantLigatures,

  3608               0, 0, 0, systemFont.variantLigatures);

  3610   // font-variant-numeric: normal, enum (bit field), inherit, initial,

  3611   //                       -moz-system-font

  3612   SetDiscrete(*aRuleData->ValueForFontVariantNumeric(),

  3613               aFont->mFont.variantNumeric, aCanStoreInRuleTree,

  3614               SETDSC_NORMAL | SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT |

  3615                 SETDSC_UNSET_INHERIT,

  3616               aParentFont->mFont.variantNumeric,

  3617               defaultVariableFont->variantNumeric,

  3618               0, 0, 0, systemFont.variantNumeric);

  3620   // font-variant-position: normal, enum, inherit, initial,

  3621   //                        -moz-system-font

  3622   SetDiscrete(*aRuleData->ValueForFontVariantPosition(),

  3623               aFont->mFont.variantPosition, aCanStoreInRuleTree,

  3624               SETDSC_NORMAL | SETDSC_ENUMERATED | SETDSC_SYSTEM_FONT |

  3625                 SETDSC_UNSET_INHERIT,

  3626               aParentFont->mFont.variantPosition,

  3627               defaultVariableFont->variantPosition,

  3628               0, 0, 0, systemFont.variantPosition);

  3630   // font-feature-settings

  3631   const nsCSSValue* featureSettingsValue =

  3632     aRuleData->ValueForFontFeatureSettings();

  3634   switch (featureSettingsValue->GetUnit()) {

  3635   case eCSSUnit_Null:

  3636     break;

  3638   case eCSSUnit_Normal:

  3639   case eCSSUnit_Initial:

  3640     aFont->mFont.fontFeatureSettings.Clear();

  3641     break;

  3643   case eCSSUnit_Inherit:

  3644   case eCSSUnit_Unset:

  3645     aCanStoreInRuleTree = false;

  3646     aFont->mFont.fontFeatureSettings = aParentFont->mFont.fontFeatureSettings;

  3647     break;

  3649   case eCSSUnit_System_Font:

  3650     aFont->mFont.fontFeatureSettings = systemFont.fontFeatureSettings;

  3651     break;

  3653   case eCSSUnit_PairList:

  3654   case eCSSUnit_PairListDep:

  3655     ComputeFontFeatures(featureSettingsValue->GetPairListValue(),

  3656                         aFont->mFont.fontFeatureSettings);

  3657     break;

  3659   default:

  3660     NS_ABORT_IF_FALSE(false, "unexpected value unit");

  3661     break;

  3662   }

  3664   // font-language-override

  3665   const nsCSSValue* languageOverrideValue =

  3666     aRuleData->ValueForFontLanguageOverride();

  3667   if (eCSSUnit_Inherit == languageOverrideValue->GetUnit() ||

  3668       eCSSUnit_Unset == languageOverrideValue->GetUnit()) {

  3669     aCanStoreInRuleTree = false;

  3670     aFont->mFont.languageOverride = aParentFont->mFont.languageOverride;

  3671   } else if (eCSSUnit_Normal == languageOverrideValue->GetUnit() ||

  3672              eCSSUnit_Initial == languageOverrideValue->GetUnit()) {

  3673     aFont->mFont.languageOverride.Truncate();

  3674   } else if (eCSSUnit_System_Font == languageOverrideValue->GetUnit()) {

  3675     aFont->mFont.languageOverride = systemFont.languageOverride;

  3676   } else if (eCSSUnit_String == languageOverrideValue->GetUnit()) {

  3677     languageOverrideValue->GetStringValue(aFont->mFont.languageOverride);

  3678   }

  3680   // font-size: enum, length, percent, inherit

  3681   nscoord scriptLevelAdjustedParentSize = aParentFont->mSize;

  3682   nscoord scriptLevelAdjustedUnconstrainedParentSize;

  3683   scriptLevelAdjustedParentSize =

  3684     ComputeScriptLevelSize(aFont, aParentFont, aPresContext,

  3685                            &scriptLevelAdjustedUnconstrainedParentSize);

  3686   NS_ASSERTION(!aUsedStartStruct || aFont->mScriptUnconstrainedSize == aFont->mSize,

  3687                "If we have a start struct, we should have reset everything coming in here");

  3688   SetFontSize(aPresContext, aRuleData, aFont, aParentFont,

  3689               &aFont->mSize,

  3690               systemFont, aParentFont->mSize, scriptLevelAdjustedParentSize,

  3691               aUsedStartStruct, atRoot, aCanStoreInRuleTree);

  3692   if (aParentFont->mSize == aParentFont->mScriptUnconstrainedSize &&

  3693       scriptLevelAdjustedParentSize == scriptLevelAdjustedUnconstrainedParentSize) {

  3694     // Fast path: we have not been affected by scriptminsize so we don't

  3695     // need to call SetFontSize again to compute the

  3696     // scriptminsize-unconstrained size. This is OK even if we have a

  3697     // start struct, because if we have a start struct then 'font-size'

  3698     // was specified and so scriptminsize has no effect.

  3699     aFont->mScriptUnconstrainedSize = aFont->mSize;

  3700   } else {

  3701     SetFontSize(aPresContext, aRuleData, aFont, aParentFont,

  3702                 &aFont->mScriptUnconstrainedSize,

  3703                 systemFont, aParentFont->mScriptUnconstrainedSize,

  3704                 scriptLevelAdjustedUnconstrainedParentSize,

  3705                 aUsedStartStruct, atRoot, aCanStoreInRuleTree);

  3706   }

  3707   NS_ASSERTION(aFont->mScriptUnconstrainedSize <= aFont->mSize,

  3708                "scriptminsize should never be making things bigger");

  3710   nscoord fontSize = aFont->mSize;

  3712   // enforce the user' specified minimum font-size on the value that we expose

  3713   // (but don't change font-size:0, since that would unhide hidden text)

  3714   if (fontSize > 0) {

  3715     nscoord minFontSize = aPresContext->MinFontSize(aFont->mLanguage);

  3716     if (minFontSize < 0) {

  3717       minFontSize = 0;

  3718     }

  3719     if (fontSize < minFontSize && !aPresContext->IsChrome()) {

  3720       // override the minimum font-size constraint

  3721       fontSize = minFontSize;

  3722     }

  3723   }

  3724   aFont->mFont.size = fontSize;

  3726   // font-size-adjust: number, none, inherit, initial, -moz-system-font

  3727   const nsCSSValue* sizeAdjustValue = aRuleData->ValueForFontSizeAdjust();

  3728   if (eCSSUnit_System_Font == sizeAdjustValue->GetUnit()) {

  3729     aFont->mFont.sizeAdjust = systemFont.sizeAdjust;

  3730   } else

  3731     SetFactor(*sizeAdjustValue, aFont->mFont.sizeAdjust,

  3732               aCanStoreInRuleTree, aParentFont->mFont.sizeAdjust, 0.0f,

  3733               SETFCT_NONE | SETFCT_UNSET_INHERIT);

  3734 }

  3736 /* static */ void

  3737 nsRuleNode::ComputeFontFeatures(const nsCSSValuePairList *aFeaturesList,

  3738                                 nsTArray<gfxFontFeature>& aFeatureSettings)

  3739 {

  3740   aFeatureSettings.Clear();

  3741   for (const nsCSSValuePairList* p = aFeaturesList; p; p = p->mNext) {

  3742     gfxFontFeature feat = {0, 0};

  3744     NS_ABORT_IF_FALSE(aFeaturesList->mXValue.GetUnit() == eCSSUnit_String,

  3745                       "unexpected value unit");

  3747     // tag is a 4-byte ASCII sequence

  3748     nsAutoString tag;

  3749     p->mXValue.GetStringValue(tag);

  3750     if (tag.Length() != 4) {

  3751       continue;

  3752     }

  3753     // parsing validates that these are ASCII chars

  3754     // tags are always big-endian

  3755     feat.mTag = (tag[0] << 24) | (tag[1] << 16) | (tag[2] << 8)  | tag[3];

  3757     // value

  3758     NS_ASSERTION(p->mYValue.GetUnit() == eCSSUnit_Integer,

  3759                  "should have found an integer unit");

  3760     feat.mValue = p->mYValue.GetIntValue();

  3762     aFeatureSettings.AppendElement(feat);

  3763   }

  3764 }

  3766 // This should die (bug 380915).

  3767 //

  3768 // SetGenericFont:

  3769 //  - backtrack to an ancestor with the same generic font name (possibly

  3770 //    up to the root where default values come from the presentation context)

  3771 //  - re-apply cascading rules from there without caching intermediate values

  3772 /* static */ void

  3773 nsRuleNode::SetGenericFont(nsPresContext* aPresContext,

  3774                            nsStyleContext* aContext,

  3775                            uint8_t aGenericFontID,

  3776                            nsStyleFont* aFont)

  3777 {

  3778   // walk up the contexts until a context with the desired generic font

  3779   nsAutoTArray<nsStyleContext*, 8> contextPath;

  3780   contextPath.AppendElement(aContext);

  3781   nsStyleContext* higherContext = aContext->GetParent();

  3782   while (higherContext) {

  3783     if (higherContext->StyleFont()->mGenericID == aGenericFontID) {

  3784       // done walking up the higher contexts

  3785       break;

  3786     }

  3787     contextPath.AppendElement(higherContext);

  3788     higherContext = higherContext->GetParent();

  3789   }

  3791   // re-apply the cascading rules, starting from the higher context

  3793   // If we stopped earlier because we reached the root of the style tree,

  3794   // we will start with the default generic font from the presentation

  3795   // context. Otherwise we start with the higher context.

  3796   const nsFont* defaultFont =

  3797     aPresContext->GetDefaultFont(aGenericFontID, aFont->mLanguage);

  3798   nsStyleFont parentFont(*defaultFont, aPresContext);

  3799   if (higherContext) {

  3800     const nsStyleFont* tmpFont = higherContext->StyleFont();

  3801     parentFont = *tmpFont;

  3802   }

  3803   *aFont = parentFont;

  3805   bool dummy;

  3806   uint32_t fontBit = nsCachedStyleData::GetBitForSID(eStyleStruct_Font);

  3808   // use placement new[] on the result of alloca() to allocate a

  3809   // variable-sized stack array, including execution of constructors,

  3810   // and use an RAII class to run the destructors too.

  3811   size_t nprops = nsCSSProps::PropertyCountInStruct(eStyleStruct_Font);

  3812   void* dataStorage = alloca(nprops * sizeof(nsCSSValue));

  3814   for (int32_t i = contextPath.Length() - 1; i >= 0; --i) {

  3815     nsStyleContext* context = contextPath[i];

  3816     AutoCSSValueArray dataArray(dataStorage, nprops);

  3818     nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Font), dataArray.get(),

  3819                         aPresContext, context);

  3820     ruleData.mValueOffsets[eStyleStruct_Font] = 0;

  3822     // Trimmed down version of ::WalkRuleTree() to re-apply the style rules

  3823     // Note that we *do* need to do this for our own data, since what is

  3824     // in |fontData| in ComputeFontData is only for the rules below

  3825     // aStartStruct.

  3826     for (nsRuleNode* ruleNode = context->RuleNode(); ruleNode;

  3827          ruleNode = ruleNode->GetParent()) {

  3828       if (ruleNode->mNoneBits & fontBit)

  3829         // no more font rules on this branch, get out

  3830         break;

  3832       nsIStyleRule *rule = ruleNode->GetRule();

  3833       if (rule) {

  3834         ruleData.mLevel = ruleNode->GetLevel();

  3835         ruleData.mIsImportantRule = ruleNode->IsImportantRule();

  3836         rule->MapRuleInfoInto(&ruleData);

  3837       }

  3838     }

  3840     // Compute the delta from the information that the rules specified

  3842     // Avoid unnecessary operations in SetFont().  But we care if it's

  3843     // the final value that we're computing.

  3844     if (i != 0)

  3845       ruleData.ValueForFontFamily()->Reset();

  3847     ResolveVariableReferences(eStyleStruct_Font, &ruleData, aContext);

  3849     nsRuleNode::SetFont(aPresContext, context,

  3850                         aGenericFontID, &ruleData, &parentFont, aFont,

  3851                         false, dummy);

  3853     parentFont = *aFont;

  3854   }

  3855 }

  3857 static bool ExtractGeneric(const nsString& aFamily, bool aGeneric,

  3858                              void *aData)

  3859 {

  3860   nsAutoString *data = static_cast<nsAutoString*>(aData);

  3862   if (aGeneric) {

  3863     *data = aFamily;

  3864     return false; // stop enumeration

  3865   }

  3866   return true;

  3867 }

  3869 struct smugglerStruct {

  3870   nsStyleFont *font;

  3871   gfxUserFontSet *userFonts;

  3872 };

  3874 /* This function forces the use of the first @font-face font we find */

  3875 static bool ForceFirstWebFont(const nsString& aFamily, bool aGeneric,

  3876                               void *smuggled)

  3877 {

  3878   smugglerStruct *sm = static_cast<smugglerStruct*>(smuggled);

  3880   if (aGeneric) {

  3881     return true;

  3882   }

  3884   if (sm->userFonts->HasFamily(aFamily)) {

  3885     // Force use of this exact @font-face font since we have it.

  3886     sm->font->mFont.name = aFamily;

  3888     return false; // Stop enumeration.

  3889   }

  3891   return true;

  3892 }

  3894 const void*

  3895 nsRuleNode::ComputeFontData(void* aStartStruct,

  3896                             const nsRuleData* aRuleData,

  3897                             nsStyleContext* aContext,

  3898                             nsRuleNode* aHighestNode,

  3899                             const RuleDetail aRuleDetail,

  3900                             const bool aCanStoreInRuleTree)

  3901 {

  3902   COMPUTE_START_INHERITED(Font, (mPresContext), font, parentFont)

  3904   // NOTE:  The |aRuleDetail| passed in is a little bit conservative due

  3905   // to the -moz-system-font property.  We really don't need to consider

  3906   // it here in determining whether to cache in the rule tree.  However,

  3907   // we do need to consider it in WalkRuleTree when deciding whether to

  3908   // walk further up the tree.  So this means that when the font struct

  3909   // is fully specified using *longhand* properties (excluding

  3910   // -moz-system-font), we won't cache in the rule tree even though we

  3911   // could.  However, it's pretty unlikely authors will do that

  3912   // (although there is a pretty good chance they'll fully specify it

  3913   // using the 'font' shorthand).

  3915   bool useDocumentFonts =

  3916     mPresContext->GetCachedBoolPref(kPresContext_UseDocumentFonts);

  3917   bool isXUL = PR_FALSE;

  3918   bool forcedWebFont = false;

  3920   // See if we are in the chrome

  3921   // We only need to know this to determine if we have to use the

  3922   // document fonts (overriding the useDocumentFonts flag).

  3923   if (mPresContext->IsChrome()) {

  3924     // if we are not using document fonts, but this is a XUL document,

  3925     // then we use the document fonts anyway

  3926     isXUL = true;

  3927   }

  3929   // Figure out if we are a generic font

  3930   uint8_t generic = kGenericFont_NONE;

  3931   // XXXldb What if we would have had a string if we hadn't been doing

  3932   // the optimization with a non-null aStartStruct?

  3933   const nsCSSValue* familyValue = aRuleData->ValueForFontFamily();

  3934   if (eCSSUnit_Families == familyValue->GetUnit()) {

  3935     familyValue->GetStringValue(font->mFont.name);

  3936     // XXXldb Do we want to extract the generic for this if it's not only a

  3937     // generic?

  3938     nsFont::GetGenericID(font->mFont.name, &generic);

  3940     if (!isXUL) {

  3941       gfxUserFontSet *userFonts = mPresContext->GetUserFontSet();

  3942       if (userFonts) {

  3943         smugglerStruct sm;

  3944         sm.userFonts = userFonts;

  3945         sm.font = font;

  3947         if (!sm.font->mFont.EnumerateFamilies(ForceFirstWebFont, &sm)) {

  3948           isXUL = true; // Always allow WebFont use.

  3949           forcedWebFont = true;

  3950         }

  3951       }

  3952     }

  3954     if (!forcedWebFont && generic == kGenericFont_NONE)

  3955       mPresContext->AddFontAttempt(font->mFont);

  3957     // If we aren't allowed to use document fonts, then we are only entitled

  3958     // to use the user's default variable-width font and fixed-width font

  3959     if (!isXUL && (!useDocumentFonts ||

  3960                     mPresContext->FontAttemptCountReached(font->mFont) ||

  3961                     mPresContext->FontUseCountReached(font->mFont))) {

  3962       // Extract the generic from the specified font family...

  3963       nsAutoString genericName;

  3964       if (!font->mFont.EnumerateFamilies(ExtractGeneric, &genericName)) {

  3965         // The specified font had a generic family.

  3966         font->mFont.name = genericName;

  3967         nsFont::GetGenericID(genericName, &generic);

  3969         // ... and only use it if it's -moz-fixed or monospace

  3970         if (generic != kGenericFont_moz_fixed &&

  3971             generic != kGenericFont_monospace) {

  3972           font->mFont.name.Truncate();

  3973           generic = kGenericFont_NONE;

  3974         }

  3975       } else {

  3976         // The specified font did not have a generic family.

  3977         font->mFont.name.Truncate();

  3978         generic = kGenericFont_NONE;

  3979       }

  3980     }

  3981   }

  3983   // Now compute our font struct

  3984   if (generic == kGenericFont_NONE) {

  3985     // continue the normal processing

  3986     nsRuleNode::SetFont(mPresContext, aContext, generic,

  3987                         aRuleData, parentFont, font,

  3988                         aStartStruct != nullptr, canStoreInRuleTree);

  3989   }

  3990   else {

  3991     // re-calculate the font as a generic font

  3992     canStoreInRuleTree = false;

  3993     nsRuleNode::SetGenericFont(mPresContext, aContext, generic,

  3994                                font);

  3995   }

  3997   if (!forcedWebFont && font->mGenericID == kGenericFont_NONE)

  3998     mPresContext->AddFontUse(font->mFont);

  3999   COMPUTE_END_INHERITED(Font, font)

  4000 }

  4002 template <typename T>

  4003 inline uint32_t ListLength(const T* aList)

  4004 {

  4005   uint32_t len = 0;

  4006   while (aList) {

  4007     len++;

  4008     aList = aList->mNext;

  4009   }

  4010   return len;

  4011 }

  4015 already_AddRefed<nsCSSShadowArray>

  4016 nsRuleNode::GetShadowData(const nsCSSValueList* aList,

  4017                           nsStyleContext* aContext,

  4018                           bool aIsBoxShadow,

  4019                           bool& aCanStoreInRuleTree)

  4020 {

  4021   uint32_t arrayLength = ListLength(aList);

  4023   NS_ABORT_IF_FALSE(arrayLength > 0,

  4024                     "Non-null text-shadow list, yet we counted 0 items.");

  4025   nsRefPtr<nsCSSShadowArray> shadowList =

  4026     new(arrayLength) nsCSSShadowArray(arrayLength);

  4028   if (!shadowList)

  4029     return nullptr;

  4031   nsStyleCoord tempCoord;

  4032   DebugOnly<bool> unitOK;

  4033   for (nsCSSShadowItem* item = shadowList->ShadowAt(0);

  4034        aList;

  4035        aList = aList->mNext, ++item) {

  4036     NS_ABORT_IF_FALSE(aList->mValue.GetUnit() == eCSSUnit_Array,

  4037                       "expecting a plain array value");

  4038     nsCSSValue::Array *arr = aList->mValue.GetArrayValue();

  4039     // OK to pass bad aParentCoord since we're not passing SETCOORD_INHERIT

  4040     unitOK = SetCoord(arr->Item(0), tempCoord, nsStyleCoord(),

  4041                       SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY,

  4042                       aContext, mPresContext, aCanStoreInRuleTree);

  4043     NS_ASSERTION(unitOK, "unexpected unit");

  4044     item->mXOffset = tempCoord.GetCoordValue();

  4046     unitOK = SetCoord(arr->Item(1), tempCoord, nsStyleCoord(),

  4047                       SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY,

  4048                       aContext, mPresContext, aCanStoreInRuleTree);

  4049     NS_ASSERTION(unitOK, "unexpected unit");

  4050     item->mYOffset = tempCoord.GetCoordValue();

  4052     // Blur radius is optional in the current box-shadow spec

  4053     if (arr->Item(2).GetUnit() != eCSSUnit_Null) {

  4054       unitOK = SetCoord(arr->Item(2), tempCoord, nsStyleCoord(),

  4055                         SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY |

  4056                           SETCOORD_CALC_CLAMP_NONNEGATIVE,

  4057                         aContext, mPresContext, aCanStoreInRuleTree);

  4058       NS_ASSERTION(unitOK, "unexpected unit");

  4059       item->mRadius = tempCoord.GetCoordValue();

  4060     } else {

  4061       item->mRadius = 0;

  4062     }

  4064     // Find the spread radius

  4065     if (aIsBoxShadow && arr->Item(3).GetUnit() != eCSSUnit_Null) {

  4066       unitOK = SetCoord(arr->Item(3), tempCoord, nsStyleCoord(),

  4067                         SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY,

  4068                         aContext, mPresContext, aCanStoreInRuleTree);

  4069       NS_ASSERTION(unitOK, "unexpected unit");

  4070       item->mSpread = tempCoord.GetCoordValue();

  4071     } else {

  4072       item->mSpread = 0;

  4073     }

  4075     if (arr->Item(4).GetUnit() != eCSSUnit_Null) {

  4076       item->mHasColor = true;

  4077       // 2nd argument can be bogus since inherit is not a valid color

  4078       unitOK = SetColor(arr->Item(4), 0, mPresContext, aContext, item->mColor,

  4079                         aCanStoreInRuleTree);

  4080       NS_ASSERTION(unitOK, "unexpected unit");

  4081     }

  4083     if (aIsBoxShadow && arr->Item(5).GetUnit() == eCSSUnit_Enumerated) {

  4084       NS_ASSERTION(arr->Item(5).GetIntValue() == NS_STYLE_BOX_SHADOW_INSET,

  4085                    "invalid keyword type for box shadow");

  4086       item->mInset = true;

  4087     } else {

  4088       item->mInset = false;

  4089     }

  4090   }

  4092   return shadowList.forget();

  4093 }

  4095 const void*

  4096 nsRuleNode::ComputeTextData(void* aStartStruct,

  4097                             const nsRuleData* aRuleData,

  4098                             nsStyleContext* aContext,

  4099                             nsRuleNode* aHighestNode,

  4100                             const RuleDetail aRuleDetail,

  4101                             const bool aCanStoreInRuleTree)

  4102 {

  4103   COMPUTE_START_INHERITED(Text, (), text, parentText)

  4105   // tab-size: integer, inherit

  4106   SetDiscrete(*aRuleData->ValueForTabSize(),

  4107               text->mTabSize, canStoreInRuleTree,

  4108               SETDSC_INTEGER | SETDSC_UNSET_INHERIT, parentText->mTabSize,

  4109               NS_STYLE_TABSIZE_INITIAL, 0, 0, 0, 0);

  4111   // letter-spacing: normal, length, inherit

  4112   SetCoord(*aRuleData->ValueForLetterSpacing(),

  4113            text->mLetterSpacing, parentText->mLetterSpacing,

  4114            SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL |

  4115              SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INHERIT,

  4116            aContext, mPresContext, canStoreInRuleTree);

  4118   // text-shadow: none, list, inherit, initial

  4119   const nsCSSValue* textShadowValue = aRuleData->ValueForTextShadow();

  4120   if (textShadowValue->GetUnit() != eCSSUnit_Null) {

  4121     text->mTextShadow = nullptr;

  4123     // Don't need to handle none/initial explicitly: The above assignment

  4124     // takes care of that

  4125     if (textShadowValue->GetUnit() == eCSSUnit_Inherit ||

  4126         textShadowValue->GetUnit() == eCSSUnit_Unset) {

  4127       canStoreInRuleTree = false;

  4128       text->mTextShadow = parentText->mTextShadow;

  4129     } else if (textShadowValue->GetUnit() == eCSSUnit_List ||

  4130                textShadowValue->GetUnit() == eCSSUnit_ListDep) {

  4131       // List of arrays

  4132       text->mTextShadow = GetShadowData(textShadowValue->GetListValue(),

  4133                                         aContext, false, canStoreInRuleTree);

  4134     }

  4135   }

  4137   // line-height: normal, number, length, percent, inherit

  4138   const nsCSSValue* lineHeightValue = aRuleData->ValueForLineHeight();

  4139   if (eCSSUnit_Percent == lineHeightValue->GetUnit()) {

  4140     canStoreInRuleTree = false;

  4141     // Use |mFont.size| to pick up minimum font size.

  4142     text->mLineHeight.SetCoordValue(

  4143         NSToCoordRound(float(aContext->StyleFont()->mFont.size) *

  4144                        lineHeightValue->GetPercentValue()));

  4145   }

  4146   else if (eCSSUnit_Initial == lineHeightValue->GetUnit() ||

  4147            eCSSUnit_System_Font == lineHeightValue->GetUnit()) {

  4148     text->mLineHeight.SetNormalValue();

  4149   }

  4150   else {

  4151     SetCoord(*lineHeightValue, text->mLineHeight, parentText->mLineHeight,

  4152              SETCOORD_LEH | SETCOORD_FACTOR | SETCOORD_NORMAL |

  4153                SETCOORD_UNSET_INHERIT,

  4154              aContext, mPresContext, canStoreInRuleTree);

  4155     if (lineHeightValue->IsLengthUnit() &&

  4156         !lineHeightValue->IsRelativeLengthUnit()) {

  4157       nscoord lh = nsStyleFont::ZoomText(mPresContext,

  4158                                          text->mLineHeight.GetCoordValue());

  4160       canStoreInRuleTree = false;

  4161       const nsStyleFont *font = aContext->StyleFont();

  4162       nscoord minimumFontSize = mPresContext->MinFontSize(font->mLanguage);

  4164       if (minimumFontSize > 0 && !mPresContext->IsChrome()) {

  4165         if (font->mSize != 0) {

  4166           lh = nscoord(float(lh) * float(font->mFont.size) / float(font->mSize));

  4167         } else {

  4168           lh = minimumFontSize;

  4169         }

  4170       }

  4171       text->mLineHeight.SetCoordValue(lh);

  4172     }

  4173   }

  4176   // text-align: enum, string, pair(enum|string), inherit, initial

  4177   // NOTE: string is not implemented yet.

  4178   const nsCSSValue* textAlignValue = aRuleData->ValueForTextAlign();

  4179   text->mTextAlignTrue = false;

  4180   if (eCSSUnit_String == textAlignValue->GetUnit()) {

  4181     NS_NOTYETIMPLEMENTED("align string");

  4182   } else if (eCSSUnit_Enumerated == textAlignValue->GetUnit() &&

  4183              NS_STYLE_TEXT_ALIGN_MOZ_CENTER_OR_INHERIT ==

  4184                textAlignValue->GetIntValue()) {

  4185     canStoreInRuleTree = false;

  4186     uint8_t parentAlign = parentText->mTextAlign;

  4187     text->mTextAlign = (NS_STYLE_TEXT_ALIGN_DEFAULT == parentAlign) ?

  4188       NS_STYLE_TEXT_ALIGN_CENTER : parentAlign;

  4189   } else {

  4190     if (eCSSUnit_Pair == textAlignValue->GetUnit()) {

  4191       // Two values were specified, one must be 'true'.

  4192       text->mTextAlignTrue = true;

  4193       const nsCSSValuePair& textAlignValuePair = textAlignValue->GetPairValue();

  4194       textAlignValue = &textAlignValuePair.mXValue;

  4195       if (eCSSUnit_Enumerated == textAlignValue->GetUnit()) {

  4196         if (textAlignValue->GetIntValue() == NS_STYLE_TEXT_ALIGN_TRUE) {

  4197           textAlignValue = &textAlignValuePair.mYValue;

  4198         }

  4199       } else if (eCSSUnit_String == textAlignValue->GetUnit()) {

  4200         NS_NOTYETIMPLEMENTED("align string");

  4201       }

  4202     } else if (eCSSUnit_Inherit == textAlignValue->GetUnit() ||

  4203                eCSSUnit_Unset == textAlignValue->GetUnit()) {

  4204       text->mTextAlignTrue = parentText->mTextAlignTrue;

  4205     }

  4206     SetDiscrete(*textAlignValue, text->mTextAlign, canStoreInRuleTree,

  4207                 SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4208                 parentText->mTextAlign,

  4209                 NS_STYLE_TEXT_ALIGN_DEFAULT, 0, 0, 0, 0);

  4210   }

  4212   // text-align-last: enum, pair(enum), inherit, initial

  4213   const nsCSSValue* textAlignLastValue = aRuleData->ValueForTextAlignLast();

  4214   text->mTextAlignLastTrue = false;

  4215   if (eCSSUnit_Pair == textAlignLastValue->GetUnit()) {

  4216     // Two values were specified, one must be 'true'.

  4217     text->mTextAlignLastTrue = true;

  4218     const nsCSSValuePair& textAlignLastValuePair = textAlignLastValue->GetPairValue();

  4219     textAlignLastValue = &textAlignLastValuePair.mXValue;

  4220     if (eCSSUnit_Enumerated == textAlignLastValue->GetUnit()) {

  4221       if (textAlignLastValue->GetIntValue() == NS_STYLE_TEXT_ALIGN_TRUE) {

  4222         textAlignLastValue = &textAlignLastValuePair.mYValue;

  4223       }

  4224     }

  4225   } else if (eCSSUnit_Inherit == textAlignLastValue->GetUnit() ||

  4226              eCSSUnit_Unset == textAlignLastValue->GetUnit()) {

  4227     text->mTextAlignLastTrue = parentText->mTextAlignLastTrue;

  4228   }

  4229   SetDiscrete(*textAlignLastValue, text->mTextAlignLast,

  4230               canStoreInRuleTree,

  4231               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4232               parentText->mTextAlignLast,

  4233               NS_STYLE_TEXT_ALIGN_AUTO, 0, 0, 0, 0);

  4235   // text-indent: length, percent, calc, inherit, initial

  4236   SetCoord(*aRuleData->ValueForTextIndent(), text->mTextIndent, parentText->mTextIndent,

  4237            SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |

  4238              SETCOORD_UNSET_INHERIT,

  4239            aContext, mPresContext, canStoreInRuleTree);

  4241   // text-transform: enum, inherit, initial

  4242   SetDiscrete(*aRuleData->ValueForTextTransform(), text->mTextTransform, canStoreInRuleTree,

  4243               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4244               parentText->mTextTransform,

  4245               NS_STYLE_TEXT_TRANSFORM_NONE, 0, 0, 0, 0);

  4247   // white-space: enum, inherit, initial

  4248   SetDiscrete(*aRuleData->ValueForWhiteSpace(), text->mWhiteSpace, canStoreInRuleTree,

  4249               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4250               parentText->mWhiteSpace,

  4251               NS_STYLE_WHITESPACE_NORMAL, 0, 0, 0, 0);

  4253   // word-break: enum, inherit, initial

  4254   SetDiscrete(*aRuleData->ValueForWordBreak(), text->mWordBreak, canStoreInRuleTree,

  4255               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4256               parentText->mWordBreak,

  4257               NS_STYLE_WORDBREAK_NORMAL, 0, 0, 0, 0);

  4259   // word-spacing: normal, length, inherit

  4260   nsStyleCoord tempCoord;

  4261   const nsCSSValue* wordSpacingValue = aRuleData->ValueForWordSpacing();

  4262   if (SetCoord(*wordSpacingValue, tempCoord,

  4263                nsStyleCoord(parentText->mWordSpacing,

  4264                             nsStyleCoord::CoordConstructor),

  4265                SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL |

  4266                  SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INHERIT,

  4267                aContext, mPresContext, canStoreInRuleTree)) {

  4268     if (tempCoord.GetUnit() == eStyleUnit_Coord) {

  4269       text->mWordSpacing = tempCoord.GetCoordValue();

  4270     } else if (tempCoord.GetUnit() == eStyleUnit_Normal) {

  4271       text->mWordSpacing = 0;

  4272     } else {

  4273       NS_NOTREACHED("unexpected unit");

  4274     }

  4275   } else {

  4276     NS_ASSERTION(wordSpacingValue->GetUnit() == eCSSUnit_Null,

  4277                  "unexpected unit");

  4278   }

  4280   // word-wrap: enum, inherit, initial

  4281   SetDiscrete(*aRuleData->ValueForWordWrap(), text->mWordWrap, canStoreInRuleTree,

  4282               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4283               parentText->mWordWrap,

  4284               NS_STYLE_WORDWRAP_NORMAL, 0, 0, 0, 0);

  4286   // hyphens: enum, inherit, initial

  4287   SetDiscrete(*aRuleData->ValueForHyphens(), text->mHyphens, canStoreInRuleTree,

  4288               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4289               parentText->mHyphens,

  4290               NS_STYLE_HYPHENS_MANUAL, 0, 0, 0, 0);

  4292   // text-size-adjust: none, auto, inherit, initial

  4293   SetDiscrete(*aRuleData->ValueForTextSizeAdjust(), text->mTextSizeAdjust,

  4294               canStoreInRuleTree,

  4295               SETDSC_NONE | SETDSC_AUTO | SETDSC_UNSET_INHERIT,

  4296               parentText->mTextSizeAdjust,

  4297               NS_STYLE_TEXT_SIZE_ADJUST_AUTO, // initial value

  4298               NS_STYLE_TEXT_SIZE_ADJUST_AUTO, // auto value

  4299               NS_STYLE_TEXT_SIZE_ADJUST_NONE, // none value

  4300               0, 0);

  4302   // -moz-text-discard: enum, inherit, initial

  4303   SetDiscrete(*aRuleData->ValueForControlCharacterVisibility(),

  4304               text->mControlCharacterVisibility,

  4305               canStoreInRuleTree,

  4306               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4307               parentText->mControlCharacterVisibility,

  4308               NS_STYLE_CONTROL_CHARACTER_VISIBILITY_HIDDEN, 0, 0, 0, 0);

  4310   // text-orientation: enum, inherit, initial

  4311   SetDiscrete(*aRuleData->ValueForTextOrientation(), text->mTextOrientation,

  4312               canStoreInRuleTree,

  4313               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4314               parentText->mTextOrientation,

  4315               NS_STYLE_TEXT_ORIENTATION_AUTO, 0, 0, 0, 0);

  4317   // text-combine-upright: enum, inherit, initial

  4318   SetDiscrete(*aRuleData->ValueForTextCombineUpright(),

  4319               text->mTextCombineUpright,

  4320               canStoreInRuleTree,

  4321               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4322               parentText->mTextCombineUpright,

  4323               NS_STYLE_TEXT_COMBINE_UPRIGHT_NONE, 0, 0, 0, 0);

  4325   COMPUTE_END_INHERITED(Text, text)

  4326 }

  4328 const void*

  4329 nsRuleNode::ComputeTextResetData(void* aStartStruct,

  4330                                  const nsRuleData* aRuleData,

  4331                                  nsStyleContext* aContext,

  4332                                  nsRuleNode* aHighestNode,

  4333                                  const RuleDetail aRuleDetail,

  4334                                  const bool aCanStoreInRuleTree)

  4335 {

  4336   COMPUTE_START_RESET(TextReset, (), text, parentText)

  4338   // vertical-align: enum, length, percent, calc, inherit

  4339   const nsCSSValue* verticalAlignValue = aRuleData->ValueForVerticalAlign();

  4340   if (!SetCoord(*verticalAlignValue, text->mVerticalAlign,

  4341                 parentText->mVerticalAlign,

  4342                 SETCOORD_LPH | SETCOORD_ENUMERATED | SETCOORD_STORE_CALC,

  4343                 aContext, mPresContext, canStoreInRuleTree)) {

  4344     if (eCSSUnit_Initial == verticalAlignValue->GetUnit() ||

  4345         eCSSUnit_Unset == verticalAlignValue->GetUnit()) {

  4346       text->mVerticalAlign.SetIntValue(NS_STYLE_VERTICAL_ALIGN_BASELINE,

  4347                                        eStyleUnit_Enumerated);

  4348     }

  4349   }

  4351   // text-decoration-line: enum (bit field), inherit, initial

  4352   const nsCSSValue* decorationLineValue =

  4353     aRuleData->ValueForTextDecorationLine();

  4354   if (eCSSUnit_Enumerated == decorationLineValue->GetUnit()) {

  4355     int32_t td = decorationLineValue->GetIntValue();

  4356     text->mTextDecorationLine = td;

  4357     if (td & NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS) {

  4358       bool underlineLinks =

  4359         mPresContext->GetCachedBoolPref(kPresContext_UnderlineLinks);

  4360       if (underlineLinks) {

  4361         text->mTextDecorationLine |= NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE;

  4362       }

  4363       else {

  4364         text->mTextDecorationLine &= ~NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE;

  4365       }

  4366     }

  4367   } else if (eCSSUnit_Inherit == decorationLineValue->GetUnit()) {

  4368     canStoreInRuleTree = false;

  4369     text->mTextDecorationLine = parentText->mTextDecorationLine;

  4370   } else if (eCSSUnit_Initial == decorationLineValue->GetUnit() ||

  4371              eCSSUnit_Unset == decorationLineValue->GetUnit()) {

  4372     text->mTextDecorationLine = NS_STYLE_TEXT_DECORATION_LINE_NONE;

  4373   }

  4375   // text-decoration-color: color, string, enum, inherit, initial

  4376   const nsCSSValue* decorationColorValue =

  4377     aRuleData->ValueForTextDecorationColor();

  4378   nscolor decorationColor;

  4379   if (eCSSUnit_Inherit == decorationColorValue->GetUnit()) {

  4380     canStoreInRuleTree = false;

  4381     if (parentContext) {

  4382       bool isForeground;

  4383       parentText->GetDecorationColor(decorationColor, isForeground);

  4384       if (isForeground) {

  4385         text->SetDecorationColor(parentContext->StyleColor()->mColor);

  4386       } else {

  4387         text->SetDecorationColor(decorationColor);

  4388       }

  4389     } else {

  4390       text->SetDecorationColorToForeground();

  4391     }

  4392   }

  4393   else if (eCSSUnit_EnumColor == decorationColorValue->GetUnit() &&

  4394            decorationColorValue->GetIntValue() == NS_COLOR_CURRENTCOLOR) {

  4395     text->SetDecorationColorToForeground();

  4396   }

  4397   else if (SetColor(*decorationColorValue, 0, mPresContext, aContext,

  4398                     decorationColor, canStoreInRuleTree)) {

  4399     text->SetDecorationColor(decorationColor);

  4400   }

  4401   else if (eCSSUnit_Initial == decorationColorValue->GetUnit() ||

  4402            eCSSUnit_Unset == decorationColorValue->GetUnit() ||

  4403            eCSSUnit_Enumerated == decorationColorValue->GetUnit()) {

  4404     NS_ABORT_IF_FALSE(eCSSUnit_Enumerated != decorationColorValue->GetUnit() ||

  4405                       decorationColorValue->GetIntValue() ==

  4406                         NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR,

  4407                       "unexpected enumerated value");

  4408     text->SetDecorationColorToForeground();

  4409   }

  4411   // text-decoration-style: enum, inherit, initial

  4412   const nsCSSValue* decorationStyleValue =

  4413     aRuleData->ValueForTextDecorationStyle();

  4414   if (eCSSUnit_Enumerated == decorationStyleValue->GetUnit()) {

  4415     text->SetDecorationStyle(decorationStyleValue->GetIntValue());

  4416   } else if (eCSSUnit_Inherit == decorationStyleValue->GetUnit()) {

  4417     text->SetDecorationStyle(parentText->GetDecorationStyle());

  4418     canStoreInRuleTree = false;

  4419   } else if (eCSSUnit_Initial == decorationStyleValue->GetUnit() ||

  4420              eCSSUnit_Unset == decorationStyleValue->GetUnit()) {

  4421     text->SetDecorationStyle(NS_STYLE_TEXT_DECORATION_STYLE_SOLID);

  4422   }

  4424   // text-overflow: enum, string, pair(enum|string), inherit, initial

  4425   const nsCSSValue* textOverflowValue =

  4426     aRuleData->ValueForTextOverflow();

  4427   if (eCSSUnit_Initial == textOverflowValue->GetUnit() ||

  4428       eCSSUnit_Unset == textOverflowValue->GetUnit()) {

  4429     text->mTextOverflow = nsStyleTextOverflow();

  4430   } else if (eCSSUnit_Inherit == textOverflowValue->GetUnit()) {

  4431     canStoreInRuleTree = false;

  4432     text->mTextOverflow = parentText->mTextOverflow;

  4433   } else if (eCSSUnit_Enumerated == textOverflowValue->GetUnit()) {

  4434     // A single enumerated value.

  4435     SetDiscrete(*textOverflowValue, text->mTextOverflow.mRight.mType,

  4436                 canStoreInRuleTree,

  4437                 SETDSC_ENUMERATED, parentText->mTextOverflow.mRight.mType,

  4438                 NS_STYLE_TEXT_OVERFLOW_CLIP, 0, 0, 0, 0);

  4439     text->mTextOverflow.mRight.mString.Truncate();

  4440     text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_CLIP;

  4441     text->mTextOverflow.mLeft.mString.Truncate();

  4442     text->mTextOverflow.mLogicalDirections = true;

  4443   } else if (eCSSUnit_String == textOverflowValue->GetUnit()) {

  4444     // A single string value.

  4445     text->mTextOverflow.mRight.mType = NS_STYLE_TEXT_OVERFLOW_STRING;

  4446     textOverflowValue->GetStringValue(text->mTextOverflow.mRight.mString);

  4447     text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_CLIP;

  4448     text->mTextOverflow.mLeft.mString.Truncate();

  4449     text->mTextOverflow.mLogicalDirections = true;

  4450   } else if (eCSSUnit_Pair == textOverflowValue->GetUnit()) {

  4451     // Two values were specified.

  4452     text->mTextOverflow.mLogicalDirections = false;

  4453     const nsCSSValuePair& textOverflowValuePair =

  4454       textOverflowValue->GetPairValue();

  4456     const nsCSSValue *textOverflowLeftValue = &textOverflowValuePair.mXValue;

  4457     if (eCSSUnit_Enumerated == textOverflowLeftValue->GetUnit()) {

  4458       SetDiscrete(*textOverflowLeftValue, text->mTextOverflow.mLeft.mType,

  4459                   canStoreInRuleTree,

  4460                   SETDSC_ENUMERATED, parentText->mTextOverflow.mLeft.mType,

  4461                   NS_STYLE_TEXT_OVERFLOW_CLIP, 0, 0, 0, 0);

  4462       text->mTextOverflow.mLeft.mString.Truncate();

  4463     } else if (eCSSUnit_String == textOverflowLeftValue->GetUnit()) {

  4464       textOverflowLeftValue->GetStringValue(text->mTextOverflow.mLeft.mString);

  4465       text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_STRING;

  4466     }

  4468     const nsCSSValue *textOverflowRightValue = &textOverflowValuePair.mYValue;

  4469     if (eCSSUnit_Enumerated == textOverflowRightValue->GetUnit()) {

  4470       SetDiscrete(*textOverflowRightValue, text->mTextOverflow.mRight.mType,

  4471                   canStoreInRuleTree,

  4472                   SETDSC_ENUMERATED, parentText->mTextOverflow.mRight.mType,

  4473                   NS_STYLE_TEXT_OVERFLOW_CLIP, 0, 0, 0, 0);

  4474       text->mTextOverflow.mRight.mString.Truncate();

  4475     } else if (eCSSUnit_String == textOverflowRightValue->GetUnit()) {

  4476       textOverflowRightValue->GetStringValue(text->mTextOverflow.mRight.mString);

  4477       text->mTextOverflow.mRight.mType = NS_STYLE_TEXT_OVERFLOW_STRING;

  4478     }

  4479   }

  4481   // unicode-bidi: enum, inherit, initial

  4482   SetDiscrete(*aRuleData->ValueForUnicodeBidi(), text->mUnicodeBidi, canStoreInRuleTree,

  4483               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  4484               parentText->mUnicodeBidi,

  4485               NS_STYLE_UNICODE_BIDI_NORMAL, 0, 0, 0, 0);

  4487   COMPUTE_END_RESET(TextReset, text)

  4488 }

  4490 const void*

  4491 nsRuleNode::ComputeUserInterfaceData(void* aStartStruct,

  4492                                      const nsRuleData* aRuleData,

  4493                                      nsStyleContext* aContext,

  4494                                      nsRuleNode* aHighestNode,

  4495                                      const RuleDetail aRuleDetail,

  4496                                      const bool aCanStoreInRuleTree)

  4497 {

  4498   COMPUTE_START_INHERITED(UserInterface, (), ui, parentUI)

  4500   // cursor: enum, url, inherit

  4501   const nsCSSValue* cursorValue = aRuleData->ValueForCursor();

  4502   nsCSSUnit cursorUnit = cursorValue->GetUnit();

  4503   if (cursorUnit != eCSSUnit_Null) {

  4504     delete [] ui->mCursorArray;

  4505     ui->mCursorArray = nullptr;

  4506     ui->mCursorArrayLength = 0;

  4508     if (cursorUnit == eCSSUnit_Inherit ||

  4509         cursorUnit == eCSSUnit_Unset) {

  4510       canStoreInRuleTree = false;

  4511       ui->mCursor = parentUI->mCursor;

  4512       ui->CopyCursorArrayFrom(*parentUI);

  4513     }

  4514     else if (cursorUnit == eCSSUnit_Initial) {

  4515       ui->mCursor = NS_STYLE_CURSOR_AUTO;

  4516     }

  4517     else {

  4518       // The parser will never create a list that is *all* URL values --

  4519       // that's invalid.

  4520       NS_ABORT_IF_FALSE(cursorUnit == eCSSUnit_List ||

  4521                         cursorUnit == eCSSUnit_ListDep,

  4522                         nsPrintfCString("unrecognized cursor unit %d",

  4523                                         cursorUnit).get());

  4524       const nsCSSValueList* list = cursorValue->GetListValue();

  4525       const nsCSSValueList* list2 = list;

  4526       nsIDocument* doc = aContext->PresContext()->Document();

  4527       uint32_t arrayLength = 0;

  4528       for ( ; list->mValue.GetUnit() == eCSSUnit_Array; list = list->mNext)

  4529         if (list->mValue.GetArrayValue()->Item(0).GetImageValue(doc))

  4530           ++arrayLength;

  4532       if (arrayLength != 0) {

  4533         ui->mCursorArray = new nsCursorImage[arrayLength];

  4534         if (ui->mCursorArray) {

  4535           ui->mCursorArrayLength = arrayLength;

  4537           for (nsCursorImage *item = ui->mCursorArray;

  4538                list2->mValue.GetUnit() == eCSSUnit_Array;

  4539                list2 = list2->mNext) {

  4540             nsCSSValue::Array *arr = list2->mValue.GetArrayValue();

  4541             imgIRequest *req = arr->Item(0).GetImageValue(doc);

  4542             if (req) {

  4543               item->SetImage(req);

  4544               if (arr->Item(1).GetUnit() != eCSSUnit_Null) {

  4545                 item->mHaveHotspot = true;

  4546                 item->mHotspotX = arr->Item(1).GetFloatValue(),

  4547                 item->mHotspotY = arr->Item(2).GetFloatValue();

  4548               }

  4549               ++item;

  4550             }

  4551           }

  4552         }

  4553       }

  4555       NS_ASSERTION(list, "Must have non-array value at the end");

  4556       NS_ASSERTION(list->mValue.GetUnit() == eCSSUnit_Enumerated,

  4557                    "Unexpected fallback value at end of cursor list");

  4558       ui->mCursor = list->mValue.GetIntValue();

  4559     }

  4560   }

  4562   // user-input: enum, inherit, initial

  4563   SetDiscrete(*aRuleData->ValueForUserInput(),

  4564               ui->mUserInput, canStoreInRuleTree,

  4565               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4566               parentUI->mUserInput,

  4567               NS_STYLE_USER_INPUT_AUTO, 0, 0, 0, 0);

  4569   // user-modify: enum, inherit, initial

  4570   SetDiscrete(*aRuleData->ValueForUserModify(),

  4571               ui->mUserModify, canStoreInRuleTree,

  4572               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4573               parentUI->mUserModify,

  4574               NS_STYLE_USER_MODIFY_READ_ONLY,

  4575               0, 0, 0, 0);

  4577   // user-focus: enum, inherit, initial

  4578   SetDiscrete(*aRuleData->ValueForUserFocus(),

  4579               ui->mUserFocus, canStoreInRuleTree,

  4580               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  4581               parentUI->mUserFocus,

  4582               NS_STYLE_USER_FOCUS_NONE, 0, 0, 0, 0);

  4584   COMPUTE_END_INHERITED(UserInterface, ui)

  4585 }

  4587 const void*

  4588 nsRuleNode::ComputeUIResetData(void* aStartStruct,

  4589                                const nsRuleData* aRuleData,

  4590                                nsStyleContext* aContext,

  4591                                nsRuleNode* aHighestNode,

  4592                                const RuleDetail aRuleDetail,

  4593                                const bool aCanStoreInRuleTree)

  4594 {

  4595   COMPUTE_START_RESET(UIReset, (), ui, parentUI)

  4597   // user-select: enum, inherit, initial

  4598   SetDiscrete(*aRuleData->ValueForUserSelect(),

  4599               ui->mUserSelect, canStoreInRuleTree,

  4600               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  4601               parentUI->mUserSelect,

  4602               NS_STYLE_USER_SELECT_AUTO, 0, 0, 0, 0);

  4604   // ime-mode: enum, inherit, initial

  4605   SetDiscrete(*aRuleData->ValueForImeMode(),

  4606               ui->mIMEMode, canStoreInRuleTree,

  4607               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  4608               parentUI->mIMEMode,

  4609               NS_STYLE_IME_MODE_AUTO, 0, 0, 0, 0);

  4611   // force-broken-image-icons: integer, inherit, initial

  4612   SetDiscrete(*aRuleData->ValueForForceBrokenImageIcon(),

  4613               ui->mForceBrokenImageIcon,

  4614               canStoreInRuleTree,

  4615               SETDSC_INTEGER | SETDSC_UNSET_INITIAL,

  4616               parentUI->mForceBrokenImageIcon,

  4617               0, 0, 0, 0, 0);

  4619   // -moz-window-shadow: enum, inherit, initial

  4620   SetDiscrete(*aRuleData->ValueForWindowShadow(),

  4621               ui->mWindowShadow, canStoreInRuleTree,

  4622               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  4623               parentUI->mWindowShadow,

  4624               NS_STYLE_WINDOW_SHADOW_DEFAULT, 0, 0, 0, 0);

  4626   COMPUTE_END_RESET(UIReset, ui)

  4627 }

  4629 // Information about each transition or animation property that is

  4630 // constant.

  4631 struct TransitionPropInfo {

  4632   nsCSSProperty property;

  4633   // Location of the count of the property's computed value.

  4634   uint32_t nsStyleDisplay::* sdCount;

  4635 };

  4637 // Each property's index in this array must match its index in the

  4638 // mutable array |transitionPropData| below.

  4639 static const TransitionPropInfo transitionPropInfo[4] = {

  4640   { eCSSProperty_transition_delay,

  4641     &nsStyleDisplay::mTransitionDelayCount },

  4642   { eCSSProperty_transition_duration,

  4643     &nsStyleDisplay::mTransitionDurationCount },

  4644   { eCSSProperty_transition_property,

  4645     &nsStyleDisplay::mTransitionPropertyCount },

  4646   { eCSSProperty_transition_timing_function,

  4647     &nsStyleDisplay::mTransitionTimingFunctionCount },

  4648 };

  4650 // Each property's index in this array must match its index in the

  4651 // mutable array |animationPropData| below.

  4652 static const TransitionPropInfo animationPropInfo[8] = {

  4653   { eCSSProperty_animation_delay,

  4654     &nsStyleDisplay::mAnimationDelayCount },

  4655   { eCSSProperty_animation_duration,

  4656     &nsStyleDisplay::mAnimationDurationCount },

  4657   { eCSSProperty_animation_name,

  4658     &nsStyleDisplay::mAnimationNameCount },

  4659   { eCSSProperty_animation_timing_function,

  4660     &nsStyleDisplay::mAnimationTimingFunctionCount },

  4661   { eCSSProperty_animation_direction,

  4662     &nsStyleDisplay::mAnimationDirectionCount },

  4663   { eCSSProperty_animation_fill_mode,

  4664     &nsStyleDisplay::mAnimationFillModeCount },

  4665   { eCSSProperty_animation_play_state,

  4666     &nsStyleDisplay::mAnimationPlayStateCount },

  4667   { eCSSProperty_animation_iteration_count,

  4668     &nsStyleDisplay::mAnimationIterationCountCount },

  4669 };

  4671 // Information about each transition or animation property that changes

  4672 // during ComputeDisplayData.

  4673 struct TransitionPropData {

  4674   const nsCSSValueList *list;

  4675   nsCSSUnit unit;

  4676   uint32_t num;

  4677 };

  4679 static uint32_t

  4680 CountTransitionProps(const TransitionPropInfo* aInfo,

  4681                      TransitionPropData* aData,

  4682                      size_t aLength,

  4683                      nsStyleDisplay* aDisplay,

  4684                      const nsStyleDisplay* aParentDisplay,

  4685                      const nsRuleData* aRuleData,

  4686                      bool& aCanStoreInRuleTree)

  4687 {

  4688   // The four transition properties or eight animation properties are

  4689   // stored in nsCSSDisplay in a single array for all properties.  The

  4690   // number of transitions is equal to the number of items in the

  4691   // longest property's value.  Properties that have fewer values than

  4692   // the longest are filled in by repeating the list.  However, this

  4693   // repetition does not extend the computed value of that particular

  4694   // property (for purposes of inheritance, or, in our code, for when

  4695   // other properties are overridden by a more specific rule).

  4697   // But actually, since the spec isn't clear yet, we'll fully compute

  4698   // all of them (so we can switch easily later), but only care about

  4699   // the ones up to the number of items for 'transition-property', per

  4700   // http://lists.w3.org/Archives/Public/www-style/2009Aug/0109.html .

  4702   // Transitions are difficult to handle correctly because of this.  For

  4703   // example, we need to handle scenarios such as:

  4704   //  * a more general rule specifies transition-property: a, b, c;

  4705   //  * a more specific rule overrides as transition-property: d;

  4706   //

  4707   // If only the general rule applied, we would fill in the extra

  4708   // properties (duration, delay, etc) with initial values to create 3

  4709   // fully-specified transitions.  But when the more specific rule

  4710   // applies, we should only create a single transition.  In order to do

  4711   // this we need to remember which properties were explicitly specified

  4712   // and which ones were just filled in with initial values to get a

  4713   // fully-specified transition, which we do by remembering the number

  4714   // of values for each property.

  4716   uint32_t numTransitions = 0;

  4717   for (size_t i = 0; i < aLength; ++i) {

  4718     const TransitionPropInfo& info = aInfo[i];

  4719     TransitionPropData& data = aData[i];

  4721     // cache whether any of the properties are specified as 'inherit' so

  4722     // we can use it below

  4724     const nsCSSValue& value = *aRuleData->ValueFor(info.property);

  4725     data.unit = value.GetUnit();

  4726     data.list = (value.GetUnit() == eCSSUnit_List ||

  4727                  value.GetUnit() == eCSSUnit_ListDep)

  4728                   ? value.GetListValue() : nullptr;

  4730     // General algorithm to determine how many total transitions we need

  4731     // to build.  For each property:

  4732     //  - if there is no value specified in for the property in

  4733     //    displayData, use the values from the start struct, but only if

  4734     //    they were explicitly specified

  4735     //  - if there is a value specified for the property in displayData:

  4736     //    - if the value is 'inherit', count the number of values for

  4737     //      that property are specified by the parent, but only those

  4738     //      that were explicitly specified

  4739     //    - otherwise, count the number of values specified in displayData

  4742     // calculate number of elements

  4743     if (data.unit == eCSSUnit_Inherit) {

  4744       data.num = aParentDisplay->*(info.sdCount);

  4745       aCanStoreInRuleTree = false;

  4746     } else if (data.list) {

  4747       data.num = ListLength(data.list);

  4748     } else {

  4749       data.num = aDisplay->*(info.sdCount);

  4750     }

  4751     if (data.num > numTransitions)

  4752       numTransitions = data.num;

  4753   }

  4755   return numTransitions;

  4756 }

  4758 static void

  4759 ComputeTimingFunction(const nsCSSValue& aValue, nsTimingFunction& aResult)

  4760 {

  4761   switch (aValue.GetUnit()) {

  4762     case eCSSUnit_Enumerated:

  4763       aResult = nsTimingFunction(aValue.GetIntValue());

  4764       break;

  4765     case eCSSUnit_Cubic_Bezier:

  4766       {

  4767         nsCSSValue::Array* array = aValue.GetArrayValue();

  4768         NS_ASSERTION(array && array->Count() == 4,

  4769                      "Need 4 control points");

  4770         aResult = nsTimingFunction(array->Item(0).GetFloatValue(),

  4771                                    array->Item(1).GetFloatValue(),

  4772                                    array->Item(2).GetFloatValue(),

  4773                                    array->Item(3).GetFloatValue());

  4774       }

  4775       break;

  4776     case eCSSUnit_Steps:

  4777       {

  4778         nsCSSValue::Array* array = aValue.GetArrayValue();

  4779         NS_ASSERTION(array && array->Count() == 2,

  4780                      "Need 2 items");

  4781         NS_ASSERTION(array->Item(0).GetUnit() == eCSSUnit_Integer,

  4782                      "unexpected first value");

  4783         NS_ASSERTION(array->Item(1).GetUnit() == eCSSUnit_Enumerated &&

  4784                      (array->Item(1).GetIntValue() ==

  4785                        NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START ||

  4786                       array->Item(1).GetIntValue() ==

  4787                        NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END),

  4788                      "unexpected second value");

  4789         nsTimingFunction::Type type =

  4790           (array->Item(1).GetIntValue() ==

  4791             NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END)

  4792             ? nsTimingFunction::StepEnd : nsTimingFunction::StepStart;

  4793         aResult = nsTimingFunction(type, array->Item(0).GetIntValue());

  4794       }

  4795       break;

  4796     default:

  4797       NS_NOTREACHED("Invalid transition property unit");

  4798   }

  4799 }

  4801 const void*

  4802 nsRuleNode::ComputeDisplayData(void* aStartStruct,

  4803                                const nsRuleData* aRuleData,

  4804                                nsStyleContext* aContext,

  4805                                nsRuleNode* aHighestNode,

  4806                                const RuleDetail aRuleDetail,

  4807                                const bool aCanStoreInRuleTree)

  4808 {

  4809   COMPUTE_START_RESET(Display, (), display, parentDisplay)

  4811   // We may have ended up with aStartStruct's values of mDisplay and

  4812   // mFloats, but those may not be correct if our style data overrides

  4813   // its position or float properties.  Reset to mOriginalDisplay and

  4814   // mOriginalFloats; it if turns out we still need the display/floats

  4815   // adjustments we'll do them below.

  4816   display->mDisplay = display->mOriginalDisplay;

  4817   display->mFloats = display->mOriginalFloats;

  4819   // Each property's index in this array must match its index in the

  4820   // const array |transitionPropInfo| above.

  4821   TransitionPropData transitionPropData[4];

  4822   TransitionPropData& delay = transitionPropData[0];

  4823   TransitionPropData& duration = transitionPropData[1];

  4824   TransitionPropData& property = transitionPropData[2];

  4825   TransitionPropData& timingFunction = transitionPropData[3];

  4827 #define FOR_ALL_TRANSITION_PROPS(var_) \

  4828                                       for (uint32_t var_ = 0; var_ < 4; ++var_)

  4830   // CSS Transitions

  4831   uint32_t numTransitions =

  4832     CountTransitionProps(transitionPropInfo, transitionPropData,

  4833                          ArrayLength(transitionPropData),

  4834                          display, parentDisplay, aRuleData,

  4835                          canStoreInRuleTree);

  4837   display->mTransitions.SetLength(numTransitions);

  4839   FOR_ALL_TRANSITION_PROPS(p) {

  4840     const TransitionPropInfo& i = transitionPropInfo[p];

  4841     TransitionPropData& d = transitionPropData[p];

  4843     display->*(i.sdCount) = d.num;

  4844   }

  4846   // Fill in the transitions we just allocated with the appropriate values.

  4847   for (uint32_t i = 0; i < numTransitions; ++i) {

  4848     nsTransition *transition = &display->mTransitions[i];

  4850     if (i >= delay.num) {

  4851       transition->SetDelay(display->mTransitions[i % delay.num].GetDelay());

  4852     } else if (delay.unit == eCSSUnit_Inherit) {

  4853       // FIXME (Bug 522599) (for all transition properties): write a test that

  4854       // detects when this was wrong for i >= delay.num if parent had

  4855       // count for this property not equal to length

  4856       NS_ABORT_IF_FALSE(i < parentDisplay->mTransitionDelayCount,

  4857                         "delay.num computed incorrectly");

  4858       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  4859                         "should have made canStoreInRuleTree false above");

  4860       transition->SetDelay(parentDisplay->mTransitions[i].GetDelay());

  4861     } else if (delay.unit == eCSSUnit_Initial ||

  4862                delay.unit == eCSSUnit_Unset) {

  4863       transition->SetDelay(0.0);

  4864     } else if (delay.list) {

  4865       switch (delay.list->mValue.GetUnit()) {

  4866         case eCSSUnit_Seconds:

  4867           transition->SetDelay(PR_MSEC_PER_SEC *

  4868                                delay.list->mValue.GetFloatValue());

  4869           break;

  4870         case eCSSUnit_Milliseconds:

  4871           transition->SetDelay(delay.list->mValue.GetFloatValue());

  4872           break;

  4873         default:

  4874           NS_NOTREACHED("Invalid delay unit");

  4875       }

  4876     }

  4878     if (i >= duration.num) {

  4879       transition->SetDuration(

  4880         display->mTransitions[i % duration.num].GetDuration());

  4881     } else if (duration.unit == eCSSUnit_Inherit) {

  4882       NS_ABORT_IF_FALSE(i < parentDisplay->mTransitionDurationCount,

  4883                         "duration.num computed incorrectly");

  4884       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  4885                         "should have made canStoreInRuleTree false above");

  4886       transition->SetDuration(parentDisplay->mTransitions[i].GetDuration());

  4887     } else if (duration.unit == eCSSUnit_Initial ||

  4888                duration.unit == eCSSUnit_Unset) {

  4889       transition->SetDuration(0.0);

  4890     } else if (duration.list) {

  4891       switch (duration.list->mValue.GetUnit()) {

  4892         case eCSSUnit_Seconds:

  4893           transition->SetDuration(PR_MSEC_PER_SEC *

  4894                                   duration.list->mValue.GetFloatValue());

  4895           break;

  4896         case eCSSUnit_Milliseconds:

  4897           transition->SetDuration(duration.list->mValue.GetFloatValue());

  4898           break;

  4899         default:

  4900           NS_NOTREACHED("Invalid duration unit");

  4901       }

  4902     }

  4904     if (i >= property.num) {

  4905       transition->CopyPropertyFrom(display->mTransitions[i % property.num]);

  4906     } else if (property.unit == eCSSUnit_Inherit) {

  4907       NS_ABORT_IF_FALSE(i < parentDisplay->mTransitionPropertyCount,

  4908                         "property.num computed incorrectly");

  4909       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  4910                         "should have made canStoreInRuleTree false above");

  4911       transition->CopyPropertyFrom(parentDisplay->mTransitions[i]);

  4912     } else if (property.unit == eCSSUnit_Initial ||

  4913                property.unit == eCSSUnit_Unset) {

  4914       transition->SetProperty(eCSSPropertyExtra_all_properties);

  4915     } else if (property.unit == eCSSUnit_None) {

  4916       transition->SetProperty(eCSSPropertyExtra_no_properties);

  4917     } else if (property.list) {

  4918       const nsCSSValue &val = property.list->mValue;

  4920       if (val.GetUnit() == eCSSUnit_Ident) {

  4921         nsDependentString

  4922           propertyStr(property.list->mValue.GetStringBufferValue());

  4923         nsCSSProperty prop =

  4924           nsCSSProps::LookupProperty(propertyStr,

  4925                                      nsCSSProps::eEnabledForAllContent);

  4926         if (prop == eCSSProperty_UNKNOWN) {

  4927           transition->SetUnknownProperty(propertyStr);

  4928         } else {

  4929           transition->SetProperty(prop);

  4930         }

  4931       } else {

  4932         NS_ABORT_IF_FALSE(val.GetUnit() == eCSSUnit_All,

  4933                           nsPrintfCString("Invalid transition property unit %d",

  4934                                           val.GetUnit()).get());

  4935         transition->SetProperty(eCSSPropertyExtra_all_properties);

  4936       }

  4937     }

  4939     if (i >= timingFunction.num) {

  4940       transition->SetTimingFunction(

  4941         display->mTransitions[i % timingFunction.num].GetTimingFunction());

  4942     } else if (timingFunction.unit == eCSSUnit_Inherit) {

  4943       NS_ABORT_IF_FALSE(i < parentDisplay->mTransitionTimingFunctionCount,

  4944                         "timingFunction.num computed incorrectly");

  4945       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  4946                         "should have made canStoreInRuleTree false above");

  4947       transition->SetTimingFunction(

  4948         parentDisplay->mTransitions[i].GetTimingFunction());

  4949     } else if (timingFunction.unit == eCSSUnit_Initial ||

  4950                timingFunction.unit == eCSSUnit_Unset) {

  4951       transition->SetTimingFunction(

  4952         nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE));

  4953     } else if (timingFunction.list) {

  4954       ComputeTimingFunction(timingFunction.list->mValue,

  4955                             transition->TimingFunctionSlot());

  4956     }

  4958     FOR_ALL_TRANSITION_PROPS(p) {

  4959       const TransitionPropInfo& info = transitionPropInfo[p];

  4960       TransitionPropData& d = transitionPropData[p];

  4962       // if we're at the end of the list, start at the beginning and repeat

  4963       // until we're out of transitions to populate

  4964       if (d.list) {

  4965         d.list = d.list->mNext ? d.list->mNext :

  4966           aRuleData->ValueFor(info.property)->GetListValue();

  4967       }

  4968     }

  4969   }

  4971   // Each property's index in this array must match its index in the

  4972   // const array |animationPropInfo| above.

  4973   TransitionPropData animationPropData[8];

  4974   TransitionPropData& animDelay = animationPropData[0];

  4975   TransitionPropData& animDuration = animationPropData[1];

  4976   TransitionPropData& animName = animationPropData[2];

  4977   TransitionPropData& animTimingFunction = animationPropData[3];

  4978   TransitionPropData& animDirection = animationPropData[4];

  4979   TransitionPropData& animFillMode = animationPropData[5];

  4980   TransitionPropData& animPlayState = animationPropData[6];

  4981   TransitionPropData& animIterationCount = animationPropData[7];

  4983 #define FOR_ALL_ANIMATION_PROPS(var_) \

  4984     for (uint32_t var_ = 0; var_ < 8; ++var_)

  4986   // CSS Animations.

  4988   uint32_t numAnimations =

  4989     CountTransitionProps(animationPropInfo, animationPropData,

  4990                          ArrayLength(animationPropData),

  4991                          display, parentDisplay, aRuleData,

  4992                          canStoreInRuleTree);

  4994   display->mAnimations.SetLength(numAnimations);

  4996   FOR_ALL_ANIMATION_PROPS(p) {

  4997     const TransitionPropInfo& i = animationPropInfo[p];

  4998     TransitionPropData& d = animationPropData[p];

  5000     display->*(i.sdCount) = d.num;

  5001   }

  5003   // Fill in the animations we just allocated with the appropriate values.

  5004   for (uint32_t i = 0; i < numAnimations; ++i) {

  5005     nsAnimation *animation = &display->mAnimations[i];

  5007     if (i >= animDelay.num) {

  5008       animation->SetDelay(display->mAnimations[i % animDelay.num].GetDelay());

  5009     } else if (animDelay.unit == eCSSUnit_Inherit) {

  5010       // FIXME (Bug 522599) (for all animation properties): write a test that

  5011       // detects when this was wrong for i >= animDelay.num if parent had

  5012       // count for this property not equal to length

  5013       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationDelayCount,

  5014                         "animDelay.num computed incorrectly");

  5015       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5016                         "should have made canStoreInRuleTree false above");

  5017       animation->SetDelay(parentDisplay->mAnimations[i].GetDelay());

  5018     } else if (animDelay.unit == eCSSUnit_Initial ||

  5019                animDelay.unit == eCSSUnit_Unset) {

  5020       animation->SetDelay(0.0);

  5021     } else if (animDelay.list) {

  5022       switch (animDelay.list->mValue.GetUnit()) {

  5023         case eCSSUnit_Seconds:

  5024           animation->SetDelay(PR_MSEC_PER_SEC *

  5025                               animDelay.list->mValue.GetFloatValue());

  5026           break;

  5027         case eCSSUnit_Milliseconds:

  5028           animation->SetDelay(animDelay.list->mValue.GetFloatValue());

  5029           break;

  5030         default:

  5031           NS_NOTREACHED("Invalid delay unit");

  5032       }

  5033     }

  5035     if (i >= animDuration.num) {

  5036       animation->SetDuration(

  5037         display->mAnimations[i % animDuration.num].GetDuration());

  5038     } else if (animDuration.unit == eCSSUnit_Inherit) {

  5039       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationDurationCount,

  5040                         "animDuration.num computed incorrectly");

  5041       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5042                         "should have made canStoreInRuleTree false above");

  5043       animation->SetDuration(parentDisplay->mAnimations[i].GetDuration());

  5044     } else if (animDuration.unit == eCSSUnit_Initial ||

  5045                animDuration.unit == eCSSUnit_Unset) {

  5046       animation->SetDuration(0.0);

  5047     } else if (animDuration.list) {

  5048       switch (animDuration.list->mValue.GetUnit()) {

  5049         case eCSSUnit_Seconds:

  5050           animation->SetDuration(PR_MSEC_PER_SEC *

  5051                                  animDuration.list->mValue.GetFloatValue());

  5052           break;

  5053         case eCSSUnit_Milliseconds:

  5054           animation->SetDuration(animDuration.list->mValue.GetFloatValue());

  5055           break;

  5056         default:

  5057           NS_NOTREACHED("Invalid duration unit");

  5058       }

  5059     }

  5061     if (i >= animName.num) {

  5062       animation->SetName(display->mAnimations[i % animName.num].GetName());

  5063     } else if (animName.unit == eCSSUnit_Inherit) {

  5064       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationNameCount,

  5065                         "animName.num computed incorrectly");

  5066       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5067                         "should have made canStoreInRuleTree false above");

  5068       animation->SetName(parentDisplay->mAnimations[i].GetName());

  5069     } else if (animName.unit == eCSSUnit_Initial ||

  5070                animName.unit == eCSSUnit_Unset) {

  5071       animation->SetName(EmptyString());

  5072     } else if (animName.list) {

  5073       switch (animName.list->mValue.GetUnit()) {

  5074         case eCSSUnit_Ident: {

  5075           nsDependentString

  5076             nameStr(animName.list->mValue.GetStringBufferValue());

  5077           animation->SetName(nameStr);

  5078           break;

  5079         }

  5080         case eCSSUnit_None: {

  5081           animation->SetName(EmptyString());

  5082           break;

  5083         }

  5084         default:

  5085           NS_ABORT_IF_FALSE(false,

  5086             nsPrintfCString("Invalid animation-name unit %d",

  5087                                 animName.list->mValue.GetUnit()).get());

  5088       }

  5089     }

  5091     if (i >= animTimingFunction.num) {

  5092       animation->SetTimingFunction(

  5093         display->mAnimations[i % animTimingFunction.num].GetTimingFunction());

  5094     } else if (animTimingFunction.unit == eCSSUnit_Inherit) {

  5095       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationTimingFunctionCount,

  5096                         "animTimingFunction.num computed incorrectly");

  5097       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5098                         "should have made canStoreInRuleTree false above");

  5099       animation->SetTimingFunction(

  5100         parentDisplay->mAnimations[i].GetTimingFunction());

  5101     } else if (animTimingFunction.unit == eCSSUnit_Initial ||

  5102                animTimingFunction.unit == eCSSUnit_Unset) {

  5103       animation->SetTimingFunction(

  5104         nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE));

  5105     } else if (animTimingFunction.list) {

  5106       ComputeTimingFunction(animTimingFunction.list->mValue,

  5107                             animation->TimingFunctionSlot());

  5108     }

  5110     if (i >= animDirection.num) {

  5111       animation->SetDirection(display->mAnimations[i % animDirection.num].GetDirection());

  5112     } else if (animDirection.unit == eCSSUnit_Inherit) {

  5113       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationDirectionCount,

  5114                         "animDirection.num computed incorrectly");

  5115       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5116                         "should have made canStoreInRuleTree false above");

  5117       animation->SetDirection(parentDisplay->mAnimations[i].GetDirection());

  5118     } else if (animDirection.unit == eCSSUnit_Initial ||

  5119                animDirection.unit == eCSSUnit_Unset) {

  5120       animation->SetDirection(NS_STYLE_ANIMATION_DIRECTION_NORMAL);

  5121     } else if (animDirection.list) {

  5122       NS_ABORT_IF_FALSE(animDirection.list->mValue.GetUnit() == eCSSUnit_Enumerated,

  5123                         nsPrintfCString("Invalid animation-direction unit %d",

  5124                                         animDirection.list->mValue.GetUnit()).get());

  5126       animation->SetDirection(animDirection.list->mValue.GetIntValue());

  5127     }

  5129     if (i >= animFillMode.num) {

  5130       animation->SetFillMode(display->mAnimations[i % animFillMode.num].GetFillMode());

  5131     } else if (animFillMode.unit == eCSSUnit_Inherit) {

  5132       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationFillModeCount,

  5133                         "animFillMode.num computed incorrectly");

  5134       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5135                         "should have made canStoreInRuleTree false above");

  5136       animation->SetFillMode(parentDisplay->mAnimations[i].GetFillMode());

  5137     } else if (animFillMode.unit == eCSSUnit_Initial ||

  5138                animFillMode.unit == eCSSUnit_Unset) {

  5139       animation->SetFillMode(NS_STYLE_ANIMATION_FILL_MODE_NONE);

  5140     } else if (animFillMode.list) {

  5141       NS_ABORT_IF_FALSE(animFillMode.list->mValue.GetUnit() == eCSSUnit_Enumerated,

  5142                         nsPrintfCString("Invalid animation-fill-mode unit %d",

  5143                                         animFillMode.list->mValue.GetUnit()).get());

  5145       animation->SetFillMode(animFillMode.list->mValue.GetIntValue());

  5146     }

  5148     if (i >= animPlayState.num) {

  5149       animation->SetPlayState(display->mAnimations[i % animPlayState.num].GetPlayState());

  5150     } else if (animPlayState.unit == eCSSUnit_Inherit) {

  5151       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationPlayStateCount,

  5152                         "animPlayState.num computed incorrectly");

  5153       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5154                         "should have made canStoreInRuleTree false above");

  5155       animation->SetPlayState(parentDisplay->mAnimations[i].GetPlayState());

  5156     } else if (animPlayState.unit == eCSSUnit_Initial ||

  5157                animPlayState.unit == eCSSUnit_Unset) {

  5158       animation->SetPlayState(NS_STYLE_ANIMATION_PLAY_STATE_RUNNING);

  5159     } else if (animPlayState.list) {

  5160       NS_ABORT_IF_FALSE(animPlayState.list->mValue.GetUnit() == eCSSUnit_Enumerated,

  5161                         nsPrintfCString("Invalid animation-play-state unit %d",

  5162                                         animPlayState.list->mValue.GetUnit()).get());

  5164       animation->SetPlayState(animPlayState.list->mValue.GetIntValue());

  5165     }

  5167     if (i >= animIterationCount.num) {

  5168       animation->SetIterationCount(display->mAnimations[i % animIterationCount.num].GetIterationCount());

  5169     } else if (animIterationCount.unit == eCSSUnit_Inherit) {

  5170       NS_ABORT_IF_FALSE(i < parentDisplay->mAnimationIterationCountCount,

  5171                         "animIterationCount.num computed incorrectly");

  5172       NS_ABORT_IF_FALSE(!canStoreInRuleTree,

  5173                         "should have made canStoreInRuleTree false above");

  5174       animation->SetIterationCount(parentDisplay->mAnimations[i].GetIterationCount());

  5175     } else if (animIterationCount.unit == eCSSUnit_Initial ||

  5176                animIterationCount.unit == eCSSUnit_Unset) {

  5177       animation->SetIterationCount(1.0f);

  5178     } else if (animIterationCount.list) {

  5179       switch (animIterationCount.list->mValue.GetUnit()) {

  5180         case eCSSUnit_Enumerated:

  5181           NS_ABORT_IF_FALSE(animIterationCount.list->mValue.GetIntValue() ==

  5182                               NS_STYLE_ANIMATION_ITERATION_COUNT_INFINITE,

  5183                             "unexpected value");

  5184           animation->SetIterationCount(NS_IEEEPositiveInfinity());

  5185           break;

  5186         case eCSSUnit_Number:

  5187           animation->SetIterationCount(

  5188             animIterationCount.list->mValue.GetFloatValue());

  5189           break;

  5190         default:

  5191           NS_ABORT_IF_FALSE(false,

  5192                             "unexpected animation-iteration-count unit");

  5193       }

  5194     }

  5196     FOR_ALL_ANIMATION_PROPS(p) {

  5197       const TransitionPropInfo& info = animationPropInfo[p];

  5198       TransitionPropData& d = animationPropData[p];

  5200       // if we're at the end of the list, start at the beginning and repeat

  5201       // until we're out of animations to populate

  5202       if (d.list) {

  5203         d.list = d.list->mNext ? d.list->mNext :

  5204           aRuleData->ValueFor(info.property)->GetListValue();

  5205       }

  5206     }

  5207   }

  5209   // opacity: factor, inherit, initial

  5210   SetFactor(*aRuleData->ValueForOpacity(), display->mOpacity, canStoreInRuleTree,

  5211             parentDisplay->mOpacity, 1.0f,

  5212             SETFCT_OPACITY | SETFCT_UNSET_INITIAL);

  5214   // display: enum, inherit, initial

  5215   SetDiscrete(*aRuleData->ValueForDisplay(), display->mDisplay, canStoreInRuleTree,

  5216               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5217               parentDisplay->mDisplay,

  5218               NS_STYLE_DISPLAY_INLINE, 0, 0, 0, 0);

  5220   // mix-blend-mode: enum, inherit, initial

  5221   SetDiscrete(*aRuleData->ValueForMixBlendMode(), display->mMixBlendMode,

  5222               canStoreInRuleTree,

  5223               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5224               parentDisplay->mMixBlendMode, NS_STYLE_BLEND_NORMAL,

  5225               0, 0, 0, 0);

  5227   // Backup original display value for calculation of a hypothetical

  5228   // box (CSS2 10.6.4/10.6.5), in addition to getting our style data right later.

  5229   // See nsHTMLReflowState::CalculateHypotheticalBox

  5230   display->mOriginalDisplay = display->mDisplay;

  5232   // appearance: enum, inherit, initial

  5233   SetDiscrete(*aRuleData->ValueForAppearance(),

  5234               display->mAppearance, canStoreInRuleTree,

  5235               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5236               parentDisplay->mAppearance,

  5237               NS_THEME_NONE, 0, 0, 0, 0);

  5239   // binding: url, none, inherit

  5240   const nsCSSValue* bindingValue = aRuleData->ValueForBinding();

  5241   if (eCSSUnit_URL == bindingValue->GetUnit()) {

  5242     mozilla::css::URLValue* url = bindingValue->GetURLStructValue();

  5243     NS_ASSERTION(url, "What's going on here?");

  5245     if (MOZ_LIKELY(url->GetURI())) {

  5246       display->mBinding = url;

  5247     } else {

  5248       display->mBinding = nullptr;

  5249     }

  5250   }

  5251   else if (eCSSUnit_None == bindingValue->GetUnit() ||

  5252            eCSSUnit_Initial == bindingValue->GetUnit() ||

  5253            eCSSUnit_Unset == bindingValue->GetUnit()) {

  5254     display->mBinding = nullptr;

  5255   }

  5256   else if (eCSSUnit_Inherit == bindingValue->GetUnit()) {

  5257     canStoreInRuleTree = false;

  5258     display->mBinding = parentDisplay->mBinding;

  5259   }

  5261   // position: enum, inherit, initial

  5262   SetDiscrete(*aRuleData->ValueForPosition(), display->mPosition, canStoreInRuleTree,

  5263               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5264               parentDisplay->mPosition,

  5265               NS_STYLE_POSITION_STATIC, 0, 0, 0, 0);

  5267   // clear: enum, inherit, initial

  5268   SetDiscrete(*aRuleData->ValueForClear(), display->mBreakType, canStoreInRuleTree,

  5269               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5270               parentDisplay->mBreakType,

  5271               NS_STYLE_CLEAR_NONE, 0, 0, 0, 0);

  5273   // temp fix for bug 24000

  5274   // Map 'auto' and 'avoid' to false, and 'always', 'left', and

  5275   // 'right' to true.

  5276   // "A conforming user agent may interpret the values 'left' and

  5277   // 'right' as 'always'." - CSS2.1, section 13.3.1

  5278   const nsCSSValue* breakBeforeValue = aRuleData->ValueForPageBreakBefore();

  5279   if (eCSSUnit_Enumerated == breakBeforeValue->GetUnit()) {

  5280     display->mBreakBefore =

  5281       (NS_STYLE_PAGE_BREAK_AVOID != breakBeforeValue->GetIntValue() &&

  5282        NS_STYLE_PAGE_BREAK_AUTO  != breakBeforeValue->GetIntValue());

  5283   }

  5284   else if (eCSSUnit_Initial == breakBeforeValue->GetUnit() ||

  5285            eCSSUnit_Unset == breakBeforeValue->GetUnit()) {

  5286     display->mBreakBefore = false;

  5287   }

  5288   else if (eCSSUnit_Inherit == breakBeforeValue->GetUnit()) {

  5289     canStoreInRuleTree = false;

  5290     display->mBreakBefore = parentDisplay->mBreakBefore;

  5291   }

  5293   const nsCSSValue* breakAfterValue = aRuleData->ValueForPageBreakAfter();

  5294   if (eCSSUnit_Enumerated == breakAfterValue->GetUnit()) {

  5295     display->mBreakAfter =

  5296       (NS_STYLE_PAGE_BREAK_AVOID != breakAfterValue->GetIntValue() &&

  5297        NS_STYLE_PAGE_BREAK_AUTO  != breakAfterValue->GetIntValue());

  5298   }

  5299   else if (eCSSUnit_Initial == breakAfterValue->GetUnit() ||

  5300            eCSSUnit_Unset == breakAfterValue->GetUnit()) {

  5301     display->mBreakAfter = false;

  5302   }

  5303   else if (eCSSUnit_Inherit == breakAfterValue->GetUnit()) {

  5304     canStoreInRuleTree = false;

  5305     display->mBreakAfter = parentDisplay->mBreakAfter;

  5306   }

  5307   // end temp fix

  5309   // page-break-inside: enum, inherit, initial

  5310   SetDiscrete(*aRuleData->ValueForPageBreakInside(),

  5311               display->mBreakInside, canStoreInRuleTree,

  5312               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5313               parentDisplay->mBreakInside,

  5314               NS_STYLE_PAGE_BREAK_AUTO, 0, 0, 0, 0);

  5316   // touch-action: none, auto, enum, inherit, initial

  5317   SetDiscrete(*aRuleData->ValueForTouchAction(), display->mTouchAction,

  5318               canStoreInRuleTree,

  5319               SETDSC_ENUMERATED | SETDSC_AUTO | SETDSC_NONE |

  5320                 SETDSC_UNSET_INITIAL,

  5321               parentDisplay->mTouchAction,

  5322               NS_STYLE_TOUCH_ACTION_AUTO,

  5323               NS_STYLE_TOUCH_ACTION_AUTO,

  5324               NS_STYLE_TOUCH_ACTION_NONE, 0, 0);

  5326   // float: enum, inherit, initial

  5327   SetDiscrete(*aRuleData->ValueForFloat(),

  5328               display->mFloats, canStoreInRuleTree,

  5329               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5330               parentDisplay->mFloats,

  5331               NS_STYLE_FLOAT_NONE, 0, 0, 0, 0);

  5332   // Save mFloats in mOriginalFloats in case we need it later

  5333   display->mOriginalFloats = display->mFloats;

  5335   // overflow-x: enum, inherit, initial

  5336   SetDiscrete(*aRuleData->ValueForOverflowX(),

  5337               display->mOverflowX, canStoreInRuleTree,

  5338               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5339               parentDisplay->mOverflowX,

  5340               NS_STYLE_OVERFLOW_VISIBLE, 0, 0, 0, 0);

  5342   // overflow-y: enum, inherit, initial

  5343   SetDiscrete(*aRuleData->ValueForOverflowY(),

  5344               display->mOverflowY, canStoreInRuleTree,

  5345               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5346               parentDisplay->mOverflowY,

  5347               NS_STYLE_OVERFLOW_VISIBLE, 0, 0, 0, 0);

  5349   // CSS3 overflow-x and overflow-y require some fixup as well in some

  5350   // cases.  NS_STYLE_OVERFLOW_VISIBLE and NS_STYLE_OVERFLOW_CLIP are

  5351   // meaningful only when used in both dimensions.

  5352   if (display->mOverflowX != display->mOverflowY &&

  5353       (display->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE ||

  5354        display->mOverflowX == NS_STYLE_OVERFLOW_CLIP ||

  5355        display->mOverflowY == NS_STYLE_OVERFLOW_VISIBLE ||

  5356        display->mOverflowY == NS_STYLE_OVERFLOW_CLIP)) {

  5357     // We can't store in the rule tree since a more specific rule might

  5358     // change these conditions.

  5359     canStoreInRuleTree = false;

  5361     // NS_STYLE_OVERFLOW_CLIP is a deprecated value, so if it's specified

  5362     // in only one dimension, convert it to NS_STYLE_OVERFLOW_HIDDEN.

  5363     if (display->mOverflowX == NS_STYLE_OVERFLOW_CLIP)

  5364       display->mOverflowX = NS_STYLE_OVERFLOW_HIDDEN;

  5365     if (display->mOverflowY == NS_STYLE_OVERFLOW_CLIP)

  5366       display->mOverflowY = NS_STYLE_OVERFLOW_HIDDEN;

  5368     // If 'visible' is specified but doesn't match the other dimension, it

  5369     // turns into 'auto'.

  5370     if (display->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE)

  5371       display->mOverflowX = NS_STYLE_OVERFLOW_AUTO;

  5372     if (display->mOverflowY == NS_STYLE_OVERFLOW_VISIBLE)

  5373       display->mOverflowY = NS_STYLE_OVERFLOW_AUTO;

  5374   }

  5376   SetDiscrete(*aRuleData->ValueForOverflowClipBox(), display->mOverflowClipBox,

  5377               canStoreInRuleTree,

  5378               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5379               parentDisplay->mOverflowClipBox,

  5380               NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX, 0, 0, 0, 0);

  5382   SetDiscrete(*aRuleData->ValueForResize(), display->mResize, canStoreInRuleTree,

  5383               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5384               parentDisplay->mResize,

  5385               NS_STYLE_RESIZE_NONE, 0, 0, 0, 0);

  5387   // clip property: length, auto, inherit

  5388   const nsCSSValue* clipValue = aRuleData->ValueForClip();

  5389   switch (clipValue->GetUnit()) {

  5390   case eCSSUnit_Inherit:

  5391     canStoreInRuleTree = false;

  5392     display->mClipFlags = parentDisplay->mClipFlags;

  5393     display->mClip = parentDisplay->mClip;

  5394     break;

  5396   case eCSSUnit_Initial:

  5397   case eCSSUnit_Unset:

  5398   case eCSSUnit_Auto:

  5399     display->mClipFlags = NS_STYLE_CLIP_AUTO;

  5400     display->mClip.SetRect(0,0,0,0);

  5401     break;

  5403   case eCSSUnit_Null:

  5404     break;

  5406   case eCSSUnit_Rect: {

  5407     const nsCSSRect& clipRect = clipValue->GetRectValue();

  5409     display->mClipFlags = NS_STYLE_CLIP_RECT;

  5411     if (clipRect.mTop.GetUnit() == eCSSUnit_Auto) {

  5412       display->mClip.y = 0;

  5413       display->mClipFlags |= NS_STYLE_CLIP_TOP_AUTO;

  5414     }

  5415     else if (clipRect.mTop.IsLengthUnit()) {

  5416       display->mClip.y = CalcLength(clipRect.mTop, aContext,

  5417                                     mPresContext, canStoreInRuleTree);

  5418     }

  5420     if (clipRect.mBottom.GetUnit() == eCSSUnit_Auto) {

  5421       // Setting to NS_MAXSIZE for the 'auto' case ensures that

  5422       // the clip rect is nonempty. It is important that mClip be

  5423       // nonempty if the actual clip rect could be nonempty.

  5424       display->mClip.height = NS_MAXSIZE;

  5425       display->mClipFlags |= NS_STYLE_CLIP_BOTTOM_AUTO;

  5426     }

  5427     else if (clipRect.mBottom.IsLengthUnit()) {

  5428       display->mClip.height = CalcLength(clipRect.mBottom, aContext,

  5429                                          mPresContext, canStoreInRuleTree) -

  5430                               display->mClip.y;

  5431     }

  5433     if (clipRect.mLeft.GetUnit() == eCSSUnit_Auto) {

  5434       display->mClip.x = 0;

  5435       display->mClipFlags |= NS_STYLE_CLIP_LEFT_AUTO;

  5436     }

  5437     else if (clipRect.mLeft.IsLengthUnit()) {

  5438       display->mClip.x = CalcLength(clipRect.mLeft, aContext,

  5439                                     mPresContext, canStoreInRuleTree);

  5440     }

  5442     if (clipRect.mRight.GetUnit() == eCSSUnit_Auto) {

  5443       // Setting to NS_MAXSIZE for the 'auto' case ensures that

  5444       // the clip rect is nonempty. It is important that mClip be

  5445       // nonempty if the actual clip rect could be nonempty.

  5446       display->mClip.width = NS_MAXSIZE;

  5447       display->mClipFlags |= NS_STYLE_CLIP_RIGHT_AUTO;

  5448     }

  5449     else if (clipRect.mRight.IsLengthUnit()) {

  5450       display->mClip.width = CalcLength(clipRect.mRight, aContext,

  5451                                         mPresContext, canStoreInRuleTree) -

  5452                              display->mClip.x;

  5453     }

  5454     break;

  5455   }

  5457   default:

  5458     NS_ABORT_IF_FALSE(false, "unrecognized clip unit");

  5459   }

  5461   if (display->mDisplay != NS_STYLE_DISPLAY_NONE) {

  5462     // CSS2 9.7 specifies display type corrections dealing with 'float'

  5463     // and 'position'.  Since generated content can't be floated or

  5464     // positioned, we can deal with it here.

  5466     if (nsCSSPseudoElements::firstLetter == aContext->GetPseudo()) {

  5467       // a non-floating first-letter must be inline

  5468       // XXX this fix can go away once bug 103189 is fixed correctly

  5469       // Note that we reset mOriginalDisplay to enforce the invariant that it equals mDisplay if we're not positioned or floating.

  5470       display->mOriginalDisplay = display->mDisplay = NS_STYLE_DISPLAY_INLINE;

  5472       // We can't cache the data in the rule tree since if a more specific

  5473       // rule has 'float: left' we'll end up with the wrong 'display'

  5474       // property.

  5475       canStoreInRuleTree = false;

  5476     }

  5478     if (display->IsAbsolutelyPositionedStyle()) {

  5479       // 1) if position is 'absolute' or 'fixed' then display must be

  5480       // block-level and float must be 'none'

  5481       EnsureBlockDisplay(display->mDisplay);

  5482       display->mFloats = NS_STYLE_FLOAT_NONE;

  5484       // Note that it's OK to cache this struct in the ruletree

  5485       // because it's fine as-is for any style context that points to

  5486       // it directly, and any use of it as aStartStruct (e.g. if a

  5487       // more specific rule sets "position: static") will use

  5488       // mOriginalDisplay and mOriginalFloats, which we have carefully

  5489       // not changed.

  5490     } else if (display->mFloats != NS_STYLE_FLOAT_NONE) {

  5491       // 2) if float is not none, and display is not none, then we must

  5492       // set a block-level 'display' type per CSS2.1 section 9.7.

  5493       EnsureBlockDisplay(display->mDisplay);

  5495       // Note that it's OK to cache this struct in the ruletree

  5496       // because it's fine as-is for any style context that points to

  5497       // it directly, and any use of it as aStartStruct (e.g. if a

  5498       // more specific rule sets "float: none") will use

  5499       // mOriginalDisplay, which we have carefully not changed.

  5500     }

  5502   }

  5504   /* Convert the nsCSSValueList into an nsTArray<nsTransformFunction *>. */

  5505   const nsCSSValue* transformValue = aRuleData->ValueForTransform();

  5506   switch (transformValue->GetUnit()) {

  5507   case eCSSUnit_Null:

  5508     break;

  5510   case eCSSUnit_Initial:

  5511   case eCSSUnit_Unset:

  5512   case eCSSUnit_None:

  5513     display->mSpecifiedTransform = nullptr;

  5514     break;

  5516   case eCSSUnit_Inherit:

  5517     display->mSpecifiedTransform = parentDisplay->mSpecifiedTransform;

  5518     canStoreInRuleTree = false;

  5519     break;

  5521   case eCSSUnit_SharedList: {

  5522     nsCSSValueSharedList* list = transformValue->GetSharedListValue();

  5523     nsCSSValueList* head = list->mHead;

  5524     MOZ_ASSERT(head, "transform list must have at least one item");

  5525     // can get a _None in here from transform animation

  5526     if (head->mValue.GetUnit() == eCSSUnit_None) {

  5527       NS_ABORT_IF_FALSE(head->mNext == nullptr, "none must be alone");

  5528       display->mSpecifiedTransform = nullptr;

  5529     } else {

  5530       display->mSpecifiedTransform = list;

  5531     }

  5532     break;

  5533   }

  5535   default:

  5536     NS_ABORT_IF_FALSE(false, "unrecognized transform unit");

  5537   }

  5539   /* Convert the nsCSSValueList into a will-change bitfield for fast lookup */

  5540   const nsCSSValue* willChangeValue = aRuleData->ValueForWillChange();

  5541   switch (willChangeValue->GetUnit()) {

  5542   case eCSSUnit_Null:

  5543     break;

  5545   case eCSSUnit_List:

  5546   case eCSSUnit_ListDep: {

  5547     display->mWillChange.Clear();

  5548     display->mWillChangeBitField = 0;

  5549     for (const nsCSSValueList* item = willChangeValue->GetListValue();

  5550          item; item = item->mNext)

  5551     {

  5552       if (item->mValue.UnitHasStringValue()) {

  5553         nsAutoString buffer;

  5554         item->mValue.GetStringValue(buffer);

  5555         display->mWillChange.AppendElement(buffer);

  5557         if (buffer.EqualsLiteral("transform")) {

  5558           display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_TRANSFORM;

  5559         }

  5560         if (buffer.EqualsLiteral("opacity")) {

  5561           display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_OPACITY;

  5562         }

  5563         if (buffer.EqualsLiteral("scroll-position")) {

  5564           display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_SCROLL;

  5565         }

  5567         nsCSSProperty prop =

  5568           nsCSSProps::LookupProperty(buffer,

  5569                                      nsCSSProps::eEnabledForAllContent);

  5570         if (prop != eCSSProperty_UNKNOWN &&

  5571             nsCSSProps::PropHasFlags(prop,

  5572                                      CSS_PROPERTY_CREATES_STACKING_CONTEXT))

  5573         {

  5574           display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_STACKING_CONTEXT;

  5575         }

  5576       }

  5577     }

  5578     break;

  5579   }

  5581   case eCSSUnit_Inherit:

  5582     display->mWillChange = parentDisplay->mWillChange;

  5583     display->mWillChangeBitField = parentDisplay->mWillChangeBitField;

  5584     canStoreInRuleTree = false;

  5585     break;

  5587   case eCSSUnit_Initial:

  5588   case eCSSUnit_Unset:

  5589   case eCSSUnit_Auto:

  5590     display->mWillChange.Clear();

  5591     display->mWillChangeBitField = 0;

  5592     break;

  5594   default:

  5595     MOZ_ASSERT(false, "unrecognized will-change unit");

  5596   }

  5598   /* Convert -moz-transform-origin. */

  5599   const nsCSSValue* transformOriginValue =

  5600     aRuleData->ValueForTransformOrigin();

  5601   if (transformOriginValue->GetUnit() != eCSSUnit_Null) {

  5602     const nsCSSValue& valX =

  5603       transformOriginValue->GetUnit() == eCSSUnit_Triplet ?

  5604         transformOriginValue->GetTripletValue().mXValue : *transformOriginValue;

  5605     const nsCSSValue& valY =

  5606       transformOriginValue->GetUnit() == eCSSUnit_Triplet ?

  5607         transformOriginValue->GetTripletValue().mYValue : *transformOriginValue;

  5608     const nsCSSValue& valZ =

  5609       transformOriginValue->GetUnit() == eCSSUnit_Triplet ?

  5610         transformOriginValue->GetTripletValue().mZValue : *transformOriginValue;

  5612     mozilla::DebugOnly<bool> cX =

  5613        SetCoord(valX, display->mTransformOrigin[0],

  5614                 parentDisplay->mTransformOrigin[0],

  5615                 SETCOORD_LPH | SETCOORD_INITIAL_HALF |

  5616                   SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC |

  5617                   SETCOORD_UNSET_INITIAL,

  5618                 aContext, mPresContext, canStoreInRuleTree);

  5620      mozilla::DebugOnly<bool> cY =

  5621        SetCoord(valY, display->mTransformOrigin[1],

  5622                 parentDisplay->mTransformOrigin[1],

  5623                 SETCOORD_LPH | SETCOORD_INITIAL_HALF |

  5624                   SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC |

  5625                   SETCOORD_UNSET_INITIAL,

  5626                 aContext, mPresContext, canStoreInRuleTree);

  5628      if (valZ.GetUnit() == eCSSUnit_Null) {

  5629        // Null for the z component means a 0 translation, not

  5630        // unspecified, as we have already checked the triplet

  5631        // value for Null.

  5632        display->mTransformOrigin[2].SetCoordValue(0);

  5633      } else {

  5634        mozilla::DebugOnly<bool> cZ =

  5635          SetCoord(valZ, display->mTransformOrigin[2],

  5636                   parentDisplay->mTransformOrigin[2],

  5637                   SETCOORD_LH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |

  5638                     SETCOORD_UNSET_INITIAL,

  5639                   aContext, mPresContext, canStoreInRuleTree);

  5640        NS_ABORT_IF_FALSE(cY == cZ, "changed one but not the other");

  5641      }

  5642      NS_ABORT_IF_FALSE(cX == cY, "changed one but not the other");

  5643      NS_ASSERTION(cX, "Malformed -moz-transform-origin parse!");

  5644   }

  5646   const nsCSSValue* perspectiveOriginValue =

  5647     aRuleData->ValueForPerspectiveOrigin();

  5648   if (perspectiveOriginValue->GetUnit() != eCSSUnit_Null) {

  5649     mozilla::DebugOnly<bool> result =

  5650       SetPairCoords(*perspectiveOriginValue,

  5651                     display->mPerspectiveOrigin[0],

  5652                     display->mPerspectiveOrigin[1],

  5653                     parentDisplay->mPerspectiveOrigin[0],

  5654                     parentDisplay->mPerspectiveOrigin[1],

  5655                     SETCOORD_LPH | SETCOORD_INITIAL_HALF |

  5656                       SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC |

  5657                       SETCOORD_UNSET_INITIAL,

  5658                     aContext, mPresContext, canStoreInRuleTree);

  5659     NS_ASSERTION(result, "Malformed -moz-perspective-origin parse!");

  5660   }

  5662   SetCoord(*aRuleData->ValueForPerspective(),

  5663            display->mChildPerspective, parentDisplay->mChildPerspective,

  5664            SETCOORD_LAH | SETCOORD_INITIAL_NONE | SETCOORD_NONE |

  5665              SETCOORD_UNSET_INITIAL,

  5666            aContext, mPresContext, canStoreInRuleTree);

  5668   SetDiscrete(*aRuleData->ValueForBackfaceVisibility(),

  5669               display->mBackfaceVisibility, canStoreInRuleTree,

  5670               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5671               parentDisplay->mBackfaceVisibility,

  5672               NS_STYLE_BACKFACE_VISIBILITY_VISIBLE, 0, 0, 0, 0);

  5674   // transform-style: enum, inherit, initial

  5675   SetDiscrete(*aRuleData->ValueForTransformStyle(),

  5676               display->mTransformStyle, canStoreInRuleTree,

  5677               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5678               parentDisplay->mTransformStyle,

  5679               NS_STYLE_TRANSFORM_STYLE_FLAT, 0, 0, 0, 0);

  5681   // orient: enum, inherit, initial

  5682   SetDiscrete(*aRuleData->ValueForOrient(),

  5683               display->mOrient, canStoreInRuleTree,

  5684               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  5685               parentDisplay->mOrient,

  5686               NS_STYLE_ORIENT_AUTO, 0, 0, 0, 0);

  5688   COMPUTE_END_RESET(Display, display)

  5689 }

  5691 const void*

  5692 nsRuleNode::ComputeVisibilityData(void* aStartStruct,

  5693                                   const nsRuleData* aRuleData,

  5694                                   nsStyleContext* aContext,

  5695                                   nsRuleNode* aHighestNode,

  5696                                   const RuleDetail aRuleDetail,

  5697                                   const bool aCanStoreInRuleTree)

  5698 {

  5699   COMPUTE_START_INHERITED(Visibility, (mPresContext),

  5700                           visibility, parentVisibility)

  5702   // IMPORTANT: No properties in this struct have lengths in them.  We

  5703   // depend on this since CalcLengthWith can call StyleVisibility()

  5704   // to get the language for resolving fonts!

  5706   // direction: enum, inherit, initial

  5707   SetDiscrete(*aRuleData->ValueForDirection(), visibility->mDirection,

  5708               canStoreInRuleTree,

  5709               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  5710               parentVisibility->mDirection,

  5711               (GET_BIDI_OPTION_DIRECTION(mPresContext->GetBidi())

  5712                == IBMBIDI_TEXTDIRECTION_RTL)

  5713               ? NS_STYLE_DIRECTION_RTL : NS_STYLE_DIRECTION_LTR,

  5714               0, 0, 0, 0);

  5716   // visibility: enum, inherit, initial

  5717   SetDiscrete(*aRuleData->ValueForVisibility(), visibility->mVisible,

  5718               canStoreInRuleTree,

  5719               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  5720               parentVisibility->mVisible,

  5721               NS_STYLE_VISIBILITY_VISIBLE, 0, 0, 0, 0);

  5723   // pointer-events: enum, inherit, initial

  5724   SetDiscrete(*aRuleData->ValueForPointerEvents(), visibility->mPointerEvents,

  5725               canStoreInRuleTree,

  5726               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  5727               parentVisibility->mPointerEvents,

  5728               NS_STYLE_POINTER_EVENTS_AUTO, 0, 0, 0, 0);

  5730   // writing-mode: enum, inherit, initial

  5731   SetDiscrete(*aRuleData->ValueForWritingMode(), visibility->mWritingMode,

  5732               canStoreInRuleTree,

  5733               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  5734               parentVisibility->mWritingMode,

  5735               NS_STYLE_WRITING_MODE_HORIZONTAL_TB, 0, 0, 0, 0);

  5737   // image-orientation: enum, inherit, initial

  5738   const nsCSSValue* orientation = aRuleData->ValueForImageOrientation();

  5739   if (orientation->GetUnit() == eCSSUnit_Inherit ||

  5740       orientation->GetUnit() == eCSSUnit_Unset) {

  5741     canStoreInRuleTree = false;

  5742     visibility->mImageOrientation = parentVisibility->mImageOrientation;

  5743   } else if (orientation->GetUnit() == eCSSUnit_Initial) {

  5744     visibility->mImageOrientation = nsStyleImageOrientation();

  5745   } else if (orientation->IsAngularUnit()) {

  5746     double angle = orientation->GetAngleValueInRadians();

  5747     visibility->mImageOrientation =

  5748       nsStyleImageOrientation::CreateAsAngleAndFlip(angle, false);

  5749   } else if (orientation->GetUnit() == eCSSUnit_Array) {

  5750     const nsCSSValue::Array* array = orientation->GetArrayValue();

  5751     MOZ_ASSERT(array->Item(0).IsAngularUnit(),

  5752                "First image-orientation value is not an angle");

  5753     MOZ_ASSERT(array->Item(1).GetUnit() == eCSSUnit_Enumerated &&

  5754                array->Item(1).GetIntValue() == NS_STYLE_IMAGE_ORIENTATION_FLIP,

  5755                "Second image-orientation value is not 'flip'");

  5756     double angle = array->Item(0).GetAngleValueInRadians();

  5757     visibility->mImageOrientation =

  5758       nsStyleImageOrientation::CreateAsAngleAndFlip(angle, true);

  5760   } else if (orientation->GetUnit() == eCSSUnit_Enumerated) {

  5761     switch (orientation->GetIntValue()) {

  5762       case NS_STYLE_IMAGE_ORIENTATION_FLIP:

  5763         visibility->mImageOrientation = nsStyleImageOrientation::CreateAsFlip();

  5764         break;

  5765       case NS_STYLE_IMAGE_ORIENTATION_FROM_IMAGE:

  5766         visibility->mImageOrientation = nsStyleImageOrientation::CreateAsFromImage();

  5767         break;

  5768       default:

  5769         NS_NOTREACHED("Invalid image-orientation enumerated value");

  5770     }

  5771   } else {

  5772     MOZ_ASSERT(orientation->GetUnit() == eCSSUnit_Null, "Should be null unit");

  5773   }

  5775   COMPUTE_END_INHERITED(Visibility, visibility)

  5776 }

  5778 const void*

  5779 nsRuleNode::ComputeColorData(void* aStartStruct,

  5780                              const nsRuleData* aRuleData,

  5781                              nsStyleContext* aContext,

  5782                              nsRuleNode* aHighestNode,

  5783                              const RuleDetail aRuleDetail,

  5784                              const bool aCanStoreInRuleTree)

  5785 {

  5786   COMPUTE_START_INHERITED(Color, (mPresContext), color, parentColor)

  5788   // color: color, string, inherit

  5789   // Special case for currentColor.  According to CSS3, setting color to 'currentColor'

  5790   // should behave as if it is inherited

  5791   const nsCSSValue* colorValue = aRuleData->ValueForColor();

  5792   if ((colorValue->GetUnit() == eCSSUnit_EnumColor &&

  5793        colorValue->GetIntValue() == NS_COLOR_CURRENTCOLOR) ||

  5794       colorValue->GetUnit() == eCSSUnit_Unset) {

  5795     color->mColor = parentColor->mColor;

  5796     canStoreInRuleTree = false;

  5797   }

  5798   else if (colorValue->GetUnit() == eCSSUnit_Initial) {

  5799     color->mColor = mPresContext->DefaultColor();

  5800   }

  5801   else {

  5802     SetColor(*colorValue, parentColor->mColor, mPresContext, aContext,

  5803              color->mColor, canStoreInRuleTree);

  5804   }

  5806   COMPUTE_END_INHERITED(Color, color)

  5807 }

  5809 // information about how to compute values for background-* properties

  5810 template <class SpecifiedValueItem, class ComputedValueItem>

  5811 struct BackgroundItemComputer {

  5812 };

  5814 template <>

  5815 struct BackgroundItemComputer<nsCSSValueList, uint8_t>

  5816 {

  5817   static void ComputeValue(nsStyleContext* aStyleContext,

  5818                            const nsCSSValueList* aSpecifiedValue,

  5819                            uint8_t& aComputedValue,

  5820                            bool& aCanStoreInRuleTree)

  5821   {

  5822     SetDiscrete(aSpecifiedValue->mValue, aComputedValue, aCanStoreInRuleTree,

  5823                 SETDSC_ENUMERATED, uint8_t(0), 0, 0, 0, 0, 0);

  5824   }

  5825 };

  5827 template <>

  5828 struct BackgroundItemComputer<nsCSSValuePairList, nsStyleBackground::Repeat>

  5829 {

  5830   static void ComputeValue(nsStyleContext* aStyleContext,

  5831                            const nsCSSValuePairList* aSpecifiedValue,

  5832                            nsStyleBackground::Repeat& aComputedValue,

  5833                            bool& aCanStoreInRuleTree)

  5834   {

  5835     NS_ASSERTION(aSpecifiedValue->mXValue.GetUnit() == eCSSUnit_Enumerated &&

  5836                  (aSpecifiedValue->mYValue.GetUnit() == eCSSUnit_Enumerated ||

  5837                   aSpecifiedValue->mYValue.GetUnit() == eCSSUnit_Null),

  5838                  "Invalid unit");

  5840     bool hasContraction = true;

  5841     uint8_t value = aSpecifiedValue->mXValue.GetIntValue();

  5842     switch (value) {

  5843     case NS_STYLE_BG_REPEAT_REPEAT_X:

  5844       aComputedValue.mXRepeat = NS_STYLE_BG_REPEAT_REPEAT;

  5845       aComputedValue.mYRepeat = NS_STYLE_BG_REPEAT_NO_REPEAT;

  5846       break;

  5847     case NS_STYLE_BG_REPEAT_REPEAT_Y:

  5848       aComputedValue.mXRepeat = NS_STYLE_BG_REPEAT_NO_REPEAT;

  5849       aComputedValue.mYRepeat = NS_STYLE_BG_REPEAT_REPEAT;

  5850       break;

  5851     default:

  5852       aComputedValue.mXRepeat = value;

  5853       hasContraction = false;

  5854       break;

  5855     }

  5857     if (hasContraction) {

  5858       NS_ASSERTION(aSpecifiedValue->mYValue.GetUnit() == eCSSUnit_Null,

  5859                    "Invalid unit.");

  5860       return;

  5861     }

  5863     switch (aSpecifiedValue->mYValue.GetUnit()) {

  5864     case eCSSUnit_Null:

  5865       aComputedValue.mYRepeat = aComputedValue.mXRepeat;

  5866       break;

  5867     case eCSSUnit_Enumerated:

  5868       value = aSpecifiedValue->mYValue.GetIntValue();

  5869       NS_ASSERTION(value == NS_STYLE_BG_REPEAT_NO_REPEAT ||

  5870                    value == NS_STYLE_BG_REPEAT_REPEAT, "Unexpected value");

  5871       aComputedValue.mYRepeat = value;

  5872       break;

  5873     default:

  5874       NS_NOTREACHED("Unexpected CSS value");

  5875       break;

  5876     }

  5877   }

  5878 };

  5880 template <>

  5881 struct BackgroundItemComputer<nsCSSValueList, nsStyleImage>

  5882 {

  5883   static void ComputeValue(nsStyleContext* aStyleContext,

  5884                            const nsCSSValueList* aSpecifiedValue,

  5885                            nsStyleImage& aComputedValue,

  5886                            bool& aCanStoreInRuleTree)

  5887   {

  5888     SetStyleImage(aStyleContext, aSpecifiedValue->mValue, aComputedValue,

  5889                   aCanStoreInRuleTree);

  5890   }

  5891 };

  5893 /* Helper function for

  5894  * BackgroundItemComputer<nsCSSValue, nsStyleBackground::Position>

  5895  * It computes a single PositionCoord from an nsCSSValue object

  5896  * (contained in a list).

  5897  */

  5898 typedef nsStyleBackground::Position::PositionCoord PositionCoord;

  5899 static void

  5900 ComputeBackgroundPositionCoord(nsStyleContext* aStyleContext,

  5901                                const nsCSSValue& aEdge,

  5902                                const nsCSSValue& aOffset,

  5903                                PositionCoord* aResult,

  5904                                bool& aCanStoreInRuleTree)

  5905 {

  5906   if (eCSSUnit_Percent == aOffset.GetUnit()) {

  5907     aResult->mLength = 0;

  5908     aResult->mPercent = aOffset.GetPercentValue();

  5909     aResult->mHasPercent = true;

  5910   } else if (aOffset.IsLengthUnit()) {

  5911     aResult->mLength = CalcLength(aOffset, aStyleContext,

  5912                                   aStyleContext->PresContext(),

  5913                                   aCanStoreInRuleTree);

  5914     aResult->mPercent = 0.0f;

  5915     aResult->mHasPercent = false;

  5916   } else if (aOffset.IsCalcUnit()) {

  5917     LengthPercentPairCalcOps ops(aStyleContext,

  5918                                  aStyleContext->PresContext(),

  5919                                  aCanStoreInRuleTree);

  5920     nsRuleNode::ComputedCalc vals = ComputeCalc(aOffset, ops);

  5921     aResult->mLength = vals.mLength;

  5922     aResult->mPercent = vals.mPercent;

  5923     aResult->mHasPercent = ops.mHasPercent;

  5924   } else {

  5925     aResult->mLength = 0;

  5926     aResult->mPercent = 0.0f;

  5927     aResult->mHasPercent = false;

  5928     NS_ASSERTION(aOffset.GetUnit() == eCSSUnit_Null, "unexpected unit");

  5929   }

  5931   if (eCSSUnit_Enumerated == aEdge.GetUnit()) {

  5932     int sign;

  5933     if (aEdge.GetIntValue() & (NS_STYLE_BG_POSITION_BOTTOM |

  5934                                NS_STYLE_BG_POSITION_RIGHT)) {

  5935       sign = -1;

  5936     } else {

  5937       sign = 1;

  5938     }

  5939     aResult->mPercent = GetFloatFromBoxPosition(aEdge.GetIntValue()) +

  5940                         sign * aResult->mPercent;

  5941     aResult->mLength = sign * aResult->mLength;

  5942     aResult->mHasPercent = true;

  5943   } else {

  5944     NS_ASSERTION(eCSSUnit_Null == aEdge.GetUnit(), "unexpected unit");

  5945   }

  5946 }

  5948 template <>

  5949 struct BackgroundItemComputer<nsCSSValueList, nsStyleBackground::Position>

  5950 {

  5951   static void ComputeValue(nsStyleContext* aStyleContext,

  5952                            const nsCSSValueList* aSpecifiedValue,

  5953                            nsStyleBackground::Position& aComputedValue,

  5954                            bool& aCanStoreInRuleTree)

  5955   {

  5956     NS_ASSERTION(aSpecifiedValue->mValue.GetUnit() == eCSSUnit_Array, "bg-position not an array");

  5958     nsRefPtr<nsCSSValue::Array> bgPositionArray =

  5959                                   aSpecifiedValue->mValue.GetArrayValue();

  5960     const nsCSSValue &xEdge   = bgPositionArray->Item(0);

  5961     const nsCSSValue &xOffset = bgPositionArray->Item(1);

  5962     const nsCSSValue &yEdge   = bgPositionArray->Item(2);

  5963     const nsCSSValue &yOffset = bgPositionArray->Item(3);

  5965     NS_ASSERTION((eCSSUnit_Enumerated == xEdge.GetUnit()  ||

  5966                   eCSSUnit_Null       == xEdge.GetUnit()) &&

  5967                  (eCSSUnit_Enumerated == yEdge.GetUnit()  ||

  5968                   eCSSUnit_Null       == yEdge.GetUnit()) &&

  5969                   eCSSUnit_Enumerated != xOffset.GetUnit()  &&

  5970                   eCSSUnit_Enumerated != yOffset.GetUnit(),

  5971                   "Invalid background position");

  5973     ComputeBackgroundPositionCoord(aStyleContext, xEdge, xOffset,

  5974                                    &aComputedValue.mXPosition,

  5975                                    aCanStoreInRuleTree);

  5977     ComputeBackgroundPositionCoord(aStyleContext, yEdge, yOffset,

  5978                                    &aComputedValue.mYPosition,

  5979                                    aCanStoreInRuleTree);

  5980   }

  5981 };

  5984 struct BackgroundSizeAxis {

  5985   nsCSSValue nsCSSValuePairList::* specified;

  5986   nsStyleBackground::Size::Dimension nsStyleBackground::Size::* result;

  5987   uint8_t nsStyleBackground::Size::* type;

  5988 };

  5990 static const BackgroundSizeAxis gBGSizeAxes[] = {

  5991   { &nsCSSValuePairList::mXValue,

  5992     &nsStyleBackground::Size::mWidth,

  5993     &nsStyleBackground::Size::mWidthType },

  5994   { &nsCSSValuePairList::mYValue,

  5995     &nsStyleBackground::Size::mHeight,

  5996     &nsStyleBackground::Size::mHeightType }

  5997 };

  5999 template <>

  6000 struct BackgroundItemComputer<nsCSSValuePairList, nsStyleBackground::Size>

  6001 {

  6002   static void ComputeValue(nsStyleContext* aStyleContext,

  6003                            const nsCSSValuePairList* aSpecifiedValue,

  6004                            nsStyleBackground::Size& aComputedValue,

  6005                            bool& aCanStoreInRuleTree)

  6006   {

  6007     nsStyleBackground::Size &size = aComputedValue;

  6008     for (const BackgroundSizeAxis *axis = gBGSizeAxes,

  6009                         *axis_end = ArrayEnd(gBGSizeAxes);

  6010          axis < axis_end; ++axis) {

  6011       const nsCSSValue &specified = aSpecifiedValue->*(axis->specified);

  6012       if (eCSSUnit_Auto == specified.GetUnit()) {

  6013         size.*(axis->type) = nsStyleBackground::Size::eAuto;

  6014       }

  6015       else if (eCSSUnit_Enumerated == specified.GetUnit()) {

  6016         static_assert(nsStyleBackground::Size::eContain ==

  6017                       NS_STYLE_BG_SIZE_CONTAIN &&

  6018                       nsStyleBackground::Size::eCover ==

  6019                       NS_STYLE_BG_SIZE_COVER,

  6020                       "background size constants out of sync");

  6021         NS_ABORT_IF_FALSE(specified.GetIntValue() == NS_STYLE_BG_SIZE_CONTAIN ||

  6022                           specified.GetIntValue() == NS_STYLE_BG_SIZE_COVER,

  6023                           "invalid enumerated value for size coordinate");

  6024         size.*(axis->type) = specified.GetIntValue();

  6025       }

  6026       else if (eCSSUnit_Null == specified.GetUnit()) {

  6027         NS_ABORT_IF_FALSE(axis == gBGSizeAxes + 1,

  6028                           "null allowed only as height value, and only "

  6029                           "for contain/cover/initial/inherit");

  6030 #ifdef DEBUG

  6031         {

  6032           const nsCSSValue &widthValue = aSpecifiedValue->mXValue;

  6033           NS_ABORT_IF_FALSE(widthValue.GetUnit() != eCSSUnit_Inherit &&

  6034                             widthValue.GetUnit() != eCSSUnit_Initial &&

  6035                             widthValue.GetUnit() != eCSSUnit_Unset,

  6036                             "initial/inherit/unset should already have been handled");

  6037           NS_ABORT_IF_FALSE(widthValue.GetUnit() == eCSSUnit_Enumerated &&

  6038                             (widthValue.GetIntValue() == NS_STYLE_BG_SIZE_CONTAIN ||

  6039                              widthValue.GetIntValue() == NS_STYLE_BG_SIZE_COVER),

  6040                             "null height value not corresponding to allowable "

  6041                             "non-null width value");

  6042         }

  6043 #endif

  6044         size.*(axis->type) = size.mWidthType;

  6045       }

  6046       else if (eCSSUnit_Percent == specified.GetUnit()) {

  6047         (size.*(axis->result)).mLength = 0;

  6048         (size.*(axis->result)).mPercent = specified.GetPercentValue();

  6049         (size.*(axis->result)).mHasPercent = true;

  6050         size.*(axis->type) = nsStyleBackground::Size::eLengthPercentage;

  6051       }

  6052       else if (specified.IsLengthUnit()) {

  6053         (size.*(axis->result)).mLength =

  6054           CalcLength(specified, aStyleContext, aStyleContext->PresContext(),

  6055                      aCanStoreInRuleTree);

  6056         (size.*(axis->result)).mPercent = 0.0f;

  6057         (size.*(axis->result)).mHasPercent = false;

  6058         size.*(axis->type) = nsStyleBackground::Size::eLengthPercentage;

  6059       } else {

  6060         NS_ABORT_IF_FALSE(specified.IsCalcUnit(), "unexpected unit");

  6061         LengthPercentPairCalcOps ops(aStyleContext,

  6062                                      aStyleContext->PresContext(),

  6063                                      aCanStoreInRuleTree);

  6064         nsRuleNode::ComputedCalc vals = ComputeCalc(specified, ops);

  6065         (size.*(axis->result)).mLength = vals.mLength;

  6066         (size.*(axis->result)).mPercent = vals.mPercent;

  6067         (size.*(axis->result)).mHasPercent = ops.mHasPercent;

  6068         size.*(axis->type) = nsStyleBackground::Size::eLengthPercentage;

  6069       }

  6070     }

  6072     NS_ABORT_IF_FALSE(size.mWidthType < nsStyleBackground::Size::eDimensionType_COUNT,

  6073                       "bad width type");

  6074     NS_ABORT_IF_FALSE(size.mHeightType < nsStyleBackground::Size::eDimensionType_COUNT,

  6075                       "bad height type");

  6076     NS_ABORT_IF_FALSE((size.mWidthType != nsStyleBackground::Size::eContain &&

  6077                        size.mWidthType != nsStyleBackground::Size::eCover) ||

  6078                       size.mWidthType == size.mHeightType,

  6079                       "contain/cover apply to both dimensions or to neither");

  6080   }

  6081 };

  6083 template <class ComputedValueItem>

  6084 static void

  6085 SetBackgroundList(nsStyleContext* aStyleContext,

  6086                   const nsCSSValue& aValue,

  6087                   nsAutoTArray< nsStyleBackground::Layer, 1> &aLayers,

  6088                   const nsAutoTArray<nsStyleBackground::Layer, 1> &aParentLayers,

  6089                   ComputedValueItem nsStyleBackground::Layer::* aResultLocation,

  6090                   ComputedValueItem aInitialValue,

  6091                   uint32_t aParentItemCount,

  6092                   uint32_t& aItemCount,

  6093                   uint32_t& aMaxItemCount,

  6094                   bool& aRebuild,

  6095                   bool& aCanStoreInRuleTree)

  6096 {

  6097   switch (aValue.GetUnit()) {

  6098   case eCSSUnit_Null:

  6099     break;

  6101   case eCSSUnit_Inherit:

  6102     aRebuild = true;

  6103     aCanStoreInRuleTree = false;

  6104     aLayers.EnsureLengthAtLeast(aParentItemCount);

  6105     aItemCount = aParentItemCount;

  6106     for (uint32_t i = 0; i < aParentItemCount; ++i) {

  6107       aLayers[i].*aResultLocation = aParentLayers[i].*aResultLocation;

  6108     }

  6109     break;

  6111   case eCSSUnit_Initial:

  6112   case eCSSUnit_Unset:

  6113     aRebuild = true;

  6114     aItemCount = 1;

  6115     aLayers[0].*aResultLocation = aInitialValue;

  6116     break;

  6118   case eCSSUnit_List:

  6119   case eCSSUnit_ListDep: {

  6120     aRebuild = true;

  6121     aItemCount = 0;

  6122     const nsCSSValueList* item = aValue.GetListValue();

  6123     do {

  6124       NS_ASSERTION(item->mValue.GetUnit() != eCSSUnit_Null &&

  6125                    item->mValue.GetUnit() != eCSSUnit_Inherit &&

  6126                    item->mValue.GetUnit() != eCSSUnit_Initial &&

  6127                    item->mValue.GetUnit() != eCSSUnit_Unset,

  6128                    "unexpected unit");

  6129       ++aItemCount;

  6130       aLayers.EnsureLengthAtLeast(aItemCount);

  6131       BackgroundItemComputer<nsCSSValueList, ComputedValueItem>

  6132         ::ComputeValue(aStyleContext, item,

  6133                        aLayers[aItemCount-1].*aResultLocation,

  6134                        aCanStoreInRuleTree);

  6135       item = item->mNext;

  6136     } while (item);

  6137     break;

  6138   }

  6140   default:

  6141     NS_ABORT_IF_FALSE(false,

  6142                       nsPrintfCString("unexpected unit %d",

  6143                                       aValue.GetUnit()).get());

  6144   }

  6146   if (aItemCount > aMaxItemCount)

  6147     aMaxItemCount = aItemCount;

  6148 }

  6150 template <class ComputedValueItem>

  6151 static void

  6152 SetBackgroundPairList(nsStyleContext* aStyleContext,

  6153                       const nsCSSValue& aValue,

  6154                       nsAutoTArray< nsStyleBackground::Layer, 1> &aLayers,

  6155                       const nsAutoTArray<nsStyleBackground::Layer, 1>

  6156                                                                  &aParentLayers,

  6157                       ComputedValueItem nsStyleBackground::Layer::*

  6158                                                                 aResultLocation,

  6159                       ComputedValueItem aInitialValue,

  6160                       uint32_t aParentItemCount,

  6161                       uint32_t& aItemCount,

  6162                       uint32_t& aMaxItemCount,

  6163                       bool& aRebuild,

  6164                       bool& aCanStoreInRuleTree)

  6165 {

  6166   switch (aValue.GetUnit()) {

  6167   case eCSSUnit_Null:

  6168     break;

  6170   case eCSSUnit_Inherit:

  6171     aRebuild = true;

  6172     aCanStoreInRuleTree = false;

  6173     aLayers.EnsureLengthAtLeast(aParentItemCount);

  6174     aItemCount = aParentItemCount;

  6175     for (uint32_t i = 0; i < aParentItemCount; ++i) {

  6176       aLayers[i].*aResultLocation = aParentLayers[i].*aResultLocation;

  6177     }

  6178     break;

  6180   case eCSSUnit_Initial:

  6181   case eCSSUnit_Unset:

  6182     aRebuild = true;

  6183     aItemCount = 1;

  6184     aLayers[0].*aResultLocation = aInitialValue;

  6185     break;

  6187   case eCSSUnit_PairList:

  6188   case eCSSUnit_PairListDep: {

  6189     aRebuild = true;

  6190     aItemCount = 0;

  6191     const nsCSSValuePairList* item = aValue.GetPairListValue();

  6192     do {

  6193       NS_ASSERTION(item->mXValue.GetUnit() != eCSSUnit_Inherit &&

  6194                    item->mXValue.GetUnit() != eCSSUnit_Initial &&

  6195                    item->mXValue.GetUnit() != eCSSUnit_Unset &&

  6196                    item->mYValue.GetUnit() != eCSSUnit_Inherit &&

  6197                    item->mYValue.GetUnit() != eCSSUnit_Initial &&

  6198                    item->mYValue.GetUnit() != eCSSUnit_Unset,

  6199                    "unexpected unit");

  6200       ++aItemCount;

  6201       aLayers.EnsureLengthAtLeast(aItemCount);

  6202       BackgroundItemComputer<nsCSSValuePairList, ComputedValueItem>

  6203         ::ComputeValue(aStyleContext, item,

  6204                        aLayers[aItemCount-1].*aResultLocation,

  6205                        aCanStoreInRuleTree);

  6206       item = item->mNext;

  6207     } while (item);

  6208     break;

  6209   }

  6211   default:

  6212     NS_ABORT_IF_FALSE(false,

  6213                       nsPrintfCString("unexpected unit %d",

  6214                                       aValue.GetUnit()).get());

  6215   }

  6217   if (aItemCount > aMaxItemCount)

  6218     aMaxItemCount = aItemCount;

  6219 }

  6221 template <class ComputedValueItem>

  6222 static void

  6223 FillBackgroundList(nsAutoTArray< nsStyleBackground::Layer, 1> &aLayers,

  6224     ComputedValueItem nsStyleBackground::Layer::* aResultLocation,

  6225     uint32_t aItemCount, uint32_t aFillCount)

  6226 {

  6227   NS_PRECONDITION(aFillCount <= aLayers.Length(), "unexpected array length");

  6228   for (uint32_t sourceLayer = 0, destLayer = aItemCount;

  6229        destLayer < aFillCount;

  6230        ++sourceLayer, ++destLayer) {

  6231     aLayers[destLayer].*aResultLocation =

  6232       aLayers[sourceLayer].*aResultLocation;

  6233   }

  6234 }

  6236 const void*

  6237 nsRuleNode::ComputeBackgroundData(void* aStartStruct,

  6238                                   const nsRuleData* aRuleData,

  6239                                   nsStyleContext* aContext,

  6240                                   nsRuleNode* aHighestNode,

  6241                                   const RuleDetail aRuleDetail,

  6242                                   const bool aCanStoreInRuleTree)

  6243 {

  6244   COMPUTE_START_RESET(Background, (), bg, parentBG)

  6246   // background-color: color, string, inherit

  6247   const nsCSSValue* backColorValue = aRuleData->ValueForBackgroundColor();

  6248   if (eCSSUnit_Initial == backColorValue->GetUnit() ||

  6249       eCSSUnit_Unset == backColorValue->GetUnit()) {

  6250     bg->mBackgroundColor = NS_RGBA(0, 0, 0, 0);

  6251   } else if (!SetColor(*backColorValue, parentBG->mBackgroundColor,

  6252                        mPresContext, aContext, bg->mBackgroundColor,

  6253                        canStoreInRuleTree)) {

  6254     NS_ASSERTION(eCSSUnit_Null == backColorValue->GetUnit(),

  6255                  "unexpected color unit");

  6256   }

  6258   uint32_t maxItemCount = 1;

  6259   bool rebuild = false;

  6261   // background-image: url (stored as image), none, inherit [list]

  6262   nsStyleImage initialImage;

  6263   SetBackgroundList(aContext, *aRuleData->ValueForBackgroundImage(),

  6264                     bg->mLayers,

  6265                     parentBG->mLayers, &nsStyleBackground::Layer::mImage,

  6266                     initialImage, parentBG->mImageCount, bg->mImageCount,

  6267                     maxItemCount, rebuild, canStoreInRuleTree);

  6269   // background-repeat: enum, inherit, initial [pair list]

  6270   nsStyleBackground::Repeat initialRepeat;

  6271   initialRepeat.SetInitialValues();

  6272   SetBackgroundPairList(aContext, *aRuleData->ValueForBackgroundRepeat(),

  6273                         bg->mLayers,

  6274                         parentBG->mLayers, &nsStyleBackground::Layer::mRepeat,

  6275                         initialRepeat, parentBG->mRepeatCount,

  6276                         bg->mRepeatCount, maxItemCount, rebuild,

  6277                         canStoreInRuleTree);

  6279   // background-attachment: enum, inherit, initial [list]

  6280   SetBackgroundList(aContext, *aRuleData->ValueForBackgroundAttachment(),

  6281                     bg->mLayers, parentBG->mLayers,

  6282                     &nsStyleBackground::Layer::mAttachment,

  6283                     uint8_t(NS_STYLE_BG_ATTACHMENT_SCROLL),

  6284                     parentBG->mAttachmentCount,

  6285                     bg->mAttachmentCount, maxItemCount, rebuild,

  6286                     canStoreInRuleTree);

  6288   // background-clip: enum, inherit, initial [list]

  6289   SetBackgroundList(aContext, *aRuleData->ValueForBackgroundClip(),

  6290                     bg->mLayers,

  6291                     parentBG->mLayers, &nsStyleBackground::Layer::mClip,

  6292                     uint8_t(NS_STYLE_BG_CLIP_BORDER), parentBG->mClipCount,

  6293                     bg->mClipCount, maxItemCount, rebuild, canStoreInRuleTree);

  6295   // background-inline-policy: enum, inherit, initial

  6296   SetDiscrete(*aRuleData->ValueForBackgroundInlinePolicy(),

  6297               bg->mBackgroundInlinePolicy,

  6298               canStoreInRuleTree,

  6299               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  6300               parentBG->mBackgroundInlinePolicy,

  6301               NS_STYLE_BG_INLINE_POLICY_CONTINUOUS, 0, 0, 0, 0);

  6303   // background-blend-mode: enum, inherit, initial [list]

  6304   SetBackgroundList(aContext, *aRuleData->ValueForBackgroundBlendMode(),

  6305                     bg->mLayers,

  6306                     parentBG->mLayers, &nsStyleBackground::Layer::mBlendMode,

  6307                     uint8_t(NS_STYLE_BLEND_NORMAL), parentBG->mBlendModeCount,

  6308                     bg->mBlendModeCount, maxItemCount, rebuild,

  6309                     canStoreInRuleTree);

  6311   // background-origin: enum, inherit, initial [list]

  6312   SetBackgroundList(aContext, *aRuleData->ValueForBackgroundOrigin(),

  6313                     bg->mLayers,

  6314                     parentBG->mLayers, &nsStyleBackground::Layer::mOrigin,

  6315                     uint8_t(NS_STYLE_BG_ORIGIN_PADDING), parentBG->mOriginCount,

  6316                     bg->mOriginCount, maxItemCount, rebuild,

  6317                     canStoreInRuleTree);

  6319   // background-position: enum, length, percent (flags), inherit [pair list]

  6320   nsStyleBackground::Position initialPosition;

  6321   initialPosition.SetInitialValues();

  6322   SetBackgroundList(aContext, *aRuleData->ValueForBackgroundPosition(),

  6323                     bg->mLayers,

  6324                     parentBG->mLayers, &nsStyleBackground::Layer::mPosition,

  6325                     initialPosition, parentBG->mPositionCount,

  6326                     bg->mPositionCount, maxItemCount, rebuild,

  6327                     canStoreInRuleTree);

  6329   // background-size: enum, length, auto, inherit, initial [pair list]

  6330   nsStyleBackground::Size initialSize;

  6331   initialSize.SetInitialValues();

  6332   SetBackgroundPairList(aContext, *aRuleData->ValueForBackgroundSize(),

  6333                         bg->mLayers,

  6334                         parentBG->mLayers, &nsStyleBackground::Layer::mSize,

  6335                         initialSize, parentBG->mSizeCount,

  6336                         bg->mSizeCount, maxItemCount, rebuild,

  6337                         canStoreInRuleTree);

  6339   if (rebuild) {

  6340     // Delete any extra items.  We need to keep layers in which any

  6341     // property was specified.

  6342     bg->mLayers.TruncateLength(maxItemCount);

  6344     uint32_t fillCount = bg->mImageCount;

  6345     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mImage,

  6346                        bg->mImageCount, fillCount);

  6347     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mRepeat,

  6348                        bg->mRepeatCount, fillCount);

  6349     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mAttachment,

  6350                        bg->mAttachmentCount, fillCount);

  6351     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mClip,

  6352                        bg->mClipCount, fillCount);

  6353     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mBlendMode,

  6354                        bg->mBlendModeCount, fillCount);

  6355     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mOrigin,

  6356                        bg->mOriginCount, fillCount);

  6357     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mPosition,

  6358                        bg->mPositionCount, fillCount);

  6359     FillBackgroundList(bg->mLayers, &nsStyleBackground::Layer::mSize,

  6360                        bg->mSizeCount, fillCount);

  6361   }

  6363   // Now that the dust has settled, register the images with the document

  6364   for (uint32_t i = 0; i < bg->mImageCount; ++i)

  6365     bg->mLayers[i].TrackImages(aContext->PresContext());

  6367   COMPUTE_END_RESET(Background, bg)

  6368 }

  6370 const void*

  6371 nsRuleNode::ComputeMarginData(void* aStartStruct,

  6372                               const nsRuleData* aRuleData,

  6373                               nsStyleContext* aContext,

  6374                               nsRuleNode* aHighestNode,

  6375                               const RuleDetail aRuleDetail,

  6376                               const bool aCanStoreInRuleTree)

  6377 {

  6378   COMPUTE_START_RESET(Margin, (), margin, parentMargin)

  6380   // margin: length, percent, auto, inherit

  6381   nsStyleCoord  coord;

  6382   nsCSSRect ourMargin;

  6383   ourMargin.mTop = *aRuleData->ValueForMarginTop();

  6384   ourMargin.mRight = *aRuleData->ValueForMarginRightValue();

  6385   ourMargin.mBottom = *aRuleData->ValueForMarginBottom();

  6386   ourMargin.mLeft = *aRuleData->ValueForMarginLeftValue();

  6387   AdjustLogicalBoxProp(aContext,

  6388                        *aRuleData->ValueForMarginLeftLTRSource(),

  6389                        *aRuleData->ValueForMarginLeftRTLSource(),

  6390                        *aRuleData->ValueForMarginStartValue(),

  6391                        *aRuleData->ValueForMarginEndValue(),

  6392                        NS_SIDE_LEFT, ourMargin, canStoreInRuleTree);

  6393   AdjustLogicalBoxProp(aContext,

  6394                        *aRuleData->ValueForMarginRightLTRSource(),

  6395                        *aRuleData->ValueForMarginRightRTLSource(),

  6396                        *aRuleData->ValueForMarginEndValue(),

  6397                        *aRuleData->ValueForMarginStartValue(),

  6398                        NS_SIDE_RIGHT, ourMargin, canStoreInRuleTree);

  6399   NS_FOR_CSS_SIDES(side) {

  6400     nsStyleCoord parentCoord = parentMargin->mMargin.Get(side);

  6401     if (SetCoord(ourMargin.*(nsCSSRect::sides[side]),

  6402                  coord, parentCoord,

  6403                  SETCOORD_LPAH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |

  6404                    SETCOORD_UNSET_INITIAL,

  6405                  aContext, mPresContext, canStoreInRuleTree)) {

  6406       margin->mMargin.Set(side, coord);

  6407     }

  6408   }

  6410   margin->RecalcData();

  6411   COMPUTE_END_RESET(Margin, margin)

  6412 }

  6414 static void

  6415 SetBorderImageRect(const nsCSSValue& aValue,

  6416                    /** outparam */ nsCSSRect& aRect)

  6417 {

  6418   switch (aValue.GetUnit()) {

  6419   case eCSSUnit_Null:

  6420     aRect.Reset();

  6421     break;

  6422   case eCSSUnit_Rect:

  6423     aRect = aValue.GetRectValue();

  6424     break;

  6425   case eCSSUnit_Inherit:

  6426   case eCSSUnit_Initial:

  6427   case eCSSUnit_Unset:

  6428     aRect.SetAllSidesTo(aValue);

  6429     break;

  6430   default:

  6431     NS_ASSERTION(false, "Unexpected border image value for rect.");

  6432   }

  6433 }

  6435 static void

  6436 SetBorderImagePair(const nsCSSValue& aValue,

  6437                    /** outparam */ nsCSSValuePair& aPair)

  6438 {

  6439   switch (aValue.GetUnit()) {

  6440   case eCSSUnit_Null:

  6441     aPair.Reset();

  6442     break;

  6443   case eCSSUnit_Pair:

  6444     aPair = aValue.GetPairValue();

  6445     break;

  6446   case eCSSUnit_Inherit:

  6447   case eCSSUnit_Initial:

  6448   case eCSSUnit_Unset:

  6449     aPair.SetBothValuesTo(aValue);

  6450     break;

  6451   default:

  6452     NS_ASSERTION(false, "Unexpected border image value for pair.");

  6453   }

  6454 }

  6456 static void

  6457 SetBorderImageSlice(const nsCSSValue& aValue,

  6458                     /** outparam */ nsCSSValue& aSlice,

  6459                     /** outparam */ nsCSSValue& aFill)

  6460 {

  6461   const nsCSSValueList* valueList;

  6462   switch (aValue.GetUnit()) {

  6463   case eCSSUnit_Null:

  6464     aSlice.Reset();

  6465     aFill.Reset();

  6466     break;

  6467   case eCSSUnit_List:

  6468     // Get slice dimensions.

  6469     valueList = aValue.GetListValue();

  6470     aSlice = valueList->mValue;

  6472     // Get "fill" keyword.

  6473     valueList = valueList->mNext;

  6474     if (valueList) {

  6475       aFill = valueList->mValue;

  6476     } else {

  6477       aFill.SetInitialValue();

  6478     }

  6479     break;

  6480   case eCSSUnit_Inherit:

  6481   case eCSSUnit_Initial:

  6482   case eCSSUnit_Unset:

  6483     aSlice = aValue;

  6484     aFill = aValue;

  6485     break;

  6486   default:

  6487     NS_ASSERTION(false, "Unexpected border image value for pair.");

  6488   }

  6489 }

  6491 const void*

  6492 nsRuleNode::ComputeBorderData(void* aStartStruct,

  6493                               const nsRuleData* aRuleData,

  6494                               nsStyleContext* aContext,

  6495                               nsRuleNode* aHighestNode,

  6496                               const RuleDetail aRuleDetail,

  6497                               const bool aCanStoreInRuleTree)

  6498 {

  6499   COMPUTE_START_RESET(Border, (mPresContext), border, parentBorder)

  6501   // box-shadow: none, list, inherit, initial

  6502   const nsCSSValue* boxShadowValue = aRuleData->ValueForBoxShadow();

  6503   switch (boxShadowValue->GetUnit()) {

  6504   case eCSSUnit_Null:

  6505     break;

  6507   case eCSSUnit_Initial:

  6508   case eCSSUnit_Unset:

  6509   case eCSSUnit_None:

  6510     border->mBoxShadow = nullptr;

  6511     break;

  6513   case eCSSUnit_Inherit:

  6514     border->mBoxShadow = parentBorder->mBoxShadow;

  6515     canStoreInRuleTree = false;

  6516     break;

  6518   case eCSSUnit_List:

  6519   case eCSSUnit_ListDep:

  6520     border->mBoxShadow = GetShadowData(boxShadowValue->GetListValue(),

  6521                                        aContext, true, canStoreInRuleTree);

  6522     break;

  6524   default:

  6525     NS_ABORT_IF_FALSE(false,

  6526                       nsPrintfCString("unrecognized shadow unit %d",

  6527                                       boxShadowValue->GetUnit()).get());

  6528   }

  6530   // border-width, border-*-width: length, enum, inherit

  6531   nsStyleCoord  coord;

  6532   nsCSSRect ourBorderWidth;

  6533   ourBorderWidth.mTop = *aRuleData->ValueForBorderTopWidth();

  6534   ourBorderWidth.mRight = *aRuleData->ValueForBorderRightWidthValue();

  6535   ourBorderWidth.mBottom = *aRuleData->ValueForBorderBottomWidth();

  6536   ourBorderWidth.mLeft = *aRuleData->ValueForBorderLeftWidthValue();

  6537   AdjustLogicalBoxProp(aContext,

  6538                        *aRuleData->ValueForBorderLeftWidthLTRSource(),

  6539                        *aRuleData->ValueForBorderLeftWidthRTLSource(),

  6540                        *aRuleData->ValueForBorderStartWidthValue(),

  6541                        *aRuleData->ValueForBorderEndWidthValue(),

  6542                        NS_SIDE_LEFT, ourBorderWidth, canStoreInRuleTree);

  6543   AdjustLogicalBoxProp(aContext,

  6544                        *aRuleData->ValueForBorderRightWidthLTRSource(),

  6545                        *aRuleData->ValueForBorderRightWidthRTLSource(),

  6546                        *aRuleData->ValueForBorderEndWidthValue(),

  6547                        *aRuleData->ValueForBorderStartWidthValue(),

  6548                        NS_SIDE_RIGHT, ourBorderWidth, canStoreInRuleTree);

  6549   { // scope for compilers with broken |for| loop scoping

  6550     NS_FOR_CSS_SIDES(side) {

  6551       const nsCSSValue &value = ourBorderWidth.*(nsCSSRect::sides[side]);

  6552       NS_ASSERTION(eCSSUnit_Percent != value.GetUnit(),

  6553                    "Percentage borders not implemented yet "

  6554                    "If implementing, make sure to fix all consumers of "

  6555                    "nsStyleBorder, the IsPercentageAwareChild method, "

  6556                    "the nsAbsoluteContainingBlock::FrameDependsOnContainer "

  6557                    "method, the "

  6558                    "nsLineLayout::IsPercentageAwareReplacedElement method "

  6559                    "and probably some other places");

  6560       if (eCSSUnit_Enumerated == value.GetUnit()) {

  6561         NS_ASSERTION(value.GetIntValue() == NS_STYLE_BORDER_WIDTH_THIN ||

  6562                      value.GetIntValue() == NS_STYLE_BORDER_WIDTH_MEDIUM ||

  6563                      value.GetIntValue() == NS_STYLE_BORDER_WIDTH_THICK,

  6564                      "Unexpected enum value");

  6565         border->SetBorderWidth(side,

  6566                                (mPresContext->GetBorderWidthTable())[value.GetIntValue()]);

  6567       }

  6568       // OK to pass bad aParentCoord since we're not passing SETCOORD_INHERIT

  6569       else if (SetCoord(value, coord, nsStyleCoord(),

  6570                         SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY,

  6571                         aContext, mPresContext, canStoreInRuleTree)) {

  6572         NS_ASSERTION(coord.GetUnit() == eStyleUnit_Coord, "unexpected unit");

  6573         // clamp negative calc() to 0.

  6574         border->SetBorderWidth(side, std::max(coord.GetCoordValue(), 0));

  6575       }

  6576       else if (eCSSUnit_Inherit == value.GetUnit()) {

  6577         canStoreInRuleTree = false;

  6578         border->SetBorderWidth(side,

  6579                                parentBorder->GetComputedBorder().Side(side));

  6580       }

  6581       else if (eCSSUnit_Initial == value.GetUnit() ||

  6582                eCSSUnit_Unset == value.GetUnit()) {

  6583         border->SetBorderWidth(side,

  6584           (mPresContext->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM]);

  6585       }

  6586       else {

  6587         NS_ASSERTION(eCSSUnit_Null == value.GetUnit(),

  6588                      "missing case handling border width");

  6589       }

  6590     }

  6591   }

  6593   // border-style, border-*-style: enum, inherit

  6594   nsCSSRect ourBorderStyle;

  6595   ourBorderStyle.mTop = *aRuleData->ValueForBorderTopStyle();

  6596   ourBorderStyle.mRight = *aRuleData->ValueForBorderRightStyleValue();

  6597   ourBorderStyle.mBottom = *aRuleData->ValueForBorderBottomStyle();

  6598   ourBorderStyle.mLeft = *aRuleData->ValueForBorderLeftStyleValue();

  6599   AdjustLogicalBoxProp(aContext,

  6600                        *aRuleData->ValueForBorderLeftStyleLTRSource(),

  6601                        *aRuleData->ValueForBorderLeftStyleRTLSource(),

  6602                        *aRuleData->ValueForBorderStartStyleValue(),

  6603                        *aRuleData->ValueForBorderEndStyleValue(),

  6604                        NS_SIDE_LEFT, ourBorderStyle, canStoreInRuleTree);

  6605   AdjustLogicalBoxProp(aContext,

  6606                        *aRuleData->ValueForBorderRightStyleLTRSource(),

  6607                        *aRuleData->ValueForBorderRightStyleRTLSource(),

  6608                        *aRuleData->ValueForBorderEndStyleValue(),

  6609                        *aRuleData->ValueForBorderStartStyleValue(),

  6610                        NS_SIDE_RIGHT, ourBorderStyle, canStoreInRuleTree);

  6611   { // scope for compilers with broken |for| loop scoping

  6612     NS_FOR_CSS_SIDES(side) {

  6613       const nsCSSValue &value = ourBorderStyle.*(nsCSSRect::sides[side]);

  6614       nsCSSUnit unit = value.GetUnit();

  6615       NS_ABORT_IF_FALSE(eCSSUnit_None != unit,

  6616                         "'none' should be handled as enumerated value");

  6617       if (eCSSUnit_Enumerated == unit) {

  6618         border->SetBorderStyle(side, value.GetIntValue());

  6619       }

  6620       else if (eCSSUnit_Initial == unit ||

  6621                eCSSUnit_Unset == unit) {

  6622         border->SetBorderStyle(side, NS_STYLE_BORDER_STYLE_NONE);

  6623       }

  6624       else if (eCSSUnit_Inherit == unit) {

  6625         canStoreInRuleTree = false;

  6626         border->SetBorderStyle(side, parentBorder->GetBorderStyle(side));

  6627       }

  6628     }

  6629   }

  6631   // -moz-border-*-colors: color, string, enum, none, inherit/initial

  6632   nscolor borderColor;

  6633   nscolor unused = NS_RGB(0,0,0);

  6635   static const nsCSSProperty borderColorsProps[] = {

  6636     eCSSProperty_border_top_colors,

  6637     eCSSProperty_border_right_colors,

  6638     eCSSProperty_border_bottom_colors,

  6639     eCSSProperty_border_left_colors

  6640   };

  6642   NS_FOR_CSS_SIDES(side) {

  6643     const nsCSSValue& value = *aRuleData->ValueFor(borderColorsProps[side]);

  6644     switch (value.GetUnit()) {

  6645     case eCSSUnit_Null:

  6646       break;

  6648     case eCSSUnit_Initial:

  6649     case eCSSUnit_Unset:

  6650     case eCSSUnit_None:

  6651       border->ClearBorderColors(side);

  6652       break;

  6654     case eCSSUnit_Inherit: {

  6655       canStoreInRuleTree = false;

  6656       border->ClearBorderColors(side);

  6657       if (parentContext) {

  6658         nsBorderColors *parentColors;

  6659         parentBorder->GetCompositeColors(side, &parentColors);

  6660         if (parentColors) {

  6661           border->EnsureBorderColors();

  6662           border->mBorderColors[side] = parentColors->Clone();

  6663         }

  6664       }

  6665       break;

  6666     }

  6668     case eCSSUnit_List:

  6669     case eCSSUnit_ListDep: {

  6670       // Some composite border color information has been specified for this

  6671       // border side.

  6672       border->EnsureBorderColors();

  6673       border->ClearBorderColors(side);

  6674       const nsCSSValueList* list = value.GetListValue();

  6675       while (list) {

  6676         if (SetColor(list->mValue, unused, mPresContext,

  6677                      aContext, borderColor, canStoreInRuleTree))

  6678           border->AppendBorderColor(side, borderColor);

  6679         else {

  6680           NS_NOTREACHED("unexpected item in -moz-border-*-colors list");

  6681         }

  6682         list = list->mNext;

  6683       }

  6684       break;

  6685     }

  6687     default:

  6688       NS_ABORT_IF_FALSE(false, "unrecognized border color unit");

  6689     }

  6690   }

  6692   // border-color, border-*-color: color, string, enum, inherit

  6693   bool foreground;

  6694   nsCSSRect ourBorderColor;

  6695   ourBorderColor.mTop = *aRuleData->ValueForBorderTopColor();

  6696   ourBorderColor.mRight = *aRuleData->ValueForBorderRightColorValue();

  6697   ourBorderColor.mBottom = *aRuleData->ValueForBorderBottomColor();

  6698   ourBorderColor.mLeft = *aRuleData->ValueForBorderLeftColorValue();

  6699   AdjustLogicalBoxProp(aContext,

  6700                        *aRuleData->ValueForBorderLeftColorLTRSource(),

  6701                        *aRuleData->ValueForBorderLeftColorRTLSource(),

  6702                        *aRuleData->ValueForBorderStartColorValue(),

  6703                        *aRuleData->ValueForBorderEndColorValue(),

  6704                        NS_SIDE_LEFT, ourBorderColor, canStoreInRuleTree);

  6705   AdjustLogicalBoxProp(aContext,

  6706                        *aRuleData->ValueForBorderRightColorLTRSource(),

  6707                        *aRuleData->ValueForBorderRightColorRTLSource(),

  6708                        *aRuleData->ValueForBorderEndColorValue(),

  6709                        *aRuleData->ValueForBorderStartColorValue(),

  6710                        NS_SIDE_RIGHT, ourBorderColor, canStoreInRuleTree);

  6711   { // scope for compilers with broken |for| loop scoping

  6712     NS_FOR_CSS_SIDES(side) {

  6713       const nsCSSValue &value = ourBorderColor.*(nsCSSRect::sides[side]);

  6714       if (eCSSUnit_Inherit == value.GetUnit()) {

  6715         canStoreInRuleTree = false;

  6716         if (parentContext) {

  6717           parentBorder->GetBorderColor(side, borderColor, foreground);

  6718           if (foreground) {

  6719             // We want to inherit the color from the parent, not use the

  6720             // color on the element where this chunk of style data will be

  6721             // used.  We can ensure that the data for the parent are fully

  6722             // computed (unlike for the element where this will be used, for

  6723             // which the color could be specified on a more specific rule).

  6724             border->SetBorderColor(side, parentContext->StyleColor()->mColor);

  6725           } else

  6726             border->SetBorderColor(side, borderColor);

  6727         } else {

  6728           // We're the root

  6729           border->SetBorderToForeground(side);

  6730         }

  6731       }

  6732       else if (SetColor(value, unused, mPresContext, aContext, borderColor,

  6733                         canStoreInRuleTree)) {

  6734         border->SetBorderColor(side, borderColor);

  6735       }

  6736       else if (eCSSUnit_Enumerated == value.GetUnit()) {

  6737         switch (value.GetIntValue()) {

  6738           case NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR:

  6739             border->SetBorderToForeground(side);

  6740             break;

  6741           default:

  6742             NS_NOTREACHED("Unexpected enumerated color");

  6743             break;

  6744         }

  6745       }

  6746       else if (eCSSUnit_Initial == value.GetUnit() ||

  6747                eCSSUnit_Unset == value.GetUnit()) {

  6748         border->SetBorderToForeground(side);

  6749       }

  6750     }

  6751   }

  6753   // border-radius: length, percent, inherit

  6754   {

  6755     const nsCSSProperty* subprops =

  6756       nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_radius);

  6757     NS_FOR_CSS_FULL_CORNERS(corner) {

  6758       int cx = NS_FULL_TO_HALF_CORNER(corner, false);

  6759       int cy = NS_FULL_TO_HALF_CORNER(corner, true);

  6760       const nsCSSValue& radius = *aRuleData->ValueFor(subprops[corner]);

  6761       nsStyleCoord parentX = parentBorder->mBorderRadius.Get(cx);

  6762       nsStyleCoord parentY = parentBorder->mBorderRadius.Get(cy);

  6763       nsStyleCoord coordX, coordY;

  6765       if (SetPairCoords(radius, coordX, coordY, parentX, parentY,

  6766                         SETCOORD_LPH | SETCOORD_INITIAL_ZERO |

  6767                           SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL,

  6768                         aContext, mPresContext, canStoreInRuleTree)) {

  6769         border->mBorderRadius.Set(cx, coordX);

  6770         border->mBorderRadius.Set(cy, coordY);

  6771       }

  6772     }

  6773   }

  6775   // float-edge: enum, inherit, initial

  6776   SetDiscrete(*aRuleData->ValueForFloatEdge(),

  6777               border->mFloatEdge, canStoreInRuleTree,

  6778               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  6779               parentBorder->mFloatEdge,

  6780               NS_STYLE_FLOAT_EDGE_CONTENT, 0, 0, 0, 0);

  6782   // border-image-source

  6783   const nsCSSValue* borderImageSource = aRuleData->ValueForBorderImageSource();

  6784   if (borderImageSource->GetUnit() == eCSSUnit_Inherit) {

  6785     canStoreInRuleTree = false;

  6786     border->mBorderImageSource = parentBorder->mBorderImageSource;

  6787   } else {

  6788     SetStyleImage(aContext,

  6789                   *borderImageSource,

  6790                   border->mBorderImageSource,

  6791                   canStoreInRuleTree);

  6792   }

  6794   nsCSSValue borderImageSliceValue;

  6795   nsCSSValue borderImageSliceFill;

  6796   SetBorderImageSlice(*aRuleData->ValueForBorderImageSlice(),

  6797                       borderImageSliceValue, borderImageSliceFill);

  6799   // border-image-slice: fill

  6800   SetDiscrete(borderImageSliceFill,

  6801               border->mBorderImageFill,

  6802               canStoreInRuleTree,

  6803               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  6804               parentBorder->mBorderImageFill,

  6805               NS_STYLE_BORDER_IMAGE_SLICE_NOFILL, 0, 0, 0, 0);

  6807   nsCSSRect borderImageSlice;

  6808   SetBorderImageRect(borderImageSliceValue, borderImageSlice);

  6810   nsCSSRect borderImageWidth;

  6811   SetBorderImageRect(*aRuleData->ValueForBorderImageWidth(),

  6812                      borderImageWidth);

  6814   nsCSSRect borderImageOutset;

  6815   SetBorderImageRect(*aRuleData->ValueForBorderImageOutset(),

  6816                      borderImageOutset);

  6818   NS_FOR_CSS_SIDES (side) {

  6819     // border-image-slice

  6820     if (SetCoord(borderImageSlice.*(nsCSSRect::sides[side]), coord,

  6821                  parentBorder->mBorderImageSlice.Get(side),

  6822                  SETCOORD_FACTOR | SETCOORD_PERCENT |

  6823                    SETCOORD_INHERIT | SETCOORD_INITIAL_HUNDRED_PCT |

  6824                    SETCOORD_UNSET_INITIAL,

  6825                  aContext, mPresContext, canStoreInRuleTree)) {

  6826       border->mBorderImageSlice.Set(side, coord);

  6827     }

  6829     // border-image-width

  6830     // 'auto' here means "same as slice"

  6831     if (SetCoord(borderImageWidth.*(nsCSSRect::sides[side]), coord,

  6832                  parentBorder->mBorderImageWidth.Get(side),

  6833                  SETCOORD_LPAH | SETCOORD_FACTOR | SETCOORD_INITIAL_FACTOR_ONE |

  6834                    SETCOORD_UNSET_INITIAL,

  6835                  aContext, mPresContext, canStoreInRuleTree)) {

  6836       border->mBorderImageWidth.Set(side, coord);

  6837     }

  6839     // border-image-outset

  6840     if (SetCoord(borderImageOutset.*(nsCSSRect::sides[side]), coord,

  6841                  parentBorder->mBorderImageOutset.Get(side),

  6842                  SETCOORD_LENGTH | SETCOORD_FACTOR |

  6843                    SETCOORD_INHERIT | SETCOORD_INITIAL_FACTOR_ZERO |

  6844                    SETCOORD_UNSET_INITIAL,

  6845                  aContext, mPresContext, canStoreInRuleTree)) {

  6846       border->mBorderImageOutset.Set(side, coord);

  6847     }

  6848   }

  6850   // border-image-repeat

  6851   nsCSSValuePair borderImageRepeat;

  6852   SetBorderImagePair(*aRuleData->ValueForBorderImageRepeat(),

  6853                      borderImageRepeat);

  6855   SetDiscrete(borderImageRepeat.mXValue,

  6856               border->mBorderImageRepeatH,

  6857               canStoreInRuleTree,

  6858               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  6859               parentBorder->mBorderImageRepeatH,

  6860               NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH, 0, 0, 0, 0);

  6862   SetDiscrete(borderImageRepeat.mYValue,

  6863               border->mBorderImageRepeatV,

  6864               canStoreInRuleTree,

  6865               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  6866               parentBorder->mBorderImageRepeatV,

  6867               NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH, 0, 0, 0, 0);

  6869   border->TrackImage(aContext->PresContext());

  6871   COMPUTE_END_RESET(Border, border)

  6872 }

  6874 const void*

  6875 nsRuleNode::ComputePaddingData(void* aStartStruct,

  6876                                const nsRuleData* aRuleData,

  6877                                nsStyleContext* aContext,

  6878                                nsRuleNode* aHighestNode,

  6879                                const RuleDetail aRuleDetail,

  6880                                const bool aCanStoreInRuleTree)

  6881 {

  6882   COMPUTE_START_RESET(Padding, (), padding, parentPadding)

  6884   // padding: length, percent, inherit

  6885   nsStyleCoord  coord;

  6886   nsCSSRect ourPadding;

  6887   ourPadding.mTop = *aRuleData->ValueForPaddingTop();

  6888   ourPadding.mRight = *aRuleData->ValueForPaddingRightValue();

  6889   ourPadding.mBottom = *aRuleData->ValueForPaddingBottom();

  6890   ourPadding.mLeft = *aRuleData->ValueForPaddingLeftValue();

  6891   AdjustLogicalBoxProp(aContext,

  6892                        *aRuleData->ValueForPaddingLeftLTRSource(),

  6893                        *aRuleData->ValueForPaddingLeftRTLSource(),

  6894                        *aRuleData->ValueForPaddingStartValue(),

  6895                        *aRuleData->ValueForPaddingEndValue(),

  6896                        NS_SIDE_LEFT, ourPadding, canStoreInRuleTree);

  6897   AdjustLogicalBoxProp(aContext,

  6898                        *aRuleData->ValueForPaddingRightLTRSource(),

  6899                        *aRuleData->ValueForPaddingRightRTLSource(),

  6900                        *aRuleData->ValueForPaddingEndValue(),

  6901                        *aRuleData->ValueForPaddingStartValue(),

  6902                        NS_SIDE_RIGHT, ourPadding, canStoreInRuleTree);

  6903   NS_FOR_CSS_SIDES(side) {

  6904     nsStyleCoord parentCoord = parentPadding->mPadding.Get(side);

  6905     if (SetCoord(ourPadding.*(nsCSSRect::sides[side]),

  6906                  coord, parentCoord,

  6907                  SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |

  6908                    SETCOORD_UNSET_INITIAL,

  6909                  aContext, mPresContext, canStoreInRuleTree)) {

  6910       padding->mPadding.Set(side, coord);

  6911     }

  6912   }

  6914   padding->RecalcData();

  6915   COMPUTE_END_RESET(Padding, padding)

  6916 }

  6918 const void*

  6919 nsRuleNode::ComputeOutlineData(void* aStartStruct,

  6920                                const nsRuleData* aRuleData,

  6921                                nsStyleContext* aContext,

  6922                                nsRuleNode* aHighestNode,

  6923                                const RuleDetail aRuleDetail,

  6924                                const bool aCanStoreInRuleTree)

  6925 {

  6926   COMPUTE_START_RESET(Outline, (mPresContext), outline, parentOutline)

  6928   // outline-width: length, enum, inherit

  6929   const nsCSSValue* outlineWidthValue = aRuleData->ValueForOutlineWidth();

  6930   if (eCSSUnit_Initial == outlineWidthValue->GetUnit() ||

  6931       eCSSUnit_Unset == outlineWidthValue->GetUnit()) {

  6932     outline->mOutlineWidth =

  6933       nsStyleCoord(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated);

  6934   }

  6935   else {

  6936     SetCoord(*outlineWidthValue, outline->mOutlineWidth,

  6937              parentOutline->mOutlineWidth,

  6938              SETCOORD_LEH | SETCOORD_CALC_LENGTH_ONLY, aContext,

  6939              mPresContext, canStoreInRuleTree);

  6940   }

  6942   // outline-offset: length, inherit

  6943   nsStyleCoord tempCoord;

  6944   const nsCSSValue* outlineOffsetValue = aRuleData->ValueForOutlineOffset();

  6945   if (SetCoord(*outlineOffsetValue, tempCoord,

  6946                nsStyleCoord(parentOutline->mOutlineOffset,

  6947                             nsStyleCoord::CoordConstructor),

  6948                SETCOORD_LH | SETCOORD_INITIAL_ZERO | SETCOORD_CALC_LENGTH_ONLY |

  6949                  SETCOORD_UNSET_INITIAL,

  6950                aContext, mPresContext, canStoreInRuleTree)) {

  6951     outline->mOutlineOffset = tempCoord.GetCoordValue();

  6952   } else {

  6953     NS_ASSERTION(outlineOffsetValue->GetUnit() == eCSSUnit_Null,

  6954                  "unexpected unit");

  6955   }

  6957   // outline-color: color, string, enum, inherit

  6958   nscolor outlineColor;

  6959   nscolor unused = NS_RGB(0,0,0);

  6960   const nsCSSValue* outlineColorValue = aRuleData->ValueForOutlineColor();

  6961   if (eCSSUnit_Inherit == outlineColorValue->GetUnit()) {

  6962     canStoreInRuleTree = false;

  6963     if (parentContext) {

  6964       if (parentOutline->GetOutlineColor(outlineColor))

  6965         outline->SetOutlineColor(outlineColor);

  6966       else {

  6967         // We want to inherit the color from the parent, not use the

  6968         // color on the element where this chunk of style data will be

  6969         // used.  We can ensure that the data for the parent are fully

  6970         // computed (unlike for the element where this will be used, for

  6971         // which the color could be specified on a more specific rule).

  6972         outline->SetOutlineColor(parentContext->StyleColor()->mColor);

  6973       }

  6974     } else {

  6975       outline->SetOutlineInitialColor();

  6976     }

  6977   }

  6978   else if (SetColor(*outlineColorValue, unused, mPresContext,

  6979                     aContext, outlineColor, canStoreInRuleTree))

  6980     outline->SetOutlineColor(outlineColor);

  6981   else if (eCSSUnit_Enumerated == outlineColorValue->GetUnit() ||

  6982            eCSSUnit_Initial == outlineColorValue->GetUnit() ||

  6983            eCSSUnit_Unset == outlineColorValue->GetUnit()) {

  6984     outline->SetOutlineInitialColor();

  6985   }

  6987   // -moz-outline-radius: length, percent, inherit

  6988   {

  6989     const nsCSSProperty* subprops =

  6990       nsCSSProps::SubpropertyEntryFor(eCSSProperty__moz_outline_radius);

  6991     NS_FOR_CSS_FULL_CORNERS(corner) {

  6992       int cx = NS_FULL_TO_HALF_CORNER(corner, false);

  6993       int cy = NS_FULL_TO_HALF_CORNER(corner, true);

  6994       const nsCSSValue& radius = *aRuleData->ValueFor(subprops[corner]);

  6995       nsStyleCoord parentX = parentOutline->mOutlineRadius.Get(cx);

  6996       nsStyleCoord parentY = parentOutline->mOutlineRadius.Get(cy);

  6997       nsStyleCoord coordX, coordY;

  6999       if (SetPairCoords(radius, coordX, coordY, parentX, parentY,

  7000                         SETCOORD_LPH | SETCOORD_INITIAL_ZERO |

  7001                           SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL,

  7002                         aContext, mPresContext, canStoreInRuleTree)) {

  7003         outline->mOutlineRadius.Set(cx, coordX);

  7004         outline->mOutlineRadius.Set(cy, coordY);

  7005       }

  7006     }

  7007   }

  7009   // outline-style: enum, inherit, initial

  7010   // cannot use SetDiscrete because of SetOutlineStyle

  7011   const nsCSSValue* outlineStyleValue = aRuleData->ValueForOutlineStyle();

  7012   nsCSSUnit unit = outlineStyleValue->GetUnit();

  7013   NS_ABORT_IF_FALSE(eCSSUnit_None != unit && eCSSUnit_Auto != unit,

  7014                     "'none' and 'auto' should be handled as enumerated values");

  7015   if (eCSSUnit_Enumerated == unit) {

  7016     outline->SetOutlineStyle(outlineStyleValue->GetIntValue());

  7017   } else if (eCSSUnit_Initial == unit ||

  7018              eCSSUnit_Unset == unit) {

  7019     outline->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE);

  7020   } else if (eCSSUnit_Inherit == unit) {

  7021     canStoreInRuleTree = false;

  7022     outline->SetOutlineStyle(parentOutline->GetOutlineStyle());

  7023   }

  7025   outline->RecalcData(mPresContext);

  7026   COMPUTE_END_RESET(Outline, outline)

  7027 }

  7029 const void*

  7030 nsRuleNode::ComputeListData(void* aStartStruct,

  7031                             const nsRuleData* aRuleData,

  7032                             nsStyleContext* aContext,

  7033                             nsRuleNode* aHighestNode,

  7034                             const RuleDetail aRuleDetail,

  7035                             const bool aCanStoreInRuleTree)

  7036 {

  7037   COMPUTE_START_INHERITED(List, (), list, parentList)

  7039   // list-style-type: enum, inherit, initial

  7040   SetDiscrete(*aRuleData->ValueForListStyleType(),

  7041               list->mListStyleType, canStoreInRuleTree,

  7042               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  7043               parentList->mListStyleType,

  7044               NS_STYLE_LIST_STYLE_DISC, 0, 0, 0, 0);

  7046   // list-style-image: url, none, inherit

  7047   const nsCSSValue* imageValue = aRuleData->ValueForListStyleImage();

  7048   if (eCSSUnit_Image == imageValue->GetUnit()) {

  7049     NS_SET_IMAGE_REQUEST_WITH_DOC(list->SetListStyleImage,

  7050                                   aContext,

  7051                                   imageValue->GetImageValue)

  7052   }

  7053   else if (eCSSUnit_None == imageValue->GetUnit() ||

  7054            eCSSUnit_Initial == imageValue->GetUnit()) {

  7055     list->SetListStyleImage(nullptr);

  7056   }

  7057   else if (eCSSUnit_Inherit == imageValue->GetUnit() ||

  7058            eCSSUnit_Unset == imageValue->GetUnit()) {

  7059     canStoreInRuleTree = false;

  7060     NS_SET_IMAGE_REQUEST(list->SetListStyleImage,

  7061                          aContext,

  7062                          parentList->GetListStyleImage())

  7063   }

  7065   // list-style-position: enum, inherit, initial

  7066   SetDiscrete(*aRuleData->ValueForListStylePosition(),

  7067               list->mListStylePosition, canStoreInRuleTree,

  7068               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  7069               parentList->mListStylePosition,

  7070               NS_STYLE_LIST_STYLE_POSITION_OUTSIDE, 0, 0, 0, 0);

  7072   // image region property: length, auto, inherit

  7073   const nsCSSValue* imageRegionValue = aRuleData->ValueForImageRegion();

  7074   switch (imageRegionValue->GetUnit()) {

  7075   case eCSSUnit_Inherit:

  7076   case eCSSUnit_Unset:

  7077     canStoreInRuleTree = false;

  7078     list->mImageRegion = parentList->mImageRegion;

  7079     break;

  7081   case eCSSUnit_Initial:

  7082   case eCSSUnit_Auto:

  7083     list->mImageRegion.SetRect(0,0,0,0);

  7084     break;

  7086   case eCSSUnit_Null:

  7087     break;

  7089   case eCSSUnit_Rect: {

  7090     const nsCSSRect& rgnRect = imageRegionValue->GetRectValue();

  7092     if (rgnRect.mTop.GetUnit() == eCSSUnit_Auto)

  7093       list->mImageRegion.y = 0;

  7094     else if (rgnRect.mTop.IsLengthUnit())

  7095       list->mImageRegion.y =

  7096         CalcLength(rgnRect.mTop, aContext, mPresContext, canStoreInRuleTree);

  7098     if (rgnRect.mBottom.GetUnit() == eCSSUnit_Auto)

  7099       list->mImageRegion.height = 0;

  7100     else if (rgnRect.mBottom.IsLengthUnit())

  7101       list->mImageRegion.height =

  7102         CalcLength(rgnRect.mBottom, aContext, mPresContext,

  7103                    canStoreInRuleTree) - list->mImageRegion.y;

  7105     if (rgnRect.mLeft.GetUnit() == eCSSUnit_Auto)

  7106       list->mImageRegion.x = 0;

  7107     else if (rgnRect.mLeft.IsLengthUnit())

  7108       list->mImageRegion.x =

  7109         CalcLength(rgnRect.mLeft, aContext, mPresContext, canStoreInRuleTree);

  7111     if (rgnRect.mRight.GetUnit() == eCSSUnit_Auto)

  7112       list->mImageRegion.width = 0;

  7113     else if (rgnRect.mRight.IsLengthUnit())

  7114       list->mImageRegion.width =

  7115         CalcLength(rgnRect.mRight, aContext, mPresContext,

  7116                    canStoreInRuleTree) - list->mImageRegion.x;

  7117     break;

  7118   }

  7120   default:

  7121     NS_ABORT_IF_FALSE(false, "unrecognized image-region unit");

  7122   }

  7124   COMPUTE_END_INHERITED(List, list)

  7125 }

  7127 static void

  7128 SetGridTrackBreadth(const nsCSSValue& aValue,

  7129                     nsStyleCoord& aResult,

  7130                     nsStyleContext* aStyleContext,

  7131                     nsPresContext* aPresContext,

  7132                     bool& aCanStoreInRuleTree)

  7133 {

  7134   nsCSSUnit unit = aValue.GetUnit();

  7135   if (unit == eCSSUnit_FlexFraction) {

  7136     aResult.SetFlexFractionValue(aValue.GetFloatValue());

  7137   } else {

  7138     MOZ_ASSERT(unit != eCSSUnit_Inherit && unit != eCSSUnit_Unset,

  7139                "Unexpected value that would use dummyParentCoord");

  7140     const nsStyleCoord dummyParentCoord;

  7141     SetCoord(aValue, aResult, dummyParentCoord,

  7142              SETCOORD_LPE | SETCOORD_STORE_CALC,

  7143              aStyleContext, aPresContext, aCanStoreInRuleTree);

  7144   }

  7145 }

  7147 static void

  7148 SetGridTrackSize(const nsCSSValue& aValue,

  7149                  nsStyleCoord& aResultMin,

  7150                  nsStyleCoord& aResultMax,

  7151                  nsStyleContext* aStyleContext,

  7152                  nsPresContext* aPresContext,

  7153                  bool& aCanStoreInRuleTree)

  7154 {

  7155   if (aValue.GetUnit() == eCSSUnit_Function) {

  7156     // A minmax() function.

  7157     nsCSSValue::Array* func = aValue.GetArrayValue();

  7158     NS_ASSERTION(func->Item(0).GetKeywordValue() == eCSSKeyword_minmax,

  7159                  "Expected minmax(), got another function name");

  7160     SetGridTrackBreadth(func->Item(1), aResultMin,

  7161                         aStyleContext, aPresContext, aCanStoreInRuleTree);

  7162     SetGridTrackBreadth(func->Item(2), aResultMax,

  7163                         aStyleContext, aPresContext, aCanStoreInRuleTree);

  7164   } else if (aValue.GetUnit() == eCSSUnit_Auto) {

  7165     // 'auto' computes to 'minmax(min-content, max-content)'

  7166     aResultMin.SetIntValue(NS_STYLE_GRID_TRACK_BREADTH_MIN_CONTENT,

  7167                            eStyleUnit_Enumerated);

  7168     aResultMax.SetIntValue(NS_STYLE_GRID_TRACK_BREADTH_MAX_CONTENT,

  7169                            eStyleUnit_Enumerated);

  7170   } else {

  7171     // A single <track-breadth>,

  7172     // specifies identical min and max sizing functions.

  7173     SetGridTrackBreadth(aValue, aResultMin,

  7174                         aStyleContext, aPresContext, aCanStoreInRuleTree);

  7175     aResultMax = aResultMin;

  7176   }

  7177 }

  7179 static void

  7180 SetGridAutoColumnsRows(const nsCSSValue& aValue,

  7181                        nsStyleCoord& aResultMin,

  7182                        nsStyleCoord& aResultMax,

  7183                        const nsStyleCoord& aParentValueMin,

  7184                        const nsStyleCoord& aParentValueMax,

  7185                        nsStyleContext* aStyleContext,

  7186                        nsPresContext* aPresContext,

  7187                        bool& aCanStoreInRuleTree)

  7189 {

  7190   switch (aValue.GetUnit()) {

  7191   case eCSSUnit_Null:

  7192     break;

  7194   case eCSSUnit_Inherit:

  7195     aCanStoreInRuleTree = false;

  7196     aResultMin = aParentValueMin;

  7197     aResultMax = aParentValueMax;

  7198     break;

  7200   case eCSSUnit_Initial:

  7201   case eCSSUnit_Unset:

  7202     // The initial value is 'auto',

  7203     // which computes to 'minmax(min-content, max-content)'.

  7204     // (Explicitly-specified 'auto' values are handled in SetGridTrackSize.)

  7205     aResultMin.SetIntValue(NS_STYLE_GRID_TRACK_BREADTH_MIN_CONTENT,

  7206                            eStyleUnit_Enumerated);

  7207     aResultMax.SetIntValue(NS_STYLE_GRID_TRACK_BREADTH_MAX_CONTENT,

  7208                            eStyleUnit_Enumerated);

  7209     break;

  7211   default:

  7212     SetGridTrackSize(aValue, aResultMin, aResultMax,

  7213                      aStyleContext, aPresContext, aCanStoreInRuleTree);

  7214   }

  7215 }

  7217 static void

  7218 AppendGridLineNames(const nsCSSValue& aValue,

  7219                     nsStyleGridTemplate& aResult)

  7220 {

  7221   // Compute a <line-names> value

  7222   nsTArray<nsString>* nameList = aResult.mLineNameLists.AppendElement();

  7223   // Null unit means empty list, nothing more to do.

  7224   if (aValue.GetUnit() != eCSSUnit_Null) {

  7225     const nsCSSValueList* item = aValue.GetListValue();

  7226     do {

  7227       nsString* name = nameList->AppendElement();

  7228       item->mValue.GetStringValue(*name);

  7229       item = item->mNext;

  7230     } while (item);

  7231   }

  7232 }

  7234 static void

  7235 SetGridTrackList(const nsCSSValue& aValue,

  7236                  nsStyleGridTemplate& aResult,

  7237                  const nsStyleGridTemplate& aParentValue,

  7238                  nsStyleContext* aStyleContext,

  7239                  nsPresContext* aPresContext,

  7240                  bool& aCanStoreInRuleTree)

  7242 {

  7243   switch (aValue.GetUnit()) {

  7244   case eCSSUnit_Null:

  7245     break;

  7247   case eCSSUnit_Inherit:

  7248     aCanStoreInRuleTree = false;

  7249     aResult.mIsSubgrid = aParentValue.mIsSubgrid;

  7250     aResult.mLineNameLists = aParentValue.mLineNameLists;

  7251     aResult.mMinTrackSizingFunctions = aParentValue.mMinTrackSizingFunctions;

  7252     aResult.mMaxTrackSizingFunctions = aParentValue.mMaxTrackSizingFunctions;

  7253     break;

  7255   case eCSSUnit_Initial:

  7256   case eCSSUnit_Unset:

  7257   case eCSSUnit_None:

  7258     aResult.mIsSubgrid = false;

  7259     aResult.mLineNameLists.Clear();

  7260     aResult.mMinTrackSizingFunctions.Clear();

  7261     aResult.mMaxTrackSizingFunctions.Clear();

  7262     break;

  7264   default:

  7265     aResult.mLineNameLists.Clear();

  7266     aResult.mMinTrackSizingFunctions.Clear();

  7267     aResult.mMaxTrackSizingFunctions.Clear();

  7268     const nsCSSValueList* item = aValue.GetListValue();

  7269     if (item->mValue.GetUnit() == eCSSUnit_Enumerated &&

  7270         item->mValue.GetIntValue() == NS_STYLE_GRID_TEMPLATE_SUBGRID) {

  7271       // subgrid <line-name-list>?

  7272       aResult.mIsSubgrid = true;

  7273       item = item->mNext;

  7274       while (item) {

  7275         AppendGridLineNames(item->mValue, aResult);

  7276         item = item->mNext;

  7277       }

  7278     } else {

  7279       // <track-list>

  7280       // The list is expected to have odd number of items, at least 3

  7281       // starting with a <line-names> (sub list of identifiers),

  7282       // and alternating between that and <track-size>.

  7283       aResult.mIsSubgrid = false;

  7284       for (;;) {

  7285         AppendGridLineNames(item->mValue, aResult);

  7286         item = item->mNext;

  7288         if (!item) {

  7289           break;

  7290         }

  7292         nsStyleCoord& min = *aResult.mMinTrackSizingFunctions.AppendElement();

  7293         nsStyleCoord& max = *aResult.mMaxTrackSizingFunctions.AppendElement();

  7294         SetGridTrackSize(item->mValue, min, max,

  7295                          aStyleContext, aPresContext, aCanStoreInRuleTree);

  7297         item = item->mNext;

  7298         MOZ_ASSERT(item, "Expected a eCSSUnit_List of odd length");

  7299       }

  7300       MOZ_ASSERT(!aResult.mMinTrackSizingFunctions.IsEmpty() &&

  7301                  aResult.mMinTrackSizingFunctions.Length() ==

  7302                  aResult.mMaxTrackSizingFunctions.Length() &&

  7303                  aResult.mMinTrackSizingFunctions.Length() + 1 ==

  7304                  aResult.mLineNameLists.Length(),

  7305                  "Inconstistent array lengths for nsStyleGridTemplate");

  7306     }

  7307   }

  7308 }

  7310 static void

  7311 SetGridTemplateAreas(const nsCSSValue& aValue,

  7312                      nsRefPtr<css::GridTemplateAreasValue>* aResult,

  7313                      css::GridTemplateAreasValue* aParentValue,

  7314                      bool& aCanStoreInRuleTree)

  7315 {

  7316   switch (aValue.GetUnit()) {

  7317   case eCSSUnit_Null:

  7318     break;

  7320   case eCSSUnit_Inherit:

  7321     aCanStoreInRuleTree = false;

  7322     *aResult = aParentValue;

  7323     break;

  7325   case eCSSUnit_Initial:

  7326   case eCSSUnit_Unset:

  7327   case eCSSUnit_None:

  7328     *aResult = nullptr;

  7329     break;

  7331   default:

  7332     *aResult = aValue.GetGridTemplateAreas();

  7333   }

  7334 }

  7336 static void

  7337 SetGridLine(const nsCSSValue& aValue,

  7338             nsStyleGridLine& aResult,

  7339             const nsStyleGridLine& aParentValue,

  7340             bool& aCanStoreInRuleTree)

  7342 {

  7343   switch (aValue.GetUnit()) {

  7344   case eCSSUnit_Null:

  7345     break;

  7347   case eCSSUnit_Inherit:

  7348     aCanStoreInRuleTree = false;

  7349     aResult = aParentValue;

  7350     break;

  7352   case eCSSUnit_Initial:

  7353   case eCSSUnit_Unset:

  7354   case eCSSUnit_Auto:

  7355     aResult.SetAuto();

  7356     break;

  7358   default:

  7359     aResult.SetAuto();  // Reset any existing value.

  7360     const nsCSSValueList* item = aValue.GetListValue();

  7361     do {

  7362       if (item->mValue.GetUnit() == eCSSUnit_Enumerated) {

  7363         aResult.mHasSpan = true;

  7364       } else if (item->mValue.GetUnit() == eCSSUnit_Integer) {

  7365         aResult.mInteger = item->mValue.GetIntValue();

  7366       } else if (item->mValue.GetUnit() == eCSSUnit_Ident) {

  7367         item->mValue.GetStringValue(aResult.mLineName);

  7368       } else {

  7369         NS_ASSERTION(false, "Unexpected unit");

  7370       }

  7371       item = item->mNext;

  7372     } while (item);

  7373     MOZ_ASSERT(!aResult.IsAuto(),

  7374                "should have set something away from default value");

  7375   }

  7376 }

  7378 const void*

  7379 nsRuleNode::ComputePositionData(void* aStartStruct,

  7380                                 const nsRuleData* aRuleData,

  7381                                 nsStyleContext* aContext,

  7382                                 nsRuleNode* aHighestNode,

  7383                                 const RuleDetail aRuleDetail,

  7384                                 const bool aCanStoreInRuleTree)

  7385 {

  7386   COMPUTE_START_RESET(Position, (), pos, parentPos)

  7388   // box offsets: length, percent, calc, auto, inherit

  7389   static const nsCSSProperty offsetProps[] = {

  7390     eCSSProperty_top,

  7391     eCSSProperty_right,

  7392     eCSSProperty_bottom,

  7393     eCSSProperty_left

  7394   };

  7395   nsStyleCoord  coord;

  7396   NS_FOR_CSS_SIDES(side) {

  7397     nsStyleCoord parentCoord = parentPos->mOffset.Get(side);

  7398     if (SetCoord(*aRuleData->ValueFor(offsetProps[side]),

  7399                  coord, parentCoord,

  7400                  SETCOORD_LPAH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC |

  7401                    SETCOORD_UNSET_INITIAL,

  7402                  aContext, mPresContext, canStoreInRuleTree)) {

  7403       pos->mOffset.Set(side, coord);

  7404     }

  7405   }

  7407   SetCoord(*aRuleData->ValueForWidth(), pos->mWidth, parentPos->mWidth,

  7408            SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC |

  7409              SETCOORD_UNSET_INITIAL,

  7410            aContext, mPresContext, canStoreInRuleTree);

  7411   SetCoord(*aRuleData->ValueForMinWidth(), pos->mMinWidth, parentPos->mMinWidth,

  7412            SETCOORD_LPEH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |

  7413              SETCOORD_UNSET_INITIAL,

  7414            aContext, mPresContext, canStoreInRuleTree);

  7415   SetCoord(*aRuleData->ValueForMaxWidth(), pos->mMaxWidth, parentPos->mMaxWidth,

  7416            SETCOORD_LPOEH | SETCOORD_INITIAL_NONE | SETCOORD_STORE_CALC |

  7417              SETCOORD_UNSET_INITIAL,

  7418            aContext, mPresContext, canStoreInRuleTree);

  7420   SetCoord(*aRuleData->ValueForHeight(), pos->mHeight, parentPos->mHeight,

  7421            SETCOORD_LPAH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC |

  7422              SETCOORD_UNSET_INITIAL,

  7423            aContext, mPresContext, canStoreInRuleTree);

  7424   SetCoord(*aRuleData->ValueForMinHeight(), pos->mMinHeight, parentPos->mMinHeight,

  7425            SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |

  7426              SETCOORD_UNSET_INITIAL,

  7427            aContext, mPresContext, canStoreInRuleTree);

  7428   SetCoord(*aRuleData->ValueForMaxHeight(), pos->mMaxHeight, parentPos->mMaxHeight,

  7429            SETCOORD_LPOH | SETCOORD_INITIAL_NONE | SETCOORD_STORE_CALC |

  7430              SETCOORD_UNSET_INITIAL,

  7431            aContext, mPresContext, canStoreInRuleTree);

  7433   // box-sizing: enum, inherit, initial

  7434   SetDiscrete(*aRuleData->ValueForBoxSizing(),

  7435               pos->mBoxSizing, canStoreInRuleTree,

  7436               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7437               parentPos->mBoxSizing,

  7438               NS_STYLE_BOX_SIZING_CONTENT, 0, 0, 0, 0);

  7440   // align-content: enum, inherit, initial

  7441   SetDiscrete(*aRuleData->ValueForAlignContent(),

  7442               pos->mAlignContent, canStoreInRuleTree,

  7443               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7444               parentPos->mAlignContent,

  7445               NS_STYLE_ALIGN_CONTENT_STRETCH, 0, 0, 0, 0);

  7447   // align-items: enum, inherit, initial

  7448   SetDiscrete(*aRuleData->ValueForAlignItems(),

  7449               pos->mAlignItems, canStoreInRuleTree,

  7450               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7451               parentPos->mAlignItems,

  7452               NS_STYLE_ALIGN_ITEMS_INITIAL_VALUE, 0, 0, 0, 0);

  7454   // align-self: enum, inherit, initial

  7455   // NOTE: align-self's initial value is the special keyword "auto", which is

  7456   // supposed to compute to our parent's computed value of "align-items".  So

  7457   // technically, "auto" itself is never a valid computed value for align-self,

  7458   // since it always computes to something else.  Despite that, we do actually

  7459   // store "auto" in nsStylePosition::mAlignSelf, as NS_STYLE_ALIGN_SELF_AUTO

  7460   // (and then resolve it as-necessary).  We do this because "auto" is the

  7461   // initial value for this property, so if we were to actually resolve it in

  7462   // nsStylePosition, we'd never be able to share any nsStylePosition structs

  7463   // in the rule tree, since their mAlignSelf values would depend on the parent

  7464   // style, by default.

  7465   if (aRuleData->ValueForAlignSelf()->GetUnit() == eCSSUnit_Inherit) {

  7466     // Special handling for "align-self: inherit", in case we're inheriting

  7467     // "align-self: auto", in which case we need to resolve the parent's "auto"

  7468     // and inherit that resolved value.

  7469     uint8_t inheritedAlignSelf = parentPos->mAlignSelf;

  7470     if (inheritedAlignSelf == NS_STYLE_ALIGN_SELF_AUTO) {

  7471       if (!parentContext) {

  7472         // We're the root node. Nothing to inherit from --> just use default

  7473         // value.

  7474         inheritedAlignSelf = NS_STYLE_ALIGN_ITEMS_INITIAL_VALUE;

  7475       } else {

  7476         // Our parent's "auto" value should resolve to our grandparent's value

  7477         // for "align-items".  So, that's what we're supposed to inherit.

  7478         nsStyleContext* grandparentContext = parentContext->GetParent();

  7479         if (!grandparentContext) {

  7480           // No grandparent --> our parent is the root node, so its

  7481           // "align-self: auto" computes to the default "align-items" value:

  7482           inheritedAlignSelf = NS_STYLE_ALIGN_ITEMS_INITIAL_VALUE;

  7483         } else {

  7484           // Normal case -- we have a grandparent.

  7485           // Its "align-items" value is what we should end up inheriting.

  7486           const nsStylePosition* grandparentPos =

  7487             grandparentContext->StylePosition();

  7488           inheritedAlignSelf = grandparentPos->mAlignItems;

  7489         }

  7490       }

  7491     }

  7493     pos->mAlignSelf = inheritedAlignSelf;

  7494     canStoreInRuleTree = false;

  7495   } else {

  7496     SetDiscrete(*aRuleData->ValueForAlignSelf(),

  7497                 pos->mAlignSelf, canStoreInRuleTree,

  7498                 SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7499                 parentPos->mAlignSelf, // (unused -- we handled inherit above)

  7500                 NS_STYLE_ALIGN_SELF_AUTO, // initial == auto

  7501                 0, 0, 0, 0);

  7502   }

  7504   // flex-basis: auto, length, percent, enum, calc, inherit, initial

  7505   // (Note: The flags here should match those used for 'width' property above.)

  7506   SetCoord(*aRuleData->ValueForFlexBasis(), pos->mFlexBasis, parentPos->mFlexBasis,

  7507            SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC |

  7508              SETCOORD_UNSET_INITIAL,

  7509            aContext, mPresContext, canStoreInRuleTree);

  7511   // flex-direction: enum, inherit, initial

  7512   SetDiscrete(*aRuleData->ValueForFlexDirection(),

  7513               pos->mFlexDirection, canStoreInRuleTree,

  7514               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7515               parentPos->mFlexDirection,

  7516               NS_STYLE_FLEX_DIRECTION_ROW, 0, 0, 0, 0);

  7518   // flex-grow: float, inherit, initial

  7519   SetFactor(*aRuleData->ValueForFlexGrow(),

  7520             pos->mFlexGrow, canStoreInRuleTree,

  7521             parentPos->mFlexGrow, 0.0f,

  7522             SETFCT_UNSET_INITIAL);

  7524   // flex-shrink: float, inherit, initial

  7525   SetFactor(*aRuleData->ValueForFlexShrink(),

  7526             pos->mFlexShrink, canStoreInRuleTree,

  7527             parentPos->mFlexShrink, 1.0f,

  7528             SETFCT_UNSET_INITIAL);

  7530   // flex-wrap: enum, inherit, initial

  7531   SetDiscrete(*aRuleData->ValueForFlexWrap(),

  7532               pos->mFlexWrap, canStoreInRuleTree,

  7533               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7534               parentPos->mFlexWrap,

  7535               NS_STYLE_FLEX_WRAP_NOWRAP, 0, 0, 0, 0);

  7537   // order: integer, inherit, initial

  7538   SetDiscrete(*aRuleData->ValueForOrder(),

  7539               pos->mOrder, canStoreInRuleTree,

  7540               SETDSC_INTEGER | SETDSC_UNSET_INITIAL,

  7541               parentPos->mOrder,

  7542               NS_STYLE_ORDER_INITIAL, 0, 0, 0, 0);

  7544   // justify-content: enum, inherit, initial

  7545   SetDiscrete(*aRuleData->ValueForJustifyContent(),

  7546               pos->mJustifyContent, canStoreInRuleTree,

  7547               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7548               parentPos->mJustifyContent,

  7549               NS_STYLE_JUSTIFY_CONTENT_FLEX_START, 0, 0, 0, 0);

  7551   // grid-auto-flow

  7552   const nsCSSValue& gridAutoFlow = *aRuleData->ValueForGridAutoFlow();

  7553   switch (gridAutoFlow.GetUnit()) {

  7554     case eCSSUnit_Null:

  7555       break;

  7556     case eCSSUnit_Inherit:

  7557       canStoreInRuleTree = false;

  7558       pos->mGridAutoFlow = parentPos->mGridAutoFlow;

  7559       break;

  7560     case eCSSUnit_Initial:

  7561     case eCSSUnit_Unset:

  7562       pos->mGridAutoFlow = NS_STYLE_GRID_AUTO_FLOW_NONE;

  7563       break;

  7564     default:

  7565       NS_ASSERTION(gridAutoFlow.GetUnit() == eCSSUnit_Enumerated,

  7566                    "Unexpected unit");

  7567       pos->mGridAutoFlow = gridAutoFlow.GetIntValue();

  7568   }

  7570   // grid-auto-columns

  7571   SetGridAutoColumnsRows(*aRuleData->ValueForGridAutoColumns(),

  7572                          pos->mGridAutoColumnsMin,

  7573                          pos->mGridAutoColumnsMax,

  7574                          parentPos->mGridAutoColumnsMin,

  7575                          parentPos->mGridAutoColumnsMax,

  7576                          aContext, mPresContext, canStoreInRuleTree);

  7578   // grid-auto-rows

  7579   SetGridAutoColumnsRows(*aRuleData->ValueForGridAutoRows(),

  7580                          pos->mGridAutoRowsMin,

  7581                          pos->mGridAutoRowsMax,

  7582                          parentPos->mGridAutoRowsMin,

  7583                          parentPos->mGridAutoRowsMax,

  7584                          aContext, mPresContext, canStoreInRuleTree);

  7586   // grid-template-columns

  7587   SetGridTrackList(*aRuleData->ValueForGridTemplateColumns(),

  7588                    pos->mGridTemplateColumns, parentPos->mGridTemplateColumns,

  7589                    aContext, mPresContext, canStoreInRuleTree);

  7591   // grid-template-rows

  7592   SetGridTrackList(*aRuleData->ValueForGridTemplateRows(),

  7593                    pos->mGridTemplateRows, parentPos->mGridTemplateRows,

  7594                    aContext, mPresContext, canStoreInRuleTree);

  7596   // grid-tempate-areas

  7597   SetGridTemplateAreas(*aRuleData->ValueForGridTemplateAreas(),

  7598                        &pos->mGridTemplateAreas,

  7599                        parentPos->mGridTemplateAreas,

  7600                        canStoreInRuleTree);

  7602   // grid-auto-position

  7603   const nsCSSValue& gridAutoPosition = *aRuleData->ValueForGridAutoPosition();

  7604   switch (gridAutoPosition.GetUnit()) {

  7605     case eCSSUnit_Null:

  7606       break;

  7607     case eCSSUnit_Inherit:

  7608       canStoreInRuleTree = false;

  7609       pos->mGridAutoPositionColumn = parentPos->mGridAutoPositionColumn;

  7610       pos->mGridAutoPositionRow = parentPos->mGridAutoPositionRow;

  7611       break;

  7612     case eCSSUnit_Initial:

  7613     case eCSSUnit_Unset:

  7614       // '1 / 1'

  7615       pos->mGridAutoPositionColumn.SetToInteger(1);

  7616       pos->mGridAutoPositionRow.SetToInteger(1);

  7617       break;

  7618     default:

  7619       SetGridLine(gridAutoPosition.GetPairValue().mXValue,

  7620                   pos->mGridAutoPositionColumn,

  7621                   parentPos->mGridAutoPositionColumn,

  7622                   canStoreInRuleTree);

  7623       SetGridLine(gridAutoPosition.GetPairValue().mYValue,

  7624                   pos->mGridAutoPositionRow,

  7625                   parentPos->mGridAutoPositionRow,

  7626                   canStoreInRuleTree);

  7627   }

  7629   // grid-column-start

  7630   SetGridLine(*aRuleData->ValueForGridColumnStart(),

  7631               pos->mGridColumnStart,

  7632               parentPos->mGridColumnStart,

  7633               canStoreInRuleTree);

  7635   // grid-column-end

  7636   SetGridLine(*aRuleData->ValueForGridColumnEnd(),

  7637               pos->mGridColumnEnd,

  7638               parentPos->mGridColumnEnd,

  7639               canStoreInRuleTree);

  7641   // grid-row-start

  7642   SetGridLine(*aRuleData->ValueForGridRowStart(),

  7643               pos->mGridRowStart,

  7644               parentPos->mGridRowStart,

  7645               canStoreInRuleTree);

  7647   // grid-row-end

  7648   SetGridLine(*aRuleData->ValueForGridRowEnd(),

  7649               pos->mGridRowEnd,

  7650               parentPos->mGridRowEnd,

  7651               canStoreInRuleTree);

  7653   // z-index

  7654   const nsCSSValue* zIndexValue = aRuleData->ValueForZIndex();

  7655   if (! SetCoord(*zIndexValue, pos->mZIndex, parentPos->mZIndex,

  7656                  SETCOORD_IA | SETCOORD_INITIAL_AUTO | SETCOORD_UNSET_INITIAL,

  7657                  aContext, nullptr, canStoreInRuleTree)) {

  7658     if (eCSSUnit_Inherit == zIndexValue->GetUnit()) {

  7659       // handle inherit, because it's ok to inherit 'auto' here

  7660       canStoreInRuleTree = false;

  7661       pos->mZIndex = parentPos->mZIndex;

  7662     }

  7663   }

  7665   COMPUTE_END_RESET(Position, pos)

  7666 }

  7668 const void*

  7669 nsRuleNode::ComputeTableData(void* aStartStruct,

  7670                              const nsRuleData* aRuleData,

  7671                              nsStyleContext* aContext,

  7672                              nsRuleNode* aHighestNode,

  7673                              const RuleDetail aRuleDetail,

  7674                              const bool aCanStoreInRuleTree)

  7675 {

  7676   COMPUTE_START_RESET(Table, (), table, parentTable)

  7678   // table-layout: enum, inherit, initial

  7679   SetDiscrete(*aRuleData->ValueForTableLayout(),

  7680               table->mLayoutStrategy, canStoreInRuleTree,

  7681               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  7682               parentTable->mLayoutStrategy,

  7683               NS_STYLE_TABLE_LAYOUT_AUTO, 0, 0, 0, 0);

  7685   // span: pixels (not a real CSS prop)

  7686   const nsCSSValue* spanValue = aRuleData->ValueForSpan();

  7687   if (eCSSUnit_Enumerated == spanValue->GetUnit() ||

  7688       eCSSUnit_Integer == spanValue->GetUnit())

  7689     table->mSpan = spanValue->GetIntValue();

  7691   COMPUTE_END_RESET(Table, table)

  7692 }

  7694 const void*

  7695 nsRuleNode::ComputeTableBorderData(void* aStartStruct,

  7696                                    const nsRuleData* aRuleData,

  7697                                    nsStyleContext* aContext,

  7698                                    nsRuleNode* aHighestNode,

  7699                                    const RuleDetail aRuleDetail,

  7700                                    const bool aCanStoreInRuleTree)

  7701 {

  7702   COMPUTE_START_INHERITED(TableBorder, (mPresContext), table, parentTable)

  7704   // border-collapse: enum, inherit, initial

  7705   SetDiscrete(*aRuleData->ValueForBorderCollapse(), table->mBorderCollapse,

  7706               canStoreInRuleTree,

  7707               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  7708               parentTable->mBorderCollapse,

  7709               NS_STYLE_BORDER_SEPARATE, 0, 0, 0, 0);

  7711   const nsCSSValue* borderSpacingValue = aRuleData->ValueForBorderSpacing();

  7712   if (borderSpacingValue->GetUnit() != eCSSUnit_Null) {

  7713     // border-spacing-x/y: length, inherit

  7714     nsStyleCoord parentX(parentTable->mBorderSpacingX,

  7715                          nsStyleCoord::CoordConstructor);

  7716     nsStyleCoord parentY(parentTable->mBorderSpacingY,

  7717                          nsStyleCoord::CoordConstructor);

  7718     nsStyleCoord coordX, coordY;

  7720 #ifdef DEBUG

  7721     bool result =

  7722 #endif

  7723       SetPairCoords(*borderSpacingValue,

  7724                     coordX, coordY, parentX, parentY,

  7725                     SETCOORD_LH | SETCOORD_INITIAL_ZERO |

  7726                       SETCOORD_CALC_LENGTH_ONLY |

  7727                       SETCOORD_CALC_CLAMP_NONNEGATIVE | SETCOORD_UNSET_INHERIT,

  7728                     aContext, mPresContext, canStoreInRuleTree);

  7729     NS_ASSERTION(result, "malformed table border value");

  7730     table->mBorderSpacingX = coordX.GetCoordValue();

  7731     table->mBorderSpacingY = coordY.GetCoordValue();

  7732   }

  7734   // caption-side: enum, inherit, initial

  7735   SetDiscrete(*aRuleData->ValueForCaptionSide(),

  7736               table->mCaptionSide, canStoreInRuleTree,

  7737               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  7738               parentTable->mCaptionSide,

  7739               NS_STYLE_CAPTION_SIDE_TOP, 0, 0, 0, 0);

  7741   // empty-cells: enum, inherit, initial

  7742   SetDiscrete(*aRuleData->ValueForEmptyCells(),

  7743               table->mEmptyCells, canStoreInRuleTree,

  7744               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  7745               parentTable->mEmptyCells,

  7746               (mPresContext->CompatibilityMode() == eCompatibility_NavQuirks)

  7747               ? NS_STYLE_TABLE_EMPTY_CELLS_SHOW_BACKGROUND

  7748               : NS_STYLE_TABLE_EMPTY_CELLS_SHOW,

  7749               0, 0, 0, 0);

  7751   COMPUTE_END_INHERITED(TableBorder, table)

  7752 }

  7754 const void*

  7755 nsRuleNode::ComputeContentData(void* aStartStruct,

  7756                                const nsRuleData* aRuleData,

  7757                                nsStyleContext* aContext,

  7758                                nsRuleNode* aHighestNode,

  7759                                const RuleDetail aRuleDetail,

  7760                                const bool aCanStoreInRuleTree)

  7761 {

  7762   uint32_t count;

  7763   nsAutoString buffer;

  7765   COMPUTE_START_RESET(Content, (), content, parentContent)

  7767   // content: [string, url, counter, attr, enum]+, normal, none, inherit

  7768   const nsCSSValue* contentValue = aRuleData->ValueForContent();

  7769   switch (contentValue->GetUnit()) {

  7770   case eCSSUnit_Null:

  7771     break;

  7773   case eCSSUnit_Normal:

  7774   case eCSSUnit_None:

  7775   case eCSSUnit_Initial:

  7776   case eCSSUnit_Unset:

  7777     // "normal", "none", "initial" and "unset" all mean no content

  7778     content->AllocateContents(0);

  7779     break;

  7781   case eCSSUnit_Inherit:

  7782     canStoreInRuleTree = false;

  7783     count = parentContent->ContentCount();

  7784     if (NS_SUCCEEDED(content->AllocateContents(count))) {

  7785       while (0 < count--) {

  7786         content->ContentAt(count) = parentContent->ContentAt(count);

  7787       }

  7788     }

  7789     break;

  7791   case eCSSUnit_Enumerated: {

  7792     NS_ABORT_IF_FALSE(contentValue->GetIntValue() ==

  7793                       NS_STYLE_CONTENT_ALT_CONTENT,

  7794                       "unrecognized solitary content keyword");

  7795     content->AllocateContents(1);

  7796     nsStyleContentData& data = content->ContentAt(0);

  7797     data.mType = eStyleContentType_AltContent;

  7798     data.mContent.mString = nullptr;

  7799     break;

  7800   }

  7802   case eCSSUnit_List:

  7803   case eCSSUnit_ListDep: {

  7804     const nsCSSValueList* contentValueList = contentValue->GetListValue();

  7805       count = 0;

  7806       while (contentValueList) {

  7807         count++;

  7808         contentValueList = contentValueList->mNext;

  7809       }

  7810       if (NS_SUCCEEDED(content->AllocateContents(count))) {

  7811         const nsAutoString  nullStr;

  7812         count = 0;

  7813         contentValueList = contentValue->GetListValue();

  7814         while (contentValueList) {

  7815           const nsCSSValue& value = contentValueList->mValue;

  7816           nsCSSUnit unit = value.GetUnit();

  7817           nsStyleContentType type;

  7818           nsStyleContentData &data = content->ContentAt(count++);

  7819           switch (unit) {

  7820           case eCSSUnit_String:   type = eStyleContentType_String;    break;

  7821           case eCSSUnit_Image:    type = eStyleContentType_Image;     break;

  7822           case eCSSUnit_Attr:     type = eStyleContentType_Attr;      break;

  7823           case eCSSUnit_Counter:  type = eStyleContentType_Counter;   break;

  7824           case eCSSUnit_Counters: type = eStyleContentType_Counters;  break;

  7825           case eCSSUnit_Enumerated:

  7826             switch (value.GetIntValue()) {

  7827             case NS_STYLE_CONTENT_OPEN_QUOTE:

  7828               type = eStyleContentType_OpenQuote;     break;

  7829             case NS_STYLE_CONTENT_CLOSE_QUOTE:

  7830               type = eStyleContentType_CloseQuote;    break;

  7831             case NS_STYLE_CONTENT_NO_OPEN_QUOTE:

  7832               type = eStyleContentType_NoOpenQuote;   break;

  7833             case NS_STYLE_CONTENT_NO_CLOSE_QUOTE:

  7834               type = eStyleContentType_NoCloseQuote;  break;

  7835             default:

  7836               NS_ERROR("bad content value");

  7837               type = eStyleContentType_Uninitialized;

  7838             }

  7839             break;

  7840           default:

  7841             NS_ERROR("bad content type");

  7842             type = eStyleContentType_Uninitialized;

  7843           }

  7844           data.mType = type;

  7845           if (type == eStyleContentType_Image) {

  7846             NS_SET_IMAGE_REQUEST_WITH_DOC(data.SetImage,

  7847                                           aContext,

  7848                                           value.GetImageValue);

  7849           }

  7850           else if (type <= eStyleContentType_Attr) {

  7851             value.GetStringValue(buffer);

  7852             data.mContent.mString = NS_strdup(buffer.get());

  7853           }

  7854           else if (type <= eStyleContentType_Counters) {

  7855             data.mContent.mCounters = value.GetArrayValue();

  7856             data.mContent.mCounters->AddRef();

  7857           }

  7858           else {

  7859             data.mContent.mString = nullptr;

  7860           }

  7861           contentValueList = contentValueList->mNext;

  7862         }

  7863       }

  7864       break;

  7865   }

  7867   default:

  7868     NS_ABORT_IF_FALSE(false,

  7869                       nsPrintfCString("unrecognized content unit %d",

  7870                                       contentValue->GetUnit()).get());

  7871   }

  7873   // counter-increment: [string [int]]+, none, inherit

  7874   const nsCSSValue* counterIncrementValue =

  7875     aRuleData->ValueForCounterIncrement();

  7876   switch (counterIncrementValue->GetUnit()) {

  7877   case eCSSUnit_Null:

  7878     break;

  7880   case eCSSUnit_None:

  7881   case eCSSUnit_Initial:

  7882   case eCSSUnit_Unset:

  7883     content->AllocateCounterIncrements(0);

  7884     break;

  7886   case eCSSUnit_Inherit:

  7887     canStoreInRuleTree = false;

  7888     count = parentContent->CounterIncrementCount();

  7889     if (NS_SUCCEEDED(content->AllocateCounterIncrements(count))) {

  7890       while (0 < count--) {

  7891         const nsStyleCounterData *data =

  7892           parentContent->GetCounterIncrementAt(count);

  7893         content->SetCounterIncrementAt(count, data->mCounter, data->mValue);

  7894       }

  7895     }

  7896     break;

  7898   case eCSSUnit_PairList:

  7899   case eCSSUnit_PairListDep: {

  7900     const nsCSSValuePairList* ourIncrement =

  7901       counterIncrementValue->GetPairListValue();

  7902     NS_ABORT_IF_FALSE(ourIncrement->mXValue.GetUnit() == eCSSUnit_Ident,

  7903                       "unexpected value unit");

  7904     count = ListLength(ourIncrement);

  7905     if (NS_FAILED(content->AllocateCounterIncrements(count))) {

  7906       break;

  7907     }

  7909     count = 0;

  7910     for (const nsCSSValuePairList* p = ourIncrement; p; p = p->mNext, count++) {

  7911       int32_t increment;

  7912       if (p->mYValue.GetUnit() == eCSSUnit_Integer) {

  7913         increment = p->mYValue.GetIntValue();

  7914       } else {

  7915         increment = 1;

  7916       }

  7917       p->mXValue.GetStringValue(buffer);

  7918       content->SetCounterIncrementAt(count, buffer, increment);

  7919     }

  7920     break;

  7921   }

  7923   default:

  7924     NS_ABORT_IF_FALSE(false, "unexpected value unit");

  7925   }

  7927   // counter-reset: [string [int]]+, none, inherit

  7928   const nsCSSValue* counterResetValue = aRuleData->ValueForCounterReset();

  7929   switch (counterResetValue->GetUnit()) {

  7930   case eCSSUnit_Null:

  7931     break;

  7933   case eCSSUnit_None:

  7934   case eCSSUnit_Initial:

  7935   case eCSSUnit_Unset:

  7936     content->AllocateCounterResets(0);

  7937     break;

  7939   case eCSSUnit_Inherit:

  7940     canStoreInRuleTree = false;

  7941     count = parentContent->CounterResetCount();

  7942     if (NS_SUCCEEDED(content->AllocateCounterResets(count))) {

  7943       while (0 < count--) {

  7944         const nsStyleCounterData *data =

  7945           parentContent->GetCounterResetAt(count);

  7946         content->SetCounterResetAt(count, data->mCounter, data->mValue);

  7947       }

  7948     }

  7949     break;

  7951   case eCSSUnit_PairList:

  7952   case eCSSUnit_PairListDep: {

  7953     const nsCSSValuePairList* ourReset =

  7954       counterResetValue->GetPairListValue();

  7955     NS_ABORT_IF_FALSE(ourReset->mXValue.GetUnit() == eCSSUnit_Ident,

  7956                       "unexpected value unit");

  7957     count = ListLength(ourReset);

  7958     if (NS_FAILED(content->AllocateCounterResets(count))) {

  7959       break;

  7960     }

  7962     count = 0;

  7963     for (const nsCSSValuePairList* p = ourReset; p; p = p->mNext, count++) {

  7964       int32_t reset;

  7965       if (p->mYValue.GetUnit() == eCSSUnit_Integer) {

  7966         reset = p->mYValue.GetIntValue();

  7967       } else {

  7968         reset = 0;

  7969       }

  7970       p->mXValue.GetStringValue(buffer);

  7971       content->SetCounterResetAt(count, buffer, reset);

  7972     }

  7973     break;

  7974   }

  7976   default:

  7977     NS_ABORT_IF_FALSE(false, "unexpected value unit");

  7978   }

  7980   // marker-offset: length, auto, inherit

  7981   SetCoord(*aRuleData->ValueForMarkerOffset(), content->mMarkerOffset, parentContent->mMarkerOffset,

  7982            SETCOORD_LH | SETCOORD_AUTO | SETCOORD_INITIAL_AUTO |

  7983              SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INITIAL,

  7984            aContext, mPresContext, canStoreInRuleTree);

  7986   // If we ended up with an image, track it.

  7987   for (uint32_t i = 0; i < content->ContentCount(); ++i) {

  7988     if ((content->ContentAt(i).mType == eStyleContentType_Image) &&

  7989         content->ContentAt(i).mContent.mImage) {

  7990       content->ContentAt(i).TrackImage(aContext->PresContext());

  7991     }

  7992   }

  7994   COMPUTE_END_RESET(Content, content)

  7995 }

  7997 const void*

  7998 nsRuleNode::ComputeQuotesData(void* aStartStruct,

  7999                               const nsRuleData* aRuleData,

  8000                               nsStyleContext* aContext,

  8001                               nsRuleNode* aHighestNode,

  8002                               const RuleDetail aRuleDetail,

  8003                               const bool aCanStoreInRuleTree)

  8004 {

  8005   COMPUTE_START_INHERITED(Quotes, (), quotes, parentQuotes)

  8007   // quotes: inherit, initial, none, [string string]+

  8008   const nsCSSValue* quotesValue = aRuleData->ValueForQuotes();

  8009   switch (quotesValue->GetUnit()) {

  8010   case eCSSUnit_Null:

  8011     break;

  8012   case eCSSUnit_Inherit:

  8013   case eCSSUnit_Unset:

  8014     canStoreInRuleTree = false;

  8015     quotes->CopyFrom(*parentQuotes);

  8016     break;

  8017   case eCSSUnit_Initial:

  8018     quotes->SetInitial();

  8019     break;

  8020   case eCSSUnit_None:

  8021     quotes->AllocateQuotes(0);

  8022     break;

  8023   case eCSSUnit_PairList:

  8024   case eCSSUnit_PairListDep: {

  8025     const nsCSSValuePairList* ourQuotes

  8026       = quotesValue->GetPairListValue();

  8027     nsAutoString buffer;

  8028     nsAutoString closeBuffer;

  8029     uint32_t count = ListLength(ourQuotes);

  8030     if (NS_FAILED(quotes->AllocateQuotes(count))) {

  8031       break;

  8032     }

  8033     count = 0;

  8034     while (ourQuotes) {

  8035       NS_ABORT_IF_FALSE(ourQuotes->mXValue.GetUnit() == eCSSUnit_String &&

  8036                         ourQuotes->mYValue.GetUnit() == eCSSUnit_String,

  8037                         "improper list contents for quotes");

  8038       ourQuotes->mXValue.GetStringValue(buffer);

  8039       ourQuotes->mYValue.GetStringValue(closeBuffer);

  8040       quotes->SetQuotesAt(count++, buffer, closeBuffer);

  8041       ourQuotes = ourQuotes->mNext;

  8042     }

  8043     break;

  8044   }

  8045   default:

  8046     NS_ABORT_IF_FALSE(false, "unexpected value unit");

  8047   }

  8049   COMPUTE_END_INHERITED(Quotes, quotes)

  8050 }

  8052 const void*

  8053 nsRuleNode::ComputeXULData(void* aStartStruct,

  8054                            const nsRuleData* aRuleData,

  8055                            nsStyleContext* aContext,

  8056                            nsRuleNode* aHighestNode,

  8057                            const RuleDetail aRuleDetail,

  8058                            const bool aCanStoreInRuleTree)

  8059 {

  8060   COMPUTE_START_RESET(XUL, (), xul, parentXUL)

  8062   // box-align: enum, inherit, initial

  8063   SetDiscrete(*aRuleData->ValueForBoxAlign(),

  8064               xul->mBoxAlign, canStoreInRuleTree,

  8065               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8066               parentXUL->mBoxAlign,

  8067               NS_STYLE_BOX_ALIGN_STRETCH, 0, 0, 0, 0);

  8069   // box-direction: enum, inherit, initial

  8070   SetDiscrete(*aRuleData->ValueForBoxDirection(),

  8071               xul->mBoxDirection, canStoreInRuleTree,

  8072               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8073               parentXUL->mBoxDirection,

  8074               NS_STYLE_BOX_DIRECTION_NORMAL, 0, 0, 0, 0);

  8076   // box-flex: factor, inherit

  8077   SetFactor(*aRuleData->ValueForBoxFlex(),

  8078             xul->mBoxFlex, canStoreInRuleTree,

  8079             parentXUL->mBoxFlex, 0.0f,

  8080             SETFCT_UNSET_INITIAL);

  8082   // box-orient: enum, inherit, initial

  8083   SetDiscrete(*aRuleData->ValueForBoxOrient(),

  8084               xul->mBoxOrient, canStoreInRuleTree,

  8085               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8086               parentXUL->mBoxOrient,

  8087               NS_STYLE_BOX_ORIENT_HORIZONTAL, 0, 0, 0, 0);

  8089   // box-pack: enum, inherit, initial

  8090   SetDiscrete(*aRuleData->ValueForBoxPack(),

  8091               xul->mBoxPack, canStoreInRuleTree,

  8092               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8093               parentXUL->mBoxPack,

  8094               NS_STYLE_BOX_PACK_START, 0, 0, 0, 0);

  8096   // box-ordinal-group: integer, inherit, initial

  8097   SetDiscrete(*aRuleData->ValueForBoxOrdinalGroup(),

  8098               xul->mBoxOrdinal, canStoreInRuleTree,

  8099               SETDSC_INTEGER | SETDSC_UNSET_INITIAL,

  8100               parentXUL->mBoxOrdinal, 1,

  8101               0, 0, 0, 0);

  8103   const nsCSSValue* stackSizingValue = aRuleData->ValueForStackSizing();

  8104   if (eCSSUnit_Inherit == stackSizingValue->GetUnit()) {

  8105     canStoreInRuleTree = false;

  8106     xul->mStretchStack = parentXUL->mStretchStack;

  8107   } else if (eCSSUnit_Initial == stackSizingValue->GetUnit() ||

  8108              eCSSUnit_Unset == stackSizingValue->GetUnit()) {

  8109     xul->mStretchStack = true;

  8110   } else if (eCSSUnit_Enumerated == stackSizingValue->GetUnit()) {

  8111     xul->mStretchStack = stackSizingValue->GetIntValue() ==

  8112       NS_STYLE_STACK_SIZING_STRETCH_TO_FIT;

  8113   }

  8115   COMPUTE_END_RESET(XUL, xul)

  8116 }

  8118 const void*

  8119 nsRuleNode::ComputeColumnData(void* aStartStruct,

  8120                               const nsRuleData* aRuleData,

  8121                               nsStyleContext* aContext,

  8122                               nsRuleNode* aHighestNode,

  8123                               const RuleDetail aRuleDetail,

  8124                               const bool aCanStoreInRuleTree)

  8125 {

  8126   COMPUTE_START_RESET(Column, (mPresContext), column, parent)

  8128   // column-width: length, auto, inherit

  8129   SetCoord(*aRuleData->ValueForColumnWidth(),

  8130            column->mColumnWidth, parent->mColumnWidth,

  8131            SETCOORD_LAH | SETCOORD_INITIAL_AUTO |

  8132              SETCOORD_CALC_LENGTH_ONLY | SETCOORD_CALC_CLAMP_NONNEGATIVE |

  8133              SETCOORD_UNSET_INITIAL,

  8134            aContext, mPresContext, canStoreInRuleTree);

  8136   // column-gap: length, inherit, normal

  8137   SetCoord(*aRuleData->ValueForColumnGap(),

  8138            column->mColumnGap, parent->mColumnGap,

  8139            SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL |

  8140              SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INITIAL,

  8141            aContext, mPresContext, canStoreInRuleTree);

  8142   // clamp negative calc() to 0

  8143   if (column->mColumnGap.GetUnit() == eStyleUnit_Coord) {

  8144     column->mColumnGap.SetCoordValue(

  8145       std::max(column->mColumnGap.GetCoordValue(), 0));

  8146   }

  8148   // column-count: auto, integer, inherit

  8149   const nsCSSValue* columnCountValue = aRuleData->ValueForColumnCount();

  8150   if (eCSSUnit_Auto == columnCountValue->GetUnit() ||

  8151       eCSSUnit_Initial == columnCountValue->GetUnit() ||

  8152       eCSSUnit_Unset == columnCountValue->GetUnit()) {

  8153     column->mColumnCount = NS_STYLE_COLUMN_COUNT_AUTO;

  8154   } else if (eCSSUnit_Integer == columnCountValue->GetUnit()) {

  8155     column->mColumnCount = columnCountValue->GetIntValue();

  8156     // Max kMaxColumnCount columns - wallpaper for bug 345583.

  8157     column->mColumnCount = std::min(column->mColumnCount,

  8158                                     nsStyleColumn::kMaxColumnCount);

  8159   } else if (eCSSUnit_Inherit == columnCountValue->GetUnit()) {

  8160     canStoreInRuleTree = false;

  8161     column->mColumnCount = parent->mColumnCount;

  8162   }

  8164   // column-rule-width: length, enum, inherit

  8165   const nsCSSValue& widthValue = *aRuleData->ValueForColumnRuleWidth();

  8166   if (eCSSUnit_Initial == widthValue.GetUnit() ||

  8167       eCSSUnit_Unset == widthValue.GetUnit()) {

  8168     column->SetColumnRuleWidth(

  8169         (mPresContext->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM]);

  8170   }

  8171   else if (eCSSUnit_Enumerated == widthValue.GetUnit()) {

  8172     NS_ASSERTION(widthValue.GetIntValue() == NS_STYLE_BORDER_WIDTH_THIN ||

  8173                  widthValue.GetIntValue() == NS_STYLE_BORDER_WIDTH_MEDIUM ||

  8174                  widthValue.GetIntValue() == NS_STYLE_BORDER_WIDTH_THICK,

  8175                  "Unexpected enum value");

  8176     column->SetColumnRuleWidth(

  8177         (mPresContext->GetBorderWidthTable())[widthValue.GetIntValue()]);

  8178   }

  8179   else if (eCSSUnit_Inherit == widthValue.GetUnit()) {

  8180     column->SetColumnRuleWidth(parent->GetComputedColumnRuleWidth());

  8181     canStoreInRuleTree = false;

  8182   }

  8183   else if (widthValue.IsLengthUnit() || widthValue.IsCalcUnit()) {

  8184     nscoord len =

  8185       CalcLength(widthValue, aContext, mPresContext, canStoreInRuleTree);

  8186     if (len < 0) {

  8187       // FIXME: This is untested (by test_value_storage.html) for

  8188       // column-rule-width since it gets covered up by the border

  8189       // rounding code.

  8190       NS_ASSERTION(widthValue.IsCalcUnit(),

  8191                    "parser should have rejected negative length");

  8192       len = 0;

  8193     }

  8194     column->SetColumnRuleWidth(len);

  8195   }

  8197   // column-rule-style: enum, inherit

  8198   const nsCSSValue& styleValue = *aRuleData->ValueForColumnRuleStyle();

  8199   NS_ABORT_IF_FALSE(eCSSUnit_None != styleValue.GetUnit(),

  8200                     "'none' should be handled as enumerated value");

  8201   if (eCSSUnit_Enumerated == styleValue.GetUnit()) {

  8202     column->mColumnRuleStyle = styleValue.GetIntValue();

  8203   }

  8204   else if (eCSSUnit_Initial == styleValue.GetUnit() ||

  8205            eCSSUnit_Unset == styleValue.GetUnit()) {

  8206     column->mColumnRuleStyle = NS_STYLE_BORDER_STYLE_NONE;

  8207   }

  8208   else if (eCSSUnit_Inherit == styleValue.GetUnit()) {

  8209     canStoreInRuleTree = false;

  8210     column->mColumnRuleStyle = parent->mColumnRuleStyle;

  8211   }

  8213   // column-rule-color: color, inherit

  8214   const nsCSSValue& colorValue = *aRuleData->ValueForColumnRuleColor();

  8215   if (eCSSUnit_Inherit == colorValue.GetUnit()) {

  8216     canStoreInRuleTree = false;

  8217     column->mColumnRuleColorIsForeground = false;

  8218     if (parent->mColumnRuleColorIsForeground) {

  8219       if (parentContext) {

  8220         column->mColumnRuleColor = parentContext->StyleColor()->mColor;

  8221       } else {

  8222         nsStyleColor defaultColumnRuleColor(mPresContext);

  8223         column->mColumnRuleColor = defaultColumnRuleColor.mColor;

  8224       }

  8225     } else {

  8226       column->mColumnRuleColor = parent->mColumnRuleColor;

  8227     }

  8228   }

  8229   else if (eCSSUnit_Initial == colorValue.GetUnit() ||

  8230            eCSSUnit_Unset == colorValue.GetUnit() ||

  8231            eCSSUnit_Enumerated == colorValue.GetUnit()) {

  8232     column->mColumnRuleColorIsForeground = true;

  8233   }

  8234   else if (SetColor(colorValue, 0, mPresContext, aContext,

  8235                     column->mColumnRuleColor, canStoreInRuleTree)) {

  8236     column->mColumnRuleColorIsForeground = false;

  8237   }

  8239   // column-fill: enum

  8240   SetDiscrete(*aRuleData->ValueForColumnFill(),

  8241                 column->mColumnFill, canStoreInRuleTree,

  8242                 SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8243                 parent->mColumnFill,

  8244                 NS_STYLE_COLUMN_FILL_BALANCE,

  8245                 0, 0, 0, 0);

  8247   COMPUTE_END_RESET(Column, column)

  8248 }

  8250 static void

  8251 SetSVGPaint(const nsCSSValue& aValue, const nsStyleSVGPaint& parentPaint,

  8252             nsPresContext* aPresContext, nsStyleContext *aContext,

  8253             nsStyleSVGPaint& aResult, nsStyleSVGPaintType aInitialPaintType,

  8254             bool& aCanStoreInRuleTree)

  8255 {

  8256   nscolor color;

  8258   if (aValue.GetUnit() == eCSSUnit_Inherit ||

  8259       aValue.GetUnit() == eCSSUnit_Unset) {

  8260     aResult = parentPaint;

  8261     aCanStoreInRuleTree = false;

  8262   } else if (aValue.GetUnit() == eCSSUnit_None) {

  8263     aResult.SetType(eStyleSVGPaintType_None);

  8264   } else if (aValue.GetUnit() == eCSSUnit_Initial) {

  8265     aResult.SetType(aInitialPaintType);

  8266     aResult.mPaint.mColor = NS_RGB(0, 0, 0);

  8267     aResult.mFallbackColor = NS_RGB(0, 0, 0);

  8268   } else if (SetColor(aValue, NS_RGB(0, 0, 0), aPresContext, aContext,

  8269                       color, aCanStoreInRuleTree)) {

  8270     aResult.SetType(eStyleSVGPaintType_Color);

  8271     aResult.mPaint.mColor = color;

  8272   } else if (aValue.GetUnit() == eCSSUnit_Pair) {

  8273     const nsCSSValuePair& pair = aValue.GetPairValue();

  8275     if (pair.mXValue.GetUnit() == eCSSUnit_URL) {

  8276       aResult.SetType(eStyleSVGPaintType_Server);

  8277       aResult.mPaint.mPaintServer = pair.mXValue.GetURLValue();

  8278       NS_IF_ADDREF(aResult.mPaint.mPaintServer);

  8279     } else if (pair.mXValue.GetUnit() == eCSSUnit_Enumerated) {

  8281       switch (pair.mXValue.GetIntValue()) {

  8282       case NS_COLOR_CONTEXT_FILL:

  8283         aResult.SetType(eStyleSVGPaintType_ContextFill);

  8284         break;

  8285       case NS_COLOR_CONTEXT_STROKE:

  8286         aResult.SetType(eStyleSVGPaintType_ContextStroke);

  8287         break;

  8288       default:

  8289         NS_NOTREACHED("unknown keyword as paint server value");

  8290       }

  8292     } else {

  8293       NS_NOTREACHED("malformed paint server value");

  8294     }

  8296     if (pair.mYValue.GetUnit() == eCSSUnit_None) {

  8297       aResult.mFallbackColor = NS_RGBA(0, 0, 0, 0);

  8298     } else {

  8299       NS_ABORT_IF_FALSE(pair.mYValue.GetUnit() != eCSSUnit_Inherit,

  8300                         "cannot inherit fallback colour");

  8301       SetColor(pair.mYValue, NS_RGB(0, 0, 0), aPresContext, aContext,

  8302                aResult.mFallbackColor, aCanStoreInRuleTree);

  8303     }

  8304   } else {

  8305     NS_ABORT_IF_FALSE(aValue.GetUnit() == eCSSUnit_Null,

  8306                       "malformed paint server value");

  8307   }

  8308 }

  8310 static void

  8311 SetSVGOpacity(const nsCSSValue& aValue,

  8312               float& aOpacityField, nsStyleSVGOpacitySource& aOpacityTypeField,

  8313               bool& aCanStoreInRuleTree,

  8314               float aParentOpacity, nsStyleSVGOpacitySource aParentOpacityType)

  8315 {

  8316   if (eCSSUnit_Enumerated == aValue.GetUnit()) {

  8317     switch (aValue.GetIntValue()) {

  8318     case NS_STYLE_CONTEXT_FILL_OPACITY:

  8319       aOpacityTypeField = eStyleSVGOpacitySource_ContextFillOpacity;

  8320       break;

  8321     case NS_STYLE_CONTEXT_STROKE_OPACITY:

  8322       aOpacityTypeField = eStyleSVGOpacitySource_ContextStrokeOpacity;

  8323       break;

  8324     default:

  8325       NS_NOTREACHED("SetSVGOpacity: Unknown keyword");

  8326     }

  8327     // Fall back on fully opaque

  8328     aOpacityField = 1.0f;

  8329   } else if (eCSSUnit_Inherit == aValue.GetUnit() ||

  8330              eCSSUnit_Unset == aValue.GetUnit()) {

  8331     aCanStoreInRuleTree = false;

  8332     aOpacityField = aParentOpacity;

  8333     aOpacityTypeField = aParentOpacityType;

  8334   } else if (eCSSUnit_Null != aValue.GetUnit()) {

  8335     SetFactor(aValue, aOpacityField, aCanStoreInRuleTree,

  8336               aParentOpacity, 1.0f, SETFCT_OPACITY);

  8337     aOpacityTypeField = eStyleSVGOpacitySource_Normal;

  8338   }

  8339 }

  8341 const void*

  8342 nsRuleNode::ComputeSVGData(void* aStartStruct,

  8343                            const nsRuleData* aRuleData,

  8344                            nsStyleContext* aContext,

  8345                            nsRuleNode* aHighestNode,

  8346                            const RuleDetail aRuleDetail,

  8347                            const bool aCanStoreInRuleTree)

  8348 {

  8349   COMPUTE_START_INHERITED(SVG, (), svg, parentSVG)

  8351   // clip-rule: enum, inherit, initial

  8352   SetDiscrete(*aRuleData->ValueForClipRule(),

  8353               svg->mClipRule, canStoreInRuleTree,

  8354               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8355               parentSVG->mClipRule,

  8356               NS_STYLE_FILL_RULE_NONZERO, 0, 0, 0, 0);

  8358   // color-interpolation: enum, inherit, initial

  8359   SetDiscrete(*aRuleData->ValueForColorInterpolation(),

  8360               svg->mColorInterpolation, canStoreInRuleTree,

  8361               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8362               parentSVG->mColorInterpolation,

  8363               NS_STYLE_COLOR_INTERPOLATION_SRGB, 0, 0, 0, 0);

  8365   // color-interpolation-filters: enum, inherit, initial

  8366   SetDiscrete(*aRuleData->ValueForColorInterpolationFilters(),

  8367               svg->mColorInterpolationFilters, canStoreInRuleTree,

  8368               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8369               parentSVG->mColorInterpolationFilters,

  8370               NS_STYLE_COLOR_INTERPOLATION_LINEARRGB, 0, 0, 0, 0);

  8372   // fill:

  8373   SetSVGPaint(*aRuleData->ValueForFill(),

  8374               parentSVG->mFill, mPresContext, aContext,

  8375               svg->mFill, eStyleSVGPaintType_Color, canStoreInRuleTree);

  8377   // fill-opacity: factor, inherit, initial,

  8378   // context-fill-opacity, context-stroke-opacity

  8379   nsStyleSVGOpacitySource contextFillOpacity = svg->mFillOpacitySource;

  8380   SetSVGOpacity(*aRuleData->ValueForFillOpacity(),

  8381                 svg->mFillOpacity, contextFillOpacity, canStoreInRuleTree,

  8382                 parentSVG->mFillOpacity, parentSVG->mFillOpacitySource);

  8383   svg->mFillOpacitySource = contextFillOpacity;

  8385   // fill-rule: enum, inherit, initial

  8386   SetDiscrete(*aRuleData->ValueForFillRule(),

  8387               svg->mFillRule, canStoreInRuleTree,

  8388               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8389               parentSVG->mFillRule,

  8390               NS_STYLE_FILL_RULE_NONZERO, 0, 0, 0, 0);

  8392   // image-rendering: enum, inherit

  8393   SetDiscrete(*aRuleData->ValueForImageRendering(),

  8394               svg->mImageRendering, canStoreInRuleTree,

  8395               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8396               parentSVG->mImageRendering,

  8397               NS_STYLE_IMAGE_RENDERING_AUTO, 0, 0, 0, 0);

  8399   // marker-end: url, none, inherit

  8400   const nsCSSValue* markerEndValue = aRuleData->ValueForMarkerEnd();

  8401   if (eCSSUnit_URL == markerEndValue->GetUnit()) {

  8402     svg->mMarkerEnd = markerEndValue->GetURLValue();

  8403   } else if (eCSSUnit_None == markerEndValue->GetUnit() ||

  8404              eCSSUnit_Initial == markerEndValue->GetUnit()) {

  8405     svg->mMarkerEnd = nullptr;

  8406   } else if (eCSSUnit_Inherit == markerEndValue->GetUnit() ||

  8407              eCSSUnit_Unset == markerEndValue->GetUnit()) {

  8408     canStoreInRuleTree = false;

  8409     svg->mMarkerEnd = parentSVG->mMarkerEnd;

  8410   }

  8412   // marker-mid: url, none, inherit

  8413   const nsCSSValue* markerMidValue = aRuleData->ValueForMarkerMid();

  8414   if (eCSSUnit_URL == markerMidValue->GetUnit()) {

  8415     svg->mMarkerMid = markerMidValue->GetURLValue();

  8416   } else if (eCSSUnit_None == markerMidValue->GetUnit() ||

  8417              eCSSUnit_Initial == markerMidValue->GetUnit()) {

  8418     svg->mMarkerMid = nullptr;

  8419   } else if (eCSSUnit_Inherit == markerMidValue->GetUnit() ||

  8420              eCSSUnit_Unset == markerMidValue->GetUnit()) {

  8421     canStoreInRuleTree = false;

  8422     svg->mMarkerMid = parentSVG->mMarkerMid;

  8423   }

  8425   // marker-start: url, none, inherit

  8426   const nsCSSValue* markerStartValue = aRuleData->ValueForMarkerStart();

  8427   if (eCSSUnit_URL == markerStartValue->GetUnit()) {

  8428     svg->mMarkerStart = markerStartValue->GetURLValue();

  8429   } else if (eCSSUnit_None == markerStartValue->GetUnit() ||

  8430              eCSSUnit_Initial == markerStartValue->GetUnit()) {

  8431     svg->mMarkerStart = nullptr;

  8432   } else if (eCSSUnit_Inherit == markerStartValue->GetUnit() ||

  8433              eCSSUnit_Unset == markerStartValue->GetUnit()) {

  8434     canStoreInRuleTree = false;

  8435     svg->mMarkerStart = parentSVG->mMarkerStart;

  8436   }

  8438   // paint-order: enum (bit field), inherit, initial

  8439   const nsCSSValue* paintOrderValue = aRuleData->ValueForPaintOrder();

  8440   switch (paintOrderValue->GetUnit()) {

  8441     case eCSSUnit_Null:

  8442       break;

  8444     case eCSSUnit_Enumerated:

  8445       static_assert

  8446         (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8,

  8447          "SVGStyleStruct::mPaintOrder not big enough");

  8448       svg->mPaintOrder = static_cast<uint8_t>(paintOrderValue->GetIntValue());

  8449       break;

  8451     case eCSSUnit_Inherit:

  8452     case eCSSUnit_Unset:

  8453       canStoreInRuleTree = false;

  8454       svg->mPaintOrder = parentSVG->mPaintOrder;

  8455       break;

  8457     case eCSSUnit_Initial:

  8458       svg->mPaintOrder = NS_STYLE_PAINT_ORDER_NORMAL;

  8459       break;

  8461     default:

  8462       NS_NOTREACHED("unexpected unit");

  8463   }

  8465   // shape-rendering: enum, inherit

  8466   SetDiscrete(*aRuleData->ValueForShapeRendering(),

  8467               svg->mShapeRendering, canStoreInRuleTree,

  8468               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8469               parentSVG->mShapeRendering,

  8470               NS_STYLE_SHAPE_RENDERING_AUTO, 0, 0, 0, 0);

  8472   // stroke:

  8473   SetSVGPaint(*aRuleData->ValueForStroke(),

  8474               parentSVG->mStroke, mPresContext, aContext,

  8475               svg->mStroke, eStyleSVGPaintType_None, canStoreInRuleTree);

  8477   // stroke-dasharray: <dasharray>, none, inherit, context-value

  8478   const nsCSSValue* strokeDasharrayValue = aRuleData->ValueForStrokeDasharray();

  8479   switch (strokeDasharrayValue->GetUnit()) {

  8480   case eCSSUnit_Null:

  8481     break;

  8483   case eCSSUnit_Inherit:

  8484   case eCSSUnit_Unset:

  8485     canStoreInRuleTree = false;

  8486     svg->mStrokeDasharrayFromObject = parentSVG->mStrokeDasharrayFromObject;

  8487     // only do the copy if weren't already set up by the copy constructor

  8488     // FIXME Bug 389408: This is broken when aStartStruct is non-null!

  8489     if (!svg->mStrokeDasharray) {

  8490       svg->mStrokeDasharrayLength = parentSVG->mStrokeDasharrayLength;

  8491       if (svg->mStrokeDasharrayLength) {

  8492         svg->mStrokeDasharray = new nsStyleCoord[svg->mStrokeDasharrayLength];

  8493         if (svg->mStrokeDasharray)

  8494           memcpy(svg->mStrokeDasharray,

  8495                  parentSVG->mStrokeDasharray,

  8496                  svg->mStrokeDasharrayLength * sizeof(nsStyleCoord));

  8497         else

  8498           svg->mStrokeDasharrayLength = 0;

  8499       }

  8500     }

  8501     break;

  8503   case eCSSUnit_Enumerated:

  8504     NS_ABORT_IF_FALSE(strokeDasharrayValue->GetIntValue() ==

  8505                             NS_STYLE_STROKE_PROP_CONTEXT_VALUE,

  8506                       "Unknown keyword for stroke-dasharray");

  8507     svg->mStrokeDasharrayFromObject = true;

  8508     delete [] svg->mStrokeDasharray;

  8509     svg->mStrokeDasharray = nullptr;

  8510     svg->mStrokeDasharrayLength = 0;

  8511     break;

  8513   case eCSSUnit_Initial:

  8514   case eCSSUnit_None:

  8515     svg->mStrokeDasharrayFromObject = false;

  8516     delete [] svg->mStrokeDasharray;

  8517     svg->mStrokeDasharray = nullptr;

  8518     svg->mStrokeDasharrayLength = 0;

  8519     break;

  8521   case eCSSUnit_List:

  8522   case eCSSUnit_ListDep: {

  8523     svg->mStrokeDasharrayFromObject = false;

  8524     delete [] svg->mStrokeDasharray;

  8525     svg->mStrokeDasharray = nullptr;

  8526     svg->mStrokeDasharrayLength = 0;

  8528     // count number of values

  8529     const nsCSSValueList *value = strokeDasharrayValue->GetListValue();

  8530     svg->mStrokeDasharrayLength = ListLength(value);

  8532     NS_ASSERTION(svg->mStrokeDasharrayLength != 0, "no dasharray items");

  8534     svg->mStrokeDasharray = new nsStyleCoord[svg->mStrokeDasharrayLength];

  8536     if (svg->mStrokeDasharray) {

  8537       uint32_t i = 0;

  8538       while (nullptr != value) {

  8539         SetCoord(value->mValue,

  8540                  svg->mStrokeDasharray[i++], nsStyleCoord(),

  8541                  SETCOORD_LP | SETCOORD_FACTOR,

  8542                  aContext, mPresContext, canStoreInRuleTree);

  8543         value = value->mNext;

  8544       }

  8545     } else {

  8546       svg->mStrokeDasharrayLength = 0;

  8547     }

  8548     break;

  8549   }

  8551   default:

  8552     NS_ABORT_IF_FALSE(false, "unrecognized dasharray unit");

  8553   }

  8555   // stroke-dashoffset: <dashoffset>, inherit

  8556   const nsCSSValue *strokeDashoffsetValue =

  8557     aRuleData->ValueForStrokeDashoffset();

  8558   svg->mStrokeDashoffsetFromObject =

  8559     strokeDashoffsetValue->GetUnit() == eCSSUnit_Enumerated &&

  8560     strokeDashoffsetValue->GetIntValue() == NS_STYLE_STROKE_PROP_CONTEXT_VALUE;

  8561   if (svg->mStrokeDashoffsetFromObject) {

  8562     svg->mStrokeDashoffset.SetCoordValue(0);

  8563   } else {

  8564     SetCoord(*aRuleData->ValueForStrokeDashoffset(),

  8565              svg->mStrokeDashoffset, parentSVG->mStrokeDashoffset,

  8566              SETCOORD_LPH | SETCOORD_FACTOR | SETCOORD_INITIAL_ZERO |

  8567                SETCOORD_UNSET_INHERIT,

  8568              aContext, mPresContext, canStoreInRuleTree);

  8569   }

  8571   // stroke-linecap: enum, inherit, initial

  8572   SetDiscrete(*aRuleData->ValueForStrokeLinecap(),

  8573               svg->mStrokeLinecap, canStoreInRuleTree,

  8574               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8575               parentSVG->mStrokeLinecap,

  8576               NS_STYLE_STROKE_LINECAP_BUTT, 0, 0, 0, 0);

  8578   // stroke-linejoin: enum, inherit, initial

  8579   SetDiscrete(*aRuleData->ValueForStrokeLinejoin(),

  8580               svg->mStrokeLinejoin, canStoreInRuleTree,

  8581               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8582               parentSVG->mStrokeLinejoin,

  8583               NS_STYLE_STROKE_LINEJOIN_MITER, 0, 0, 0, 0);

  8585   // stroke-miterlimit: <miterlimit>, inherit

  8586   SetFactor(*aRuleData->ValueForStrokeMiterlimit(),

  8587             svg->mStrokeMiterlimit,

  8588             canStoreInRuleTree,

  8589             parentSVG->mStrokeMiterlimit, 4.0f,

  8590             SETFCT_UNSET_INHERIT);

  8592   // stroke-opacity:

  8593   nsStyleSVGOpacitySource contextStrokeOpacity = svg->mStrokeOpacitySource;

  8594   SetSVGOpacity(*aRuleData->ValueForStrokeOpacity(),

  8595                 svg->mStrokeOpacity, contextStrokeOpacity, canStoreInRuleTree,

  8596                 parentSVG->mStrokeOpacity, parentSVG->mStrokeOpacitySource);

  8597   svg->mStrokeOpacitySource = contextStrokeOpacity;

  8599   // stroke-width:

  8600   const nsCSSValue* strokeWidthValue = aRuleData->ValueForStrokeWidth();

  8601   switch (strokeWidthValue->GetUnit()) {

  8602   case eCSSUnit_Enumerated:

  8603     NS_ABORT_IF_FALSE(strokeWidthValue->GetIntValue() ==

  8604                         NS_STYLE_STROKE_PROP_CONTEXT_VALUE,

  8605                       "Unrecognized keyword for stroke-width");

  8606     svg->mStrokeWidthFromObject = true;

  8607     svg->mStrokeWidth.SetCoordValue(nsPresContext::CSSPixelsToAppUnits(1));

  8608     break;

  8610   case eCSSUnit_Initial:

  8611     svg->mStrokeWidthFromObject = false;

  8612     svg->mStrokeWidth.SetCoordValue(nsPresContext::CSSPixelsToAppUnits(1));

  8613     break;

  8615   default:

  8616     svg->mStrokeWidthFromObject = false;

  8617     SetCoord(*strokeWidthValue,

  8618              svg->mStrokeWidth, parentSVG->mStrokeWidth,

  8619              SETCOORD_LPH | SETCOORD_FACTOR | SETCOORD_UNSET_INHERIT,

  8620              aContext, mPresContext, canStoreInRuleTree);

  8621   }

  8623   // text-anchor: enum, inherit, initial

  8624   SetDiscrete(*aRuleData->ValueForTextAnchor(),

  8625               svg->mTextAnchor, canStoreInRuleTree,

  8626               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8627               parentSVG->mTextAnchor,

  8628               NS_STYLE_TEXT_ANCHOR_START, 0, 0, 0, 0);

  8630   // text-rendering: enum, inherit, initial

  8631   SetDiscrete(*aRuleData->ValueForTextRendering(),

  8632               svg->mTextRendering, canStoreInRuleTree,

  8633               SETDSC_ENUMERATED | SETDSC_UNSET_INHERIT,

  8634               parentSVG->mTextRendering,

  8635               NS_STYLE_TEXT_RENDERING_AUTO, 0, 0, 0, 0);

  8637   COMPUTE_END_INHERITED(SVG, svg)

  8638 }

  8640 // Returns true if the nsStyleFilter was successfully set using the nsCSSValue.

  8641 bool

  8642 nsRuleNode::SetStyleFilterToCSSValue(nsStyleFilter* aStyleFilter,

  8643                                      const nsCSSValue& aValue,

  8644                                      nsStyleContext* aStyleContext,

  8645                                      nsPresContext* aPresContext,

  8646                                      bool& aCanStoreInRuleTree)

  8647 {

  8648   nsCSSUnit unit = aValue.GetUnit();

  8649   if (unit == eCSSUnit_URL) {

  8650     nsIURI* url = aValue.GetURLValue();

  8651     if (!url)

  8652       return false;

  8653     aStyleFilter->SetURL(url);

  8654     return true;

  8655   }

  8657   NS_ABORT_IF_FALSE(unit == eCSSUnit_Function, "expected a filter function");

  8659   nsCSSValue::Array* filterFunction = aValue.GetArrayValue();

  8660   nsCSSKeyword functionName =

  8661     (nsCSSKeyword)filterFunction->Item(0).GetIntValue();

  8663   int32_t type;

  8664   DebugOnly<bool> foundKeyword =

  8665     nsCSSProps::FindKeyword(functionName,

  8666                             nsCSSProps::kFilterFunctionKTable,

  8667                             type);

  8668   NS_ABORT_IF_FALSE(foundKeyword, "unknown filter type");

  8669   if (type == NS_STYLE_FILTER_DROP_SHADOW) {

  8670     nsRefPtr<nsCSSShadowArray> shadowArray = GetShadowData(

  8671       filterFunction->Item(1).GetListValue(),

  8672       aStyleContext,

  8673       false,

  8674       aCanStoreInRuleTree);

  8675     aStyleFilter->SetDropShadow(shadowArray);

  8676     return true;

  8677   }

  8679   int32_t mask = SETCOORD_PERCENT | SETCOORD_FACTOR;

  8680   if (type == NS_STYLE_FILTER_BLUR) {

  8681     mask = SETCOORD_LENGTH | SETCOORD_STORE_CALC;

  8682   } else if (type == NS_STYLE_FILTER_HUE_ROTATE) {

  8683     mask = SETCOORD_ANGLE;

  8684   }

  8686   NS_ABORT_IF_FALSE(filterFunction->Count() == 2,

  8687                     "all filter functions should have "

  8688                     "exactly one argument");

  8690   nsCSSValue& arg = filterFunction->Item(1);

  8691   nsStyleCoord filterParameter;

  8692   DebugOnly<bool> didSetCoord = SetCoord(arg, filterParameter,

  8693                                          nsStyleCoord(), mask,

  8694                                          aStyleContext, aPresContext,

  8695                                          aCanStoreInRuleTree);

  8696   aStyleFilter->SetFilterParameter(filterParameter, type);

  8697   NS_ABORT_IF_FALSE(didSetCoord, "unexpected unit");

  8698   return true;

  8699 }

  8701 const void*

  8702 nsRuleNode::ComputeSVGResetData(void* aStartStruct,

  8703                                 const nsRuleData* aRuleData,

  8704                                 nsStyleContext* aContext,

  8705                                 nsRuleNode* aHighestNode,

  8706                                 const RuleDetail aRuleDetail,

  8707                                 const bool aCanStoreInRuleTree)

  8708 {

  8709   COMPUTE_START_RESET(SVGReset, (), svgReset, parentSVGReset)

  8711   // stop-color:

  8712   const nsCSSValue* stopColorValue = aRuleData->ValueForStopColor();

  8713   if (eCSSUnit_Initial == stopColorValue->GetUnit() ||

  8714       eCSSUnit_Unset == stopColorValue->GetUnit()) {

  8715     svgReset->mStopColor = NS_RGB(0, 0, 0);

  8716   } else {

  8717     SetColor(*stopColorValue, parentSVGReset->mStopColor,

  8718              mPresContext, aContext, svgReset->mStopColor, canStoreInRuleTree);

  8719   }

  8721   // flood-color:

  8722   const nsCSSValue* floodColorValue = aRuleData->ValueForFloodColor();

  8723   if (eCSSUnit_Initial == floodColorValue->GetUnit() ||

  8724       eCSSUnit_Unset == floodColorValue->GetUnit()) {

  8725     svgReset->mFloodColor = NS_RGB(0, 0, 0);

  8726   } else {

  8727     SetColor(*floodColorValue, parentSVGReset->mFloodColor,

  8728              mPresContext, aContext, svgReset->mFloodColor, canStoreInRuleTree);

  8729   }

  8731   // lighting-color:

  8732   const nsCSSValue* lightingColorValue = aRuleData->ValueForLightingColor();

  8733   if (eCSSUnit_Initial == lightingColorValue->GetUnit() ||

  8734       eCSSUnit_Unset == lightingColorValue->GetUnit()) {

  8735     svgReset->mLightingColor = NS_RGB(255, 255, 255);

  8736   } else {

  8737     SetColor(*lightingColorValue, parentSVGReset->mLightingColor,

  8738              mPresContext, aContext, svgReset->mLightingColor,

  8739              canStoreInRuleTree);

  8740   }

  8742   // clip-path: url, none, inherit

  8743   const nsCSSValue* clipPathValue = aRuleData->ValueForClipPath();

  8744   if (eCSSUnit_URL == clipPathValue->GetUnit()) {

  8745     svgReset->mClipPath = clipPathValue->GetURLValue();

  8746   } else if (eCSSUnit_None == clipPathValue->GetUnit() ||

  8747              eCSSUnit_Initial == clipPathValue->GetUnit() ||

  8748              eCSSUnit_Unset == clipPathValue->GetUnit()) {

  8749     svgReset->mClipPath = nullptr;

  8750   } else if (eCSSUnit_Inherit == clipPathValue->GetUnit()) {

  8751     canStoreInRuleTree = false;

  8752     svgReset->mClipPath = parentSVGReset->mClipPath;

  8753   }

  8755   // stop-opacity:

  8756   SetFactor(*aRuleData->ValueForStopOpacity(),

  8757             svgReset->mStopOpacity, canStoreInRuleTree,

  8758             parentSVGReset->mStopOpacity, 1.0f,

  8759             SETFCT_OPACITY | SETFCT_UNSET_INITIAL);

  8761   // flood-opacity:

  8762   SetFactor(*aRuleData->ValueForFloodOpacity(),

  8763             svgReset->mFloodOpacity, canStoreInRuleTree,

  8764             parentSVGReset->mFloodOpacity, 1.0f,

  8765             SETFCT_OPACITY | SETFCT_UNSET_INITIAL);

  8767   // dominant-baseline: enum, inherit, initial

  8768   SetDiscrete(*aRuleData->ValueForDominantBaseline(),

  8769               svgReset->mDominantBaseline,

  8770               canStoreInRuleTree,

  8771               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8772               parentSVGReset->mDominantBaseline,

  8773               NS_STYLE_DOMINANT_BASELINE_AUTO, 0, 0, 0, 0);

  8775   // vector-effect: enum, inherit, initial

  8776   SetDiscrete(*aRuleData->ValueForVectorEffect(),

  8777               svgReset->mVectorEffect,

  8778               canStoreInRuleTree,

  8779               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8780               parentSVGReset->mVectorEffect,

  8781               NS_STYLE_VECTOR_EFFECT_NONE, 0, 0, 0, 0);

  8783   // filter: url, none, inherit

  8784   const nsCSSValue* filterValue = aRuleData->ValueForFilter();

  8785   switch (filterValue->GetUnit()) {

  8786     case eCSSUnit_Null:

  8787       break;

  8788     case eCSSUnit_None:

  8789     case eCSSUnit_Initial:

  8790     case eCSSUnit_Unset:

  8791       svgReset->mFilters.Clear();

  8792       break;

  8793     case eCSSUnit_Inherit:

  8794       canStoreInRuleTree = false;

  8795       svgReset->mFilters = parentSVGReset->mFilters;

  8796       break;

  8797     case eCSSUnit_List:

  8798     case eCSSUnit_ListDep: {

  8799       svgReset->mFilters.Clear();

  8800       const nsCSSValueList* cur = filterValue->GetListValue();

  8801       while (cur) {

  8802         nsStyleFilter styleFilter;

  8803         if (!SetStyleFilterToCSSValue(&styleFilter, cur->mValue, aContext,

  8804                                       mPresContext, canStoreInRuleTree)) {

  8805           svgReset->mFilters.Clear();

  8806           break;

  8807         }

  8808         NS_ABORT_IF_FALSE(styleFilter.GetType() != NS_STYLE_FILTER_NONE,

  8809                           "filter should be set");

  8810         svgReset->mFilters.AppendElement(styleFilter);

  8811         cur = cur->mNext;

  8812       }

  8813       break;

  8814     }

  8815     default:

  8816       NS_NOTREACHED("unexpected unit");

  8817   }

  8819   // mask: url, none, inherit

  8820   const nsCSSValue* maskValue = aRuleData->ValueForMask();

  8821   if (eCSSUnit_URL == maskValue->GetUnit()) {

  8822     svgReset->mMask = maskValue->GetURLValue();

  8823   } else if (eCSSUnit_None == maskValue->GetUnit() ||

  8824              eCSSUnit_Initial == maskValue->GetUnit() ||

  8825              eCSSUnit_Unset == maskValue->GetUnit()) {

  8826     svgReset->mMask = nullptr;

  8827   } else if (eCSSUnit_Inherit == maskValue->GetUnit()) {

  8828     canStoreInRuleTree = false;

  8829     svgReset->mMask = parentSVGReset->mMask;

  8830   }

  8832   // mask-type: enum, inherit, initial

  8833   SetDiscrete(*aRuleData->ValueForMaskType(),

  8834               svgReset->mMaskType,

  8835               canStoreInRuleTree,

  8836               SETDSC_ENUMERATED | SETDSC_UNSET_INITIAL,

  8837               parentSVGReset->mMaskType,

  8838               NS_STYLE_MASK_TYPE_LUMINANCE, 0, 0, 0, 0);

  8840   COMPUTE_END_RESET(SVGReset, svgReset)

  8841 }

  8843 const void*

  8844 nsRuleNode::ComputeVariablesData(void* aStartStruct,

  8845                                  const nsRuleData* aRuleData,

  8846                                  nsStyleContext* aContext,

  8847                                  nsRuleNode* aHighestNode,

  8848                                  const RuleDetail aRuleDetail,

  8849                                  const bool aCanStoreInRuleTree)

  8850 {

  8851   COMPUTE_START_INHERITED(Variables, (), variables, parentVariables)

  8853   MOZ_ASSERT(aRuleData->mVariables,

  8854              "shouldn't be in ComputeVariablesData if there were no variable "

  8855              "declarations specified");

  8857   CSSVariableResolver resolver(&variables->mVariables);

  8858   resolver.Resolve(&parentVariables->mVariables,

  8859                    aRuleData->mVariables);

  8860   canStoreInRuleTree = false;

  8862   COMPUTE_END_INHERITED(Variables, variables)

  8863 }

  8865 const void*

  8866 nsRuleNode::GetStyleData(nsStyleStructID aSID,

  8867                          nsStyleContext* aContext,

  8868                          bool aComputeData)

  8869 {

  8870   NS_ASSERTION(IsUsedDirectly(),

  8871                "if we ever call this on rule nodes that aren't used "

  8872                "directly, we should adjust handling of mDependentBits "

  8873                "in some way.");

  8875   const void *data;

  8876   data = mStyleData.GetStyleData(aSID);

  8877   if (MOZ_LIKELY(data != nullptr))

  8878     return data; // We have a fully specified struct. Just return it.

  8880   if (MOZ_UNLIKELY(!aComputeData))

  8881     return nullptr;

  8883   // Nothing is cached.  We'll have to delve further and examine our rules.

  8884   data = WalkRuleTree(aSID, aContext);

  8886   NS_ABORT_IF_FALSE(data, "should have aborted on out-of-memory");

  8887   return data;

  8888 }

  8890 // See comments above in GetStyleData for an explanation of what the

  8891 // code below does.

  8892 #define STYLE_STRUCT(name_, checkdata_cb_)                                    \

  8893 const nsStyle##name_*                                                         \

  8894 nsRuleNode::GetStyle##name_(nsStyleContext* aContext, bool aComputeData)      \

  8895 {                                                                             \

  8896   NS_ASSERTION(IsUsedDirectly(),                                              \

  8897                "if we ever call this on rule nodes that aren't used "         \

  8898                "directly, we should adjust handling of mDependentBits "       \

  8899                "in some way.");                                               \

  8900                                                                               \

  8901   const nsStyle##name_ *data;                                                 \

  8902   data = mStyleData.GetStyle##name_();                                        \

  8903   if (MOZ_LIKELY(data != nullptr))                                            \

  8904     return data;                                                              \

  8905                                                                               \

  8906   if (MOZ_UNLIKELY(!aComputeData))                                            \

  8907     return nullptr;                                                           \

  8908                                                                               \

  8909   data = static_cast<const nsStyle##name_ *>                                  \

  8910            (WalkRuleTree(eStyleStruct_##name_, aContext));                    \

  8911                                                                               \

  8912   NS_ABORT_IF_FALSE(data, "should have aborted on out-of-memory");            \

  8913   return data;                                                                \

  8914 }

  8915 #include "nsStyleStructList.h"

  8916 #undef STYLE_STRUCT

  8918 void

  8919 nsRuleNode::Mark()

  8920 {

  8921   for (nsRuleNode *node = this;

  8922        node && !(node->mDependentBits & NS_RULE_NODE_GC_MARK);

  8923        node = node->mParent)

  8924     node->mDependentBits |= NS_RULE_NODE_GC_MARK;

  8925 }

  8927 static PLDHashOperator

  8928 SweepRuleNodeChildren(PLDHashTable *table, PLDHashEntryHdr *hdr,

  8929                       uint32_t number, void *arg)

  8930 {

  8931   ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(hdr);

  8932   if (entry->mRuleNode->Sweep())

  8933     return PL_DHASH_REMOVE; // implies NEXT, unless |ed with STOP

  8934   return PL_DHASH_NEXT;

  8935 }

  8937 bool

  8938 nsRuleNode::Sweep()

  8939 {

  8940   // If we're not marked, then we have to delete ourself.

  8941   // However, we never allow the root node to GC itself, because nsStyleSet

  8942   // wants to hold onto the root node and not worry about re-creating a

  8943   // rule walker if the root node is deleted.

  8944   if (!(mDependentBits & NS_RULE_NODE_GC_MARK) &&

  8945       // Skip this only if we're the *current* root and not an old one.

  8946       !(IsRoot() && mPresContext->StyleSet()->GetRuleTree() == this)) {

  8947     Destroy();

  8948     return true;

  8949   }

  8951   // Clear our mark, for the next time around.

  8952   mDependentBits &= ~NS_RULE_NODE_GC_MARK;

  8954   // Call sweep on the children, since some may not be marked, and

  8955   // remove any deleted children from the child lists.

  8956   if (HaveChildren()) {

  8957     uint32_t childrenDestroyed;

  8958     if (ChildrenAreHashed()) {

  8959       PLDHashTable *children = ChildrenHash();

  8960       uint32_t oldChildCount = children->entryCount;

  8961       PL_DHashTableEnumerate(children, SweepRuleNodeChildren, nullptr);

  8962       childrenDestroyed = children->entryCount - oldChildCount;

  8963     } else {

  8964       childrenDestroyed = 0;

  8965       for (nsRuleNode **children = ChildrenListPtr(); *children; ) {

  8966         nsRuleNode *next = (*children)->mNextSibling;

  8967         if ((*children)->Sweep()) {

  8968           // This rule node was destroyed, so implicitly advance by

  8969           // making *children point to the next entry.

  8970           *children = next;

  8971           ++childrenDestroyed;

  8972         } else {

  8973           // Advance.

  8974           children = &(*children)->mNextSibling;

  8975         }

  8976       }

  8977     }

  8978     mRefCnt -= childrenDestroyed;

  8979     NS_POSTCONDITION(IsRoot() || mRefCnt > 0,

  8980                      "We didn't get swept, so we'd better have style contexts "

  8981                      "pointing to us or to one of our descendants, which means "

  8982                      "we'd better have a nonzero mRefCnt here!");

  8983   }

  8984   return false;

  8985 }

  8987 /* static */ bool

  8988 nsRuleNode::HasAuthorSpecifiedRules(nsStyleContext* aStyleContext,

  8989                                     uint32_t ruleTypeMask,

  8990                                     bool aAuthorColorsAllowed)

  8991 {

  8992   uint32_t inheritBits = 0;

  8993   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND)

  8994     inheritBits |= NS_STYLE_INHERIT_BIT(Background);

  8996   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER)

  8997     inheritBits |= NS_STYLE_INHERIT_BIT(Border);

  8999   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING)

  9000     inheritBits |= NS_STYLE_INHERIT_BIT(Padding);

  9002   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW)

  9003     inheritBits |= NS_STYLE_INHERIT_BIT(Text);

  9005   // properties in the SIDS, whether or not we care about them

  9006   size_t nprops = 0,

  9007          backgroundOffset, borderOffset, paddingOffset, textShadowOffset;

  9009   // We put the reset properties the start of the nsCSSValue array....

  9011   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) {

  9012     backgroundOffset = nprops;

  9013     nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Background);

  9014   }

  9016   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) {

  9017     borderOffset = nprops;

  9018     nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Border);

  9019   }

  9021   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) {

  9022     paddingOffset = nprops;

  9023     nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Padding);

  9024   }

  9026   // ...and the inherited properties at the end of the array.

  9027   size_t inheritedOffset = nprops;

  9029   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) {

  9030     textShadowOffset = nprops;

  9031     nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Text);

  9032   }

  9034   void* dataStorage = alloca(nprops * sizeof(nsCSSValue));

  9035   AutoCSSValueArray dataArray(dataStorage, nprops);

  9037   /* We're relying on the use of |aStyleContext| not mutating it! */

  9038   nsRuleData ruleData(inheritBits, dataArray.get(),

  9039                       aStyleContext->PresContext(), aStyleContext);

  9041   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) {

  9042     ruleData.mValueOffsets[eStyleStruct_Background] = backgroundOffset;

  9043   }

  9045   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) {

  9046     ruleData.mValueOffsets[eStyleStruct_Border] = borderOffset;

  9047   }

  9049   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) {

  9050     ruleData.mValueOffsets[eStyleStruct_Padding] = paddingOffset;

  9051   }

  9053   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) {

  9054     ruleData.mValueOffsets[eStyleStruct_Text] = textShadowOffset;

  9055   }

  9057   static const nsCSSProperty backgroundValues[] = {

  9058     eCSSProperty_background_color,

  9059     eCSSProperty_background_image,

  9060   };

  9062   static const nsCSSProperty borderValues[] = {

  9063     eCSSProperty_border_top_color,

  9064     eCSSProperty_border_top_style,

  9065     eCSSProperty_border_top_width,

  9066     eCSSProperty_border_right_color_value,

  9067     eCSSProperty_border_right_style_value,

  9068     eCSSProperty_border_right_width_value,

  9069     eCSSProperty_border_bottom_color,

  9070     eCSSProperty_border_bottom_style,

  9071     eCSSProperty_border_bottom_width,

  9072     eCSSProperty_border_left_color_value,

  9073     eCSSProperty_border_left_style_value,

  9074     eCSSProperty_border_left_width_value,

  9075     eCSSProperty_border_start_color_value,

  9076     eCSSProperty_border_start_style_value,

  9077     eCSSProperty_border_start_width_value,

  9078     eCSSProperty_border_end_color_value,

  9079     eCSSProperty_border_end_style_value,

  9080     eCSSProperty_border_end_width_value,

  9081     eCSSProperty_border_top_left_radius,

  9082     eCSSProperty_border_top_right_radius,

  9083     eCSSProperty_border_bottom_right_radius,

  9084     eCSSProperty_border_bottom_left_radius,

  9085   };

  9087   static const nsCSSProperty paddingValues[] = {

  9088     eCSSProperty_padding_top,

  9089     eCSSProperty_padding_right_value,

  9090     eCSSProperty_padding_bottom,

  9091     eCSSProperty_padding_left_value,

  9092     eCSSProperty_padding_start_value,

  9093     eCSSProperty_padding_end_value,

  9094   };

  9096   static const nsCSSProperty textShadowValues[] = {

  9097     eCSSProperty_text_shadow

  9098   };

  9100   // Number of properties we care about

  9101   size_t nValues = 0;

  9103   nsCSSValue* values[MOZ_ARRAY_LENGTH(backgroundValues) +

  9104                      MOZ_ARRAY_LENGTH(borderValues) +

  9105                      MOZ_ARRAY_LENGTH(paddingValues) +

  9106                      MOZ_ARRAY_LENGTH(textShadowValues)];

  9108   nsCSSProperty properties[MOZ_ARRAY_LENGTH(backgroundValues) +

  9109                            MOZ_ARRAY_LENGTH(borderValues) +

  9110                            MOZ_ARRAY_LENGTH(paddingValues) +

  9111                            MOZ_ARRAY_LENGTH(textShadowValues)];

  9113   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) {

  9114     for (uint32_t i = 0, i_end = ArrayLength(backgroundValues);

  9115          i < i_end; ++i) {

  9116       properties[nValues] = backgroundValues[i];

  9117       values[nValues++] = ruleData.ValueFor(backgroundValues[i]);

  9118     }

  9119   }

  9121   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) {

  9122     for (uint32_t i = 0, i_end = ArrayLength(borderValues);

  9123          i < i_end; ++i) {

  9124       properties[nValues] = borderValues[i];

  9125       values[nValues++] = ruleData.ValueFor(borderValues[i]);

  9126     }

  9127   }

  9129   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) {

  9130     for (uint32_t i = 0, i_end = ArrayLength(paddingValues);

  9131          i < i_end; ++i) {

  9132       properties[nValues] = paddingValues[i];

  9133       values[nValues++] = ruleData.ValueFor(paddingValues[i]);

  9134     }

  9135   }

  9137   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) {

  9138     for (uint32_t i = 0, i_end = ArrayLength(textShadowValues);

  9139          i < i_end; ++i) {

  9140       properties[nValues] = textShadowValues[i];

  9141       values[nValues++] = ruleData.ValueFor(textShadowValues[i]);

  9142     }

  9143   }

  9145   nsStyleContext* styleContext = aStyleContext;

  9147   // We need to be careful not to count styles covered up by user-important or

  9148   // UA-important declarations.  But we do want to catch explicit inherit

  9149   // styling in those and check our parent style context to see whether we have

  9150   // user styling for those properties.  Note that we don't care here about

  9151   // inheritance due to lack of a specified value, since all the properties we

  9152   // care about are reset properties.

  9153   bool haveExplicitUAInherit;

  9154   do {

  9155     haveExplicitUAInherit = false;

  9156     for (nsRuleNode* ruleNode = styleContext->RuleNode(); ruleNode;

  9157          ruleNode = ruleNode->GetParent()) {

  9158       nsIStyleRule *rule = ruleNode->GetRule();

  9159       if (rule) {

  9160         ruleData.mLevel = ruleNode->GetLevel();

  9161         ruleData.mIsImportantRule = ruleNode->IsImportantRule();

  9163         rule->MapRuleInfoInto(&ruleData);

  9165         if (ruleData.mLevel == nsStyleSet::eAgentSheet ||

  9166             ruleData.mLevel == nsStyleSet::eUserSheet) {

  9167           // This is a rule whose effect we want to ignore, so if any of

  9168           // the properties we care about were set, set them to the dummy

  9169           // value that they'll never otherwise get.

  9170           for (uint32_t i = 0; i < nValues; ++i) {

  9171             nsCSSUnit unit = values[i]->GetUnit();

  9172             if (unit != eCSSUnit_Null &&

  9173                 unit != eCSSUnit_Dummy &&

  9174                 unit != eCSSUnit_DummyInherit) {

  9175               if (unit == eCSSUnit_Inherit ||

  9176                   (i >= inheritedOffset && unit == eCSSUnit_Unset)) {

  9177                 haveExplicitUAInherit = true;

  9178                 values[i]->SetDummyInheritValue();

  9179               } else {

  9180                 values[i]->SetDummyValue();

  9181               }

  9182             }

  9183           }

  9184         } else {

  9185           // If any of the values we care about was set by the above rule,

  9186           // we have author style.

  9187           for (uint32_t i = 0; i < nValues; ++i) {

  9188             if (values[i]->GetUnit() != eCSSUnit_Null &&

  9189                 values[i]->GetUnit() != eCSSUnit_Dummy && // see above

  9190                 values[i]->GetUnit() != eCSSUnit_DummyInherit) {

  9191               // If author colors are not allowed, only claim to have

  9192               // author-specified rules if we're looking at a non-color

  9193               // property or if we're looking at the background color and it's

  9194               // set to transparent.  Anything else should get set to a dummy

  9195               // value instead.

  9196               if (aAuthorColorsAllowed ||

  9197                   !nsCSSProps::PropHasFlags(properties[i],

  9198                      CSS_PROPERTY_IGNORED_WHEN_COLORS_DISABLED) ||

  9199                   (properties[i] == eCSSProperty_background_color &&

  9200                    !values[i]->IsNonTransparentColor())) {

  9201                 return true;

  9202               }

  9204               values[i]->SetDummyValue();

  9205             }

  9206           }

  9207         }

  9208       }

  9209     }

  9211     if (haveExplicitUAInherit) {

  9212       // reset all the eCSSUnit_Null values to eCSSUnit_Dummy (since they're

  9213       // not styled by the author, or by anyone else), and then reset all the

  9214       // eCSSUnit_DummyInherit values to eCSSUnit_Null (so we will be able to

  9215       // detect them being styled by the author) and move up to our parent

  9216       // style context.

  9217       for (uint32_t i = 0; i < nValues; ++i)

  9218         if (values[i]->GetUnit() == eCSSUnit_Null)

  9219           values[i]->SetDummyValue();

  9220       for (uint32_t i = 0; i < nValues; ++i)

  9221         if (values[i]->GetUnit() == eCSSUnit_DummyInherit)

  9222           values[i]->Reset();

  9223       styleContext = styleContext->GetParent();

  9224     }

  9225   } while (haveExplicitUAInherit && styleContext);

  9227   return false;

  9228 }

  9230 /* static */

  9231 bool

  9232 nsRuleNode::ComputeColor(const nsCSSValue& aValue, nsPresContext* aPresContext,

  9233                          nsStyleContext* aStyleContext, nscolor& aResult)

  9234 {

  9235   MOZ_ASSERT(aValue.GetUnit() != eCSSUnit_Inherit,

  9236              "aValue shouldn't have eCSSUnit_Inherit");

  9237   MOZ_ASSERT(aValue.GetUnit() != eCSSUnit_Initial,

  9238              "aValue shouldn't have eCSSUnit_Initial");

  9239   MOZ_ASSERT(aValue.GetUnit() != eCSSUnit_Unset,

  9240              "aValue shouldn't have eCSSUnit_Unset");

  9242   bool canStoreInRuleTree;

  9243   bool ok = SetColor(aValue, NS_RGB(0, 0, 0), aPresContext, aStyleContext,

  9244                      aResult, canStoreInRuleTree);

  9245   MOZ_ASSERT(ok || !(aPresContext && aStyleContext));

  9246   return ok;

  9247 }

The Tor Browser / file revision

layout/style/nsRuleNode.cpp@deefc01c0e14

layout/style/nsRuleNode.cpp