1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=2 et sw=2 tw=80: */
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/. */
6
7 /* representation of simple property values within CSS declarations */
8
9 #include "nsCSSValue.h"
10
11 #include "mozilla/StyleSheetInlines.h"
12 #include "mozilla/Likely.h"
13 #include "mozilla/MemoryReporting.h"
14 #include "mozilla/Move.h"
15 #include "mozilla/css/ImageLoader.h"
16 #include "CSSCalc.h"
17 #include "gfxFontConstants.h"
18 #include "imgIRequest.h"
19 #include "imgRequestProxy.h"
20 #include "nsIDocument.h"
21 #include "nsIPrincipal.h"
22 #include "nsCSSProps.h"
23 #include "nsNetUtil.h"
24 #include "nsPresContext.h"
25 #include "nsStyleUtil.h"
26 #include "nsDeviceContext.h"
27 #include "nsStyleSet.h"
28 #include "nsContentUtils.h"
29
30 using namespace mozilla;
31
32 static bool
IsLocalRefURL(nsStringBuffer * aString)33 IsLocalRefURL(nsStringBuffer* aString)
34 {
35 // Find the first non-"C0 controls + space" character.
36 char16_t* current = static_cast<char16_t*>(aString->Data());
37 for (; *current != '\0'; current++) {
38 if (*current > 0x20) {
39 // if the first non-"C0 controls + space" character is '#', this is a
40 // local-ref URL.
41 return *current == '#';
42 }
43 }
44
45 return false;
46 }
47
nsCSSValue(int32_t aValue,nsCSSUnit aUnit)48 nsCSSValue::nsCSSValue(int32_t aValue, nsCSSUnit aUnit)
49 : mUnit(aUnit)
50 {
51 MOZ_ASSERT(aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated ||
52 aUnit == eCSSUnit_EnumColor,
53 "not an int value");
54 if (aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated ||
55 aUnit == eCSSUnit_EnumColor) {
56 mValue.mInt = aValue;
57 }
58 else {
59 mUnit = eCSSUnit_Null;
60 mValue.mInt = 0;
61 }
62 }
63
nsCSSValue(float aValue,nsCSSUnit aUnit)64 nsCSSValue::nsCSSValue(float aValue, nsCSSUnit aUnit)
65 : mUnit(aUnit)
66 {
67 MOZ_ASSERT(eCSSUnit_Percent <= aUnit, "not a float value");
68 if (eCSSUnit_Percent <= aUnit) {
69 mValue.mFloat = aValue;
70 MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat));
71 }
72 else {
73 mUnit = eCSSUnit_Null;
74 mValue.mInt = 0;
75 }
76 }
77
nsCSSValue(const nsString & aValue,nsCSSUnit aUnit)78 nsCSSValue::nsCSSValue(const nsString& aValue, nsCSSUnit aUnit)
79 : mUnit(aUnit)
80 {
81 MOZ_ASSERT(UnitHasStringValue(), "not a string value");
82 if (UnitHasStringValue()) {
83 mValue.mString = BufferFromString(aValue).take();
84 }
85 else {
86 mUnit = eCSSUnit_Null;
87 mValue.mInt = 0;
88 }
89 }
90
nsCSSValue(nsCSSValue::Array * aValue,nsCSSUnit aUnit)91 nsCSSValue::nsCSSValue(nsCSSValue::Array* aValue, nsCSSUnit aUnit)
92 : mUnit(aUnit)
93 {
94 MOZ_ASSERT(UnitHasArrayValue(), "bad unit");
95 mValue.mArray = aValue;
96 mValue.mArray->AddRef();
97 }
98
nsCSSValue(mozilla::css::URLValue * aValue)99 nsCSSValue::nsCSSValue(mozilla::css::URLValue* aValue)
100 : mUnit(eCSSUnit_URL)
101 {
102 mValue.mURL = aValue;
103 mValue.mURL->AddRef();
104 }
105
nsCSSValue(mozilla::css::ImageValue * aValue)106 nsCSSValue::nsCSSValue(mozilla::css::ImageValue* aValue)
107 : mUnit(eCSSUnit_Image)
108 {
109 mValue.mImage = aValue;
110 mValue.mImage->AddRef();
111 }
112
nsCSSValue(nsCSSValueGradient * aValue)113 nsCSSValue::nsCSSValue(nsCSSValueGradient* aValue)
114 : mUnit(eCSSUnit_Gradient)
115 {
116 mValue.mGradient = aValue;
117 mValue.mGradient->AddRef();
118 }
119
nsCSSValue(nsCSSValueTokenStream * aValue)120 nsCSSValue::nsCSSValue(nsCSSValueTokenStream* aValue)
121 : mUnit(eCSSUnit_TokenStream)
122 {
123 mValue.mTokenStream = aValue;
124 mValue.mTokenStream->AddRef();
125 }
126
nsCSSValue(mozilla::css::GridTemplateAreasValue * aValue)127 nsCSSValue::nsCSSValue(mozilla::css::GridTemplateAreasValue* aValue)
128 : mUnit(eCSSUnit_GridTemplateAreas)
129 {
130 mValue.mGridTemplateAreas = aValue;
131 mValue.mGridTemplateAreas->AddRef();
132 }
133
nsCSSValue(css::FontFamilyListRefCnt * aValue)134 nsCSSValue::nsCSSValue(css::FontFamilyListRefCnt* aValue)
135 : mUnit(eCSSUnit_FontFamilyList)
136 {
137 mValue.mFontFamilyList = aValue;
138 mValue.mFontFamilyList->AddRef();
139 }
140
nsCSSValue(const nsCSSValue & aCopy)141 nsCSSValue::nsCSSValue(const nsCSSValue& aCopy)
142 : mUnit(aCopy.mUnit)
143 {
144 if (mUnit <= eCSSUnit_DummyInherit) {
145 // nothing to do, but put this important case first
146 }
147 else if (eCSSUnit_Percent <= mUnit) {
148 mValue.mFloat = aCopy.mValue.mFloat;
149 MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat));
150 }
151 else if (UnitHasStringValue()) {
152 mValue.mString = aCopy.mValue.mString;
153 mValue.mString->AddRef();
154 }
155 else if (eCSSUnit_Integer <= mUnit && mUnit <= eCSSUnit_EnumColor) {
156 mValue.mInt = aCopy.mValue.mInt;
157 }
158 else if (IsIntegerColorUnit()) {
159 mValue.mColor = aCopy.mValue.mColor;
160 }
161 else if (IsFloatColorUnit()) {
162 mValue.mFloatColor = aCopy.mValue.mFloatColor;
163 mValue.mFloatColor->AddRef();
164 }
165 else if (eCSSUnit_ComplexColor == mUnit) {
166 mValue.mComplexColor = aCopy.mValue.mComplexColor;
167 mValue.mComplexColor->AddRef();
168 }
169 else if (UnitHasArrayValue()) {
170 mValue.mArray = aCopy.mValue.mArray;
171 mValue.mArray->AddRef();
172 }
173 else if (eCSSUnit_URL == mUnit) {
174 mValue.mURL = aCopy.mValue.mURL;
175 mValue.mURL->AddRef();
176 }
177 else if (eCSSUnit_Image == mUnit) {
178 mValue.mImage = aCopy.mValue.mImage;
179 mValue.mImage->AddRef();
180 }
181 else if (eCSSUnit_Gradient == mUnit) {
182 mValue.mGradient = aCopy.mValue.mGradient;
183 mValue.mGradient->AddRef();
184 }
185 else if (eCSSUnit_TokenStream == mUnit) {
186 mValue.mTokenStream = aCopy.mValue.mTokenStream;
187 mValue.mTokenStream->AddRef();
188 }
189 else if (eCSSUnit_Pair == mUnit) {
190 mValue.mPair = aCopy.mValue.mPair;
191 mValue.mPair->AddRef();
192 }
193 else if (eCSSUnit_Triplet == mUnit) {
194 mValue.mTriplet = aCopy.mValue.mTriplet;
195 mValue.mTriplet->AddRef();
196 }
197 else if (eCSSUnit_Rect == mUnit) {
198 mValue.mRect = aCopy.mValue.mRect;
199 mValue.mRect->AddRef();
200 }
201 else if (eCSSUnit_List == mUnit) {
202 mValue.mList = aCopy.mValue.mList;
203 mValue.mList->AddRef();
204 }
205 else if (eCSSUnit_ListDep == mUnit) {
206 mValue.mListDependent = aCopy.mValue.mListDependent;
207 }
208 else if (eCSSUnit_SharedList == mUnit) {
209 mValue.mSharedList = aCopy.mValue.mSharedList;
210 mValue.mSharedList->AddRef();
211 }
212 else if (eCSSUnit_PairList == mUnit) {
213 mValue.mPairList = aCopy.mValue.mPairList;
214 mValue.mPairList->AddRef();
215 }
216 else if (eCSSUnit_PairListDep == mUnit) {
217 mValue.mPairListDependent = aCopy.mValue.mPairListDependent;
218 }
219 else if (eCSSUnit_GridTemplateAreas == mUnit) {
220 mValue.mGridTemplateAreas = aCopy.mValue.mGridTemplateAreas;
221 mValue.mGridTemplateAreas->AddRef();
222 }
223 else if (eCSSUnit_FontFamilyList == mUnit) {
224 mValue.mFontFamilyList = aCopy.mValue.mFontFamilyList;
225 mValue.mFontFamilyList->AddRef();
226 }
227 else {
228 MOZ_ASSERT(false, "unknown unit");
229 }
230 }
231
operator =(const nsCSSValue & aCopy)232 nsCSSValue& nsCSSValue::operator=(const nsCSSValue& aCopy)
233 {
234 if (this != &aCopy) {
235 Reset();
236 new (this) nsCSSValue(aCopy);
237 }
238 return *this;
239 }
240
241 nsCSSValue&
operator =(nsCSSValue && aOther)242 nsCSSValue::operator=(nsCSSValue&& aOther)
243 {
244 MOZ_ASSERT(this != &aOther, "Self assigment with rvalue reference");
245
246 Reset();
247 mUnit = aOther.mUnit;
248 mValue = aOther.mValue;
249 aOther.mUnit = eCSSUnit_Null;
250
251 return *this;
252 }
253
operator ==(const nsCSSValue & aOther) const254 bool nsCSSValue::operator==(const nsCSSValue& aOther) const
255 {
256 MOZ_ASSERT(mUnit != eCSSUnit_ListDep &&
257 aOther.mUnit != eCSSUnit_ListDep &&
258 mUnit != eCSSUnit_PairListDep &&
259 aOther.mUnit != eCSSUnit_PairListDep,
260 "don't use operator== with dependent lists");
261
262 if (mUnit == aOther.mUnit) {
263 if (mUnit <= eCSSUnit_DummyInherit) {
264 return true;
265 }
266 else if (UnitHasStringValue()) {
267 return (NS_strcmp(GetBufferValue(mValue.mString),
268 GetBufferValue(aOther.mValue.mString)) == 0);
269 }
270 else if ((eCSSUnit_Integer <= mUnit) && (mUnit <= eCSSUnit_EnumColor)) {
271 return mValue.mInt == aOther.mValue.mInt;
272 }
273 else if (IsIntegerColorUnit()) {
274 return mValue.mColor == aOther.mValue.mColor;
275 }
276 else if (IsFloatColorUnit()) {
277 return *mValue.mFloatColor == *aOther.mValue.mFloatColor;
278 }
279 else if (eCSSUnit_ComplexColor == mUnit) {
280 return *mValue.mComplexColor == *aOther.mValue.mComplexColor;
281 }
282 else if (UnitHasArrayValue()) {
283 return *mValue.mArray == *aOther.mValue.mArray;
284 }
285 else if (eCSSUnit_URL == mUnit) {
286 return mValue.mURL->Equals(*aOther.mValue.mURL);
287 }
288 else if (eCSSUnit_Image == mUnit) {
289 return mValue.mImage->Equals(*aOther.mValue.mImage);
290 }
291 else if (eCSSUnit_Gradient == mUnit) {
292 return *mValue.mGradient == *aOther.mValue.mGradient;
293 }
294 else if (eCSSUnit_TokenStream == mUnit) {
295 return *mValue.mTokenStream == *aOther.mValue.mTokenStream;
296 }
297 else if (eCSSUnit_Pair == mUnit) {
298 return *mValue.mPair == *aOther.mValue.mPair;
299 }
300 else if (eCSSUnit_Triplet == mUnit) {
301 return *mValue.mTriplet == *aOther.mValue.mTriplet;
302 }
303 else if (eCSSUnit_Rect == mUnit) {
304 return *mValue.mRect == *aOther.mValue.mRect;
305 }
306 else if (eCSSUnit_List == mUnit) {
307 return nsCSSValueList::Equal(mValue.mList, aOther.mValue.mList);
308 }
309 else if (eCSSUnit_SharedList == mUnit) {
310 return *mValue.mSharedList == *aOther.mValue.mSharedList;
311 }
312 else if (eCSSUnit_PairList == mUnit) {
313 return nsCSSValuePairList::Equal(mValue.mPairList,
314 aOther.mValue.mPairList);
315 }
316 else if (eCSSUnit_GridTemplateAreas == mUnit) {
317 return *mValue.mGridTemplateAreas == *aOther.mValue.mGridTemplateAreas;
318 }
319 else if (eCSSUnit_FontFamilyList == mUnit) {
320 return *mValue.mFontFamilyList == *aOther.mValue.mFontFamilyList;
321 }
322 else {
323 return mValue.mFloat == aOther.mValue.mFloat;
324 }
325 }
326 return false;
327 }
328
329 double
GetAngleValueInRadians() const330 nsCSSValue::GetAngleValueInRadians() const
331 {
332 double angle = GetFloatValue();
333
334 switch (GetUnit()) {
335 case eCSSUnit_Radian: return angle;
336 case eCSSUnit_Turn: return angle * 2 * M_PI;
337 case eCSSUnit_Degree: return angle * M_PI / 180.0;
338 case eCSSUnit_Grad: return angle * M_PI / 200.0;
339
340 default:
341 MOZ_ASSERT(false, "unrecognized angular unit");
342 return 0.0;
343 }
344 }
345
346 double
GetAngleValueInDegrees() const347 nsCSSValue::GetAngleValueInDegrees() const
348 {
349 double angle = GetFloatValue();
350
351 switch (GetUnit()) {
352 case eCSSUnit_Degree: return angle;
353 case eCSSUnit_Grad: return angle * 0.9; // grad / 400 * 360
354 case eCSSUnit_Radian: return angle * 180.0 / M_PI; // rad / 2pi * 360
355 case eCSSUnit_Turn: return angle * 360.0;
356
357 default:
358 MOZ_ASSERT(false, "unrecognized angular unit");
359 return 0.0;
360 }
361 }
362
GetImageValue(nsIDocument * aDocument) const363 imgRequestProxy* nsCSSValue::GetImageValue(nsIDocument* aDocument) const
364 {
365 MOZ_ASSERT(mUnit == eCSSUnit_Image, "not an Image value");
366 return mValue.mImage->mRequests.GetWeak(aDocument);
367 }
368
369 already_AddRefed<imgRequestProxy>
GetPossiblyStaticImageValue(nsIDocument * aDocument,nsPresContext * aPresContext) const370 nsCSSValue::GetPossiblyStaticImageValue(nsIDocument* aDocument,
371 nsPresContext* aPresContext) const
372 {
373 imgRequestProxy* req = GetImageValue(aDocument);
374 if (aPresContext->IsDynamic()) {
375 return do_AddRef(req);
376 }
377 return nsContentUtils::GetStaticRequest(req);
378 }
379
GetFixedLength(nsPresContext * aPresContext) const380 nscoord nsCSSValue::GetFixedLength(nsPresContext* aPresContext) const
381 {
382 MOZ_ASSERT(mUnit == eCSSUnit_PhysicalMillimeter,
383 "not a fixed length unit");
384
385 float inches = mValue.mFloat / MM_PER_INCH_FLOAT;
386 return NSToCoordFloorClamped(inches *
387 float(aPresContext->DeviceContext()->AppUnitsPerPhysicalInch()));
388 }
389
GetPixelLength() const390 nscoord nsCSSValue::GetPixelLength() const
391 {
392 MOZ_ASSERT(IsPixelLengthUnit(), "not a fixed length unit");
393
394 double scaleFactor;
395 switch (mUnit) {
396 case eCSSUnit_Pixel: return nsPresContext::CSSPixelsToAppUnits(mValue.mFloat);
397 case eCSSUnit_Pica: scaleFactor = 16.0; break;
398 case eCSSUnit_Point: scaleFactor = 4/3.0; break;
399 case eCSSUnit_Inch: scaleFactor = 96.0; break;
400 case eCSSUnit_Millimeter: scaleFactor = 96/25.4; break;
401 case eCSSUnit_Centimeter: scaleFactor = 96/2.54; break;
402 case eCSSUnit_Quarter: scaleFactor = 96/101.6; break;
403 default:
404 NS_ERROR("should never get here");
405 return 0;
406 }
407 return nsPresContext::CSSPixelsToAppUnits(float(mValue.mFloat*scaleFactor));
408 }
409
DoReset()410 void nsCSSValue::DoReset()
411 {
412 if (UnitHasStringValue()) {
413 mValue.mString->Release();
414 } else if (IsFloatColorUnit()) {
415 mValue.mFloatColor->Release();
416 } else if (eCSSUnit_ComplexColor == mUnit) {
417 mValue.mComplexColor->Release();
418 } else if (UnitHasArrayValue()) {
419 mValue.mArray->Release();
420 } else if (eCSSUnit_URL == mUnit) {
421 mValue.mURL->Release();
422 } else if (eCSSUnit_Image == mUnit) {
423 mValue.mImage->Release();
424 } else if (eCSSUnit_Gradient == mUnit) {
425 mValue.mGradient->Release();
426 } else if (eCSSUnit_TokenStream == mUnit) {
427 mValue.mTokenStream->Release();
428 } else if (eCSSUnit_Pair == mUnit) {
429 mValue.mPair->Release();
430 } else if (eCSSUnit_Triplet == mUnit) {
431 mValue.mTriplet->Release();
432 } else if (eCSSUnit_Rect == mUnit) {
433 mValue.mRect->Release();
434 } else if (eCSSUnit_List == mUnit) {
435 mValue.mList->Release();
436 } else if (eCSSUnit_SharedList == mUnit) {
437 mValue.mSharedList->Release();
438 } else if (eCSSUnit_PairList == mUnit) {
439 mValue.mPairList->Release();
440 } else if (eCSSUnit_GridTemplateAreas == mUnit) {
441 mValue.mGridTemplateAreas->Release();
442 } else if (eCSSUnit_FontFamilyList == mUnit) {
443 mValue.mFontFamilyList->Release();
444 }
445 mUnit = eCSSUnit_Null;
446 }
447
SetIntValue(int32_t aValue,nsCSSUnit aUnit)448 void nsCSSValue::SetIntValue(int32_t aValue, nsCSSUnit aUnit)
449 {
450 MOZ_ASSERT(aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated ||
451 aUnit == eCSSUnit_EnumColor,
452 "not an int value");
453 Reset();
454 if (aUnit == eCSSUnit_Integer || aUnit == eCSSUnit_Enumerated ||
455 aUnit == eCSSUnit_EnumColor) {
456 mUnit = aUnit;
457 mValue.mInt = aValue;
458 }
459 }
460
SetPercentValue(float aValue)461 void nsCSSValue::SetPercentValue(float aValue)
462 {
463 Reset();
464 mUnit = eCSSUnit_Percent;
465 mValue.mFloat = aValue;
466 MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat));
467 }
468
SetFloatValue(float aValue,nsCSSUnit aUnit)469 void nsCSSValue::SetFloatValue(float aValue, nsCSSUnit aUnit)
470 {
471 MOZ_ASSERT(IsFloatUnit(aUnit), "not a float value");
472 Reset();
473 if (IsFloatUnit(aUnit)) {
474 mUnit = aUnit;
475 mValue.mFloat = aValue;
476 MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat));
477 }
478 }
479
SetStringValue(const nsString & aValue,nsCSSUnit aUnit)480 void nsCSSValue::SetStringValue(const nsString& aValue,
481 nsCSSUnit aUnit)
482 {
483 Reset();
484 mUnit = aUnit;
485 MOZ_ASSERT(UnitHasStringValue(), "not a string unit");
486 if (UnitHasStringValue()) {
487 mValue.mString = BufferFromString(aValue).take();
488 } else
489 mUnit = eCSSUnit_Null;
490 }
491
SetColorValue(nscolor aValue)492 void nsCSSValue::SetColorValue(nscolor aValue)
493 {
494 SetIntegerColorValue(aValue, eCSSUnit_RGBAColor);
495 }
496
497
498
SetIntegerColorValue(nscolor aValue,nsCSSUnit aUnit)499 void nsCSSValue::SetIntegerColorValue(nscolor aValue, nsCSSUnit aUnit)
500 {
501 Reset();
502 mUnit = aUnit;
503 MOZ_ASSERT(IsIntegerColorUnit(), "bad unit");
504 mValue.mColor = aValue;
505 }
506
SetIntegerCoordValue(nscoord aValue)507 void nsCSSValue::SetIntegerCoordValue(nscoord aValue)
508 {
509 SetFloatValue(nsPresContext::AppUnitsToFloatCSSPixels(aValue),
510 eCSSUnit_Pixel);
511 }
512
SetFloatColorValue(float aComponent1,float aComponent2,float aComponent3,float aAlpha,nsCSSUnit aUnit)513 void nsCSSValue::SetFloatColorValue(float aComponent1,
514 float aComponent2,
515 float aComponent3,
516 float aAlpha,
517 nsCSSUnit aUnit)
518 {
519 Reset();
520 mUnit = aUnit;
521 MOZ_ASSERT(IsFloatColorUnit(), "bad unit");
522 mValue.mFloatColor =
523 new nsCSSValueFloatColor(aComponent1, aComponent2, aComponent3, aAlpha);
524 mValue.mFloatColor->AddRef();
525 }
526
527 void
SetRGBAColorValue(const RGBAColorData & aValue)528 nsCSSValue::SetRGBAColorValue(const RGBAColorData& aValue)
529 {
530 SetFloatColorValue(aValue.mR, aValue.mG, aValue.mB,
531 aValue.mA, eCSSUnit_PercentageRGBAColor);
532 }
533
534 void
SetComplexColorValue(already_AddRefed<ComplexColorValue> aValue)535 nsCSSValue::SetComplexColorValue(already_AddRefed<ComplexColorValue> aValue)
536 {
537 Reset();
538 mUnit = eCSSUnit_ComplexColor;
539 mValue.mComplexColor = aValue.take();
540 }
541
SetArrayValue(nsCSSValue::Array * aValue,nsCSSUnit aUnit)542 void nsCSSValue::SetArrayValue(nsCSSValue::Array* aValue, nsCSSUnit aUnit)
543 {
544 Reset();
545 mUnit = aUnit;
546 MOZ_ASSERT(UnitHasArrayValue(), "bad unit");
547 mValue.mArray = aValue;
548 mValue.mArray->AddRef();
549 }
550
SetURLValue(mozilla::css::URLValue * aValue)551 void nsCSSValue::SetURLValue(mozilla::css::URLValue* aValue)
552 {
553 Reset();
554 mUnit = eCSSUnit_URL;
555 mValue.mURL = aValue;
556 mValue.mURL->AddRef();
557 }
558
SetImageValue(mozilla::css::ImageValue * aValue)559 void nsCSSValue::SetImageValue(mozilla::css::ImageValue* aValue)
560 {
561 Reset();
562 mUnit = eCSSUnit_Image;
563 mValue.mImage = aValue;
564 mValue.mImage->AddRef();
565 }
566
SetGradientValue(nsCSSValueGradient * aValue)567 void nsCSSValue::SetGradientValue(nsCSSValueGradient* aValue)
568 {
569 Reset();
570 mUnit = eCSSUnit_Gradient;
571 mValue.mGradient = aValue;
572 mValue.mGradient->AddRef();
573 }
574
SetTokenStreamValue(nsCSSValueTokenStream * aValue)575 void nsCSSValue::SetTokenStreamValue(nsCSSValueTokenStream* aValue)
576 {
577 Reset();
578 mUnit = eCSSUnit_TokenStream;
579 mValue.mTokenStream = aValue;
580 mValue.mTokenStream->AddRef();
581 }
582
SetGridTemplateAreas(mozilla::css::GridTemplateAreasValue * aValue)583 void nsCSSValue::SetGridTemplateAreas(mozilla::css::GridTemplateAreasValue* aValue)
584 {
585 Reset();
586 mUnit = eCSSUnit_GridTemplateAreas;
587 mValue.mGridTemplateAreas = aValue;
588 mValue.mGridTemplateAreas->AddRef();
589 }
590
SetFontFamilyListValue(css::FontFamilyListRefCnt * aValue)591 void nsCSSValue::SetFontFamilyListValue(css::FontFamilyListRefCnt* aValue)
592 {
593 Reset();
594 mUnit = eCSSUnit_FontFamilyList;
595 mValue.mFontFamilyList = aValue;
596 mValue.mFontFamilyList->AddRef();
597 }
598
SetPairValue(const nsCSSValuePair * aValue)599 void nsCSSValue::SetPairValue(const nsCSSValuePair* aValue)
600 {
601 // pairs should not be used for null/inherit/initial values
602 MOZ_ASSERT(aValue &&
603 aValue->mXValue.GetUnit() != eCSSUnit_Null &&
604 aValue->mYValue.GetUnit() != eCSSUnit_Null &&
605 aValue->mXValue.GetUnit() != eCSSUnit_Inherit &&
606 aValue->mYValue.GetUnit() != eCSSUnit_Inherit &&
607 aValue->mXValue.GetUnit() != eCSSUnit_Initial &&
608 aValue->mYValue.GetUnit() != eCSSUnit_Initial &&
609 aValue->mXValue.GetUnit() != eCSSUnit_Unset &&
610 aValue->mYValue.GetUnit() != eCSSUnit_Unset,
611 "missing or inappropriate pair value");
612 Reset();
613 mUnit = eCSSUnit_Pair;
614 mValue.mPair = new nsCSSValuePair_heap(aValue->mXValue, aValue->mYValue);
615 mValue.mPair->AddRef();
616 }
617
SetPairValue(const nsCSSValue & xValue,const nsCSSValue & yValue)618 void nsCSSValue::SetPairValue(const nsCSSValue& xValue,
619 const nsCSSValue& yValue)
620 {
621 MOZ_ASSERT(xValue.GetUnit() != eCSSUnit_Null &&
622 yValue.GetUnit() != eCSSUnit_Null &&
623 xValue.GetUnit() != eCSSUnit_Inherit &&
624 yValue.GetUnit() != eCSSUnit_Inherit &&
625 xValue.GetUnit() != eCSSUnit_Initial &&
626 yValue.GetUnit() != eCSSUnit_Initial &&
627 xValue.GetUnit() != eCSSUnit_Unset &&
628 yValue.GetUnit() != eCSSUnit_Unset,
629 "inappropriate pair value");
630 Reset();
631 mUnit = eCSSUnit_Pair;
632 mValue.mPair = new nsCSSValuePair_heap(xValue, yValue);
633 mValue.mPair->AddRef();
634 }
635
SetTripletValue(const nsCSSValueTriplet * aValue)636 void nsCSSValue::SetTripletValue(const nsCSSValueTriplet* aValue)
637 {
638 // triplet should not be used for null/inherit/initial values
639 MOZ_ASSERT(aValue &&
640 aValue->mXValue.GetUnit() != eCSSUnit_Null &&
641 aValue->mYValue.GetUnit() != eCSSUnit_Null &&
642 aValue->mZValue.GetUnit() != eCSSUnit_Null &&
643 aValue->mXValue.GetUnit() != eCSSUnit_Inherit &&
644 aValue->mYValue.GetUnit() != eCSSUnit_Inherit &&
645 aValue->mZValue.GetUnit() != eCSSUnit_Inherit &&
646 aValue->mXValue.GetUnit() != eCSSUnit_Initial &&
647 aValue->mYValue.GetUnit() != eCSSUnit_Initial &&
648 aValue->mZValue.GetUnit() != eCSSUnit_Initial &&
649 aValue->mXValue.GetUnit() != eCSSUnit_Unset &&
650 aValue->mYValue.GetUnit() != eCSSUnit_Unset &&
651 aValue->mZValue.GetUnit() != eCSSUnit_Unset,
652 "missing or inappropriate triplet value");
653 Reset();
654 mUnit = eCSSUnit_Triplet;
655 mValue.mTriplet = new nsCSSValueTriplet_heap(aValue->mXValue, aValue->mYValue, aValue->mZValue);
656 mValue.mTriplet->AddRef();
657 }
658
SetTripletValue(const nsCSSValue & xValue,const nsCSSValue & yValue,const nsCSSValue & zValue)659 void nsCSSValue::SetTripletValue(const nsCSSValue& xValue,
660 const nsCSSValue& yValue,
661 const nsCSSValue& zValue)
662 {
663 // Only allow Null for the z component
664 MOZ_ASSERT(xValue.GetUnit() != eCSSUnit_Null &&
665 yValue.GetUnit() != eCSSUnit_Null &&
666 xValue.GetUnit() != eCSSUnit_Inherit &&
667 yValue.GetUnit() != eCSSUnit_Inherit &&
668 zValue.GetUnit() != eCSSUnit_Inherit &&
669 xValue.GetUnit() != eCSSUnit_Initial &&
670 yValue.GetUnit() != eCSSUnit_Initial &&
671 zValue.GetUnit() != eCSSUnit_Initial &&
672 xValue.GetUnit() != eCSSUnit_Unset &&
673 yValue.GetUnit() != eCSSUnit_Unset &&
674 zValue.GetUnit() != eCSSUnit_Unset,
675 "inappropriate triplet value");
676 Reset();
677 mUnit = eCSSUnit_Triplet;
678 mValue.mTriplet = new nsCSSValueTriplet_heap(xValue, yValue, zValue);
679 mValue.mTriplet->AddRef();
680 }
681
SetRectValue()682 nsCSSRect& nsCSSValue::SetRectValue()
683 {
684 Reset();
685 mUnit = eCSSUnit_Rect;
686 mValue.mRect = new nsCSSRect_heap;
687 mValue.mRect->AddRef();
688 return *mValue.mRect;
689 }
690
SetListValue()691 nsCSSValueList* nsCSSValue::SetListValue()
692 {
693 Reset();
694 mUnit = eCSSUnit_List;
695 mValue.mList = new nsCSSValueList_heap;
696 mValue.mList->AddRef();
697 return mValue.mList;
698 }
699
SetSharedListValue(nsCSSValueSharedList * aList)700 void nsCSSValue::SetSharedListValue(nsCSSValueSharedList* aList)
701 {
702 Reset();
703 mUnit = eCSSUnit_SharedList;
704 mValue.mSharedList = aList;
705 mValue.mSharedList->AddRef();
706 }
707
SetDependentListValue(nsCSSValueList * aList)708 void nsCSSValue::SetDependentListValue(nsCSSValueList* aList)
709 {
710 Reset();
711 if (aList) {
712 mUnit = eCSSUnit_ListDep;
713 mValue.mListDependent = aList;
714 }
715 }
716
717 void
AdoptListValue(UniquePtr<nsCSSValueList> aValue)718 nsCSSValue::AdoptListValue(UniquePtr<nsCSSValueList> aValue)
719 {
720 // We have to copy the first element since for owned lists the first
721 // element should be an nsCSSValueList_heap object.
722 SetListValue();
723 mValue.mList->mValue = Move(aValue->mValue);
724 mValue.mList->mNext = aValue->mNext;
725 aValue->mNext = nullptr;
726 aValue.reset();
727 }
728
SetPairListValue()729 nsCSSValuePairList* nsCSSValue::SetPairListValue()
730 {
731 Reset();
732 mUnit = eCSSUnit_PairList;
733 mValue.mPairList = new nsCSSValuePairList_heap;
734 mValue.mPairList->AddRef();
735 return mValue.mPairList;
736 }
737
SetDependentPairListValue(nsCSSValuePairList * aList)738 void nsCSSValue::SetDependentPairListValue(nsCSSValuePairList* aList)
739 {
740 Reset();
741 if (aList) {
742 mUnit = eCSSUnit_PairListDep;
743 mValue.mPairListDependent = aList;
744 }
745 }
746
747 void
AdoptPairListValue(UniquePtr<nsCSSValuePairList> aValue)748 nsCSSValue::AdoptPairListValue(UniquePtr<nsCSSValuePairList> aValue)
749 {
750 // We have to copy the first element, since for owned pair lists, the first
751 // element should be an nsCSSValuePairList_heap object.
752 SetPairListValue();
753 mValue.mPairList->mXValue = Move(aValue->mXValue);
754 mValue.mPairList->mYValue = Move(aValue->mYValue);
755 mValue.mPairList->mNext = aValue->mNext;
756 aValue->mNext = nullptr;
757 aValue.reset();
758 }
759
SetAutoValue()760 void nsCSSValue::SetAutoValue()
761 {
762 Reset();
763 mUnit = eCSSUnit_Auto;
764 }
765
SetInheritValue()766 void nsCSSValue::SetInheritValue()
767 {
768 Reset();
769 mUnit = eCSSUnit_Inherit;
770 }
771
SetInitialValue()772 void nsCSSValue::SetInitialValue()
773 {
774 Reset();
775 mUnit = eCSSUnit_Initial;
776 }
777
SetUnsetValue()778 void nsCSSValue::SetUnsetValue()
779 {
780 Reset();
781 mUnit = eCSSUnit_Unset;
782 }
783
SetNoneValue()784 void nsCSSValue::SetNoneValue()
785 {
786 Reset();
787 mUnit = eCSSUnit_None;
788 }
789
SetAllValue()790 void nsCSSValue::SetAllValue()
791 {
792 Reset();
793 mUnit = eCSSUnit_All;
794 }
795
SetNormalValue()796 void nsCSSValue::SetNormalValue()
797 {
798 Reset();
799 mUnit = eCSSUnit_Normal;
800 }
801
SetSystemFontValue()802 void nsCSSValue::SetSystemFontValue()
803 {
804 Reset();
805 mUnit = eCSSUnit_System_Font;
806 }
807
SetDummyValue()808 void nsCSSValue::SetDummyValue()
809 {
810 Reset();
811 mUnit = eCSSUnit_Dummy;
812 }
813
SetDummyInheritValue()814 void nsCSSValue::SetDummyInheritValue()
815 {
816 Reset();
817 mUnit = eCSSUnit_DummyInherit;
818 }
819
SetCalcValue(const nsStyleCoord::CalcValue * aCalc)820 void nsCSSValue::SetCalcValue(const nsStyleCoord::CalcValue* aCalc)
821 {
822 RefPtr<nsCSSValue::Array> arr = nsCSSValue::Array::Create(1);
823 if (!aCalc->mHasPercent) {
824 arr->Item(0).SetIntegerCoordValue(aCalc->mLength);
825 } else {
826 nsCSSValue::Array *arr2 = nsCSSValue::Array::Create(2);
827 arr->Item(0).SetArrayValue(arr2, eCSSUnit_Calc_Plus);
828 arr2->Item(0).SetIntegerCoordValue(aCalc->mLength);
829 arr2->Item(1).SetPercentValue(aCalc->mPercent);
830 }
831
832 SetArrayValue(arr, eCSSUnit_Calc);
833 }
834
StartImageLoad(nsIDocument * aDocument) const835 void nsCSSValue::StartImageLoad(nsIDocument* aDocument) const
836 {
837 MOZ_ASSERT(eCSSUnit_URL == mUnit, "Not a URL value!");
838 mozilla::css::ImageValue* image =
839 new mozilla::css::ImageValue(mValue.mURL->GetURI(),
840 mValue.mURL->mString,
841 mValue.mURL->mBaseURI,
842 mValue.mURL->mReferrer,
843 mValue.mURL->mOriginPrincipal,
844 aDocument);
845
846 nsCSSValue* writable = const_cast<nsCSSValue*>(this);
847 writable->SetImageValue(image);
848 }
849
GetColorValue() const850 nscolor nsCSSValue::GetColorValue() const
851 {
852 MOZ_ASSERT(IsNumericColorUnit(), "not a color value");
853 if (IsFloatColorUnit()) {
854 return mValue.mFloatColor->GetColorValue(mUnit);
855 }
856 return mValue.mColor;
857 }
858
IsNonTransparentColor() const859 bool nsCSSValue::IsNonTransparentColor() const
860 {
861 // We have the value in the form it was specified in at this point, so we
862 // have to look for both the keyword 'transparent' and its equivalent in
863 // rgba notation.
864 nsDependentString buf;
865 return
866 (IsIntegerColorUnit() && NS_GET_A(GetColorValue()) > 0) ||
867 (IsFloatColorUnit() && mValue.mFloatColor->IsNonTransparentColor()) ||
868 (mUnit == eCSSUnit_Ident &&
869 !nsGkAtoms::transparent->Equals(GetStringValue(buf))) ||
870 (mUnit == eCSSUnit_EnumColor);
871 }
872
873 nsCSSValue::Array*
InitFunction(nsCSSKeyword aFunctionId,uint32_t aNumArgs)874 nsCSSValue::InitFunction(nsCSSKeyword aFunctionId, uint32_t aNumArgs)
875 {
876 RefPtr<nsCSSValue::Array> func = Array::Create(aNumArgs + 1);
877 func->Item(0).SetIntValue(aFunctionId, eCSSUnit_Enumerated);
878 SetArrayValue(func, eCSSUnit_Function);
879 return func;
880 }
881
882 bool
EqualsFunction(nsCSSKeyword aFunctionId) const883 nsCSSValue::EqualsFunction(nsCSSKeyword aFunctionId) const
884 {
885 if (mUnit != eCSSUnit_Function) {
886 return false;
887 }
888
889 nsCSSValue::Array* func = mValue.mArray;
890 MOZ_ASSERT(func && func->Count() >= 1 &&
891 func->Item(0).GetUnit() == eCSSUnit_Enumerated,
892 "illegally structured function value");
893
894 nsCSSKeyword thisFunctionId = func->Item(0).GetKeywordValue();
895 return thisFunctionId == aFunctionId;
896 }
897
898 // static
899 already_AddRefed<nsStringBuffer>
BufferFromString(const nsString & aValue)900 nsCSSValue::BufferFromString(const nsString& aValue)
901 {
902 RefPtr<nsStringBuffer> buffer = nsStringBuffer::FromString(aValue);
903 if (buffer) {
904 return buffer.forget();
905 }
906
907 nsString::size_type length = aValue.Length();
908
909 // NOTE: Alloc prouduces a new, already-addref'd (refcnt = 1) buffer.
910 // NOTE: String buffer allocation is currently fallible.
911 size_t sz = (length + 1) * sizeof(char16_t);
912 buffer = nsStringBuffer::Alloc(sz);
913 if (MOZ_UNLIKELY(!buffer)) {
914 NS_ABORT_OOM(sz);
915 }
916
917 char16_t* data = static_cast<char16_t*>(buffer->Data());
918 nsCharTraits<char16_t>::copy(data, aValue.get(), length);
919 // Null-terminate.
920 data[length] = 0;
921 return buffer.forget();
922 }
923
924 namespace {
925
926 struct CSSValueSerializeCalcOps {
CSSValueSerializeCalcOps__anon723e434b0111::CSSValueSerializeCalcOps927 CSSValueSerializeCalcOps(nsCSSPropertyID aProperty, nsAString& aResult,
928 nsCSSValue::Serialization aSerialization)
929 : mProperty(aProperty),
930 mResult(aResult),
931 mValueSerialization(aSerialization)
932 {
933 }
934
935 typedef nsCSSValue input_type;
936 typedef nsCSSValue::Array input_array_type;
937
GetUnit__anon723e434b0111::CSSValueSerializeCalcOps938 static nsCSSUnit GetUnit(const input_type& aValue) {
939 return aValue.GetUnit();
940 }
941
Append__anon723e434b0111::CSSValueSerializeCalcOps942 void Append(const char* aString)
943 {
944 mResult.AppendASCII(aString);
945 }
946
AppendLeafValue__anon723e434b0111::CSSValueSerializeCalcOps947 void AppendLeafValue(const input_type& aValue)
948 {
949 MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Percent ||
950 aValue.IsLengthUnit() ||
951 aValue.GetUnit() == eCSSUnit_Number,
952 "unexpected unit");
953 aValue.AppendToString(mProperty, mResult, mValueSerialization);
954 }
955
AppendNumber__anon723e434b0111::CSSValueSerializeCalcOps956 void AppendNumber(const input_type& aValue)
957 {
958 MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Number, "unexpected unit");
959 aValue.AppendToString(mProperty, mResult, mValueSerialization);
960 }
961
962 private:
963 nsCSSPropertyID mProperty;
964 nsAString &mResult;
965 nsCSSValue::Serialization mValueSerialization;
966 };
967
968 } // namespace
969
970 void
AppendPolygonToString(nsCSSPropertyID aProperty,nsAString & aResult,Serialization aSerialization) const971 nsCSSValue::AppendPolygonToString(nsCSSPropertyID aProperty, nsAString& aResult,
972 Serialization aSerialization) const
973 {
974 const nsCSSValue::Array* array = GetArrayValue();
975 MOZ_ASSERT(array->Count() > 1 && array->Count() <= 3,
976 "Polygons must have name and at least one more value.");
977 // When the array has 2 elements, the item on index 1 is the coordinate
978 // pair list.
979 // When the array has 3 elements, the item on index 1 is a fill-rule
980 // and item on index 2 is the coordinate pair list.
981 size_t index = 1;
982 if (array->Count() == 3) {
983 const nsCSSValue& fillRuleValue = array->Item(index);
984 MOZ_ASSERT(fillRuleValue.GetUnit() == eCSSUnit_Enumerated,
985 "Expected polygon fill rule.");
986 int32_t fillRule = fillRuleValue.GetIntValue();
987 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(fillRule,
988 nsCSSProps::kFillRuleKTable),
989 aResult);
990 aResult.AppendLiteral(", ");
991 ++index;
992 }
993 array->Item(index).AppendToString(aProperty, aResult, aSerialization);
994 }
995
996 inline void
AppendPositionCoordinateToString(const nsCSSValue & aValue,nsCSSPropertyID aProperty,nsAString & aResult,Serialization aSerialization) const997 nsCSSValue::AppendPositionCoordinateToString(
998 const nsCSSValue& aValue, nsCSSPropertyID aProperty,
999 nsAString& aResult, Serialization aSerialization) const
1000 {
1001 if (aValue.GetUnit() == eCSSUnit_Enumerated) {
1002 int32_t intValue = aValue.GetIntValue();
1003 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1004 nsCSSProps::kShapeRadiusKTable), aResult);
1005 } else {
1006 aValue.AppendToString(aProperty, aResult, aSerialization);
1007 }
1008 }
1009
1010 void
AppendCircleOrEllipseToString(nsCSSKeyword aFunctionId,nsCSSPropertyID aProperty,nsAString & aResult,Serialization aSerialization) const1011 nsCSSValue::AppendCircleOrEllipseToString(nsCSSKeyword aFunctionId,
1012 nsCSSPropertyID aProperty,
1013 nsAString& aResult,
1014 Serialization aSerialization) const
1015 {
1016 const nsCSSValue::Array* array = GetArrayValue();
1017 size_t count = aFunctionId == eCSSKeyword_circle ? 2 : 3;
1018 MOZ_ASSERT(array->Count() == count + 1, "wrong number of arguments");
1019
1020 bool hasRadii = array->Item(1).GetUnit() != eCSSUnit_Null;
1021
1022 // closest-side is the default, so we don't need to
1023 // output it if all values are closest-side.
1024 if (array->Item(1).GetUnit() == eCSSUnit_Enumerated &&
1025 array->Item(1).GetIntValue() == NS_RADIUS_CLOSEST_SIDE &&
1026 (aFunctionId == eCSSKeyword_circle ||
1027 (array->Item(2).GetUnit() == eCSSUnit_Enumerated &&
1028 array->Item(2).GetIntValue() == NS_RADIUS_CLOSEST_SIDE))) {
1029 hasRadii = false;
1030 } else {
1031 AppendPositionCoordinateToString(array->Item(1), aProperty,
1032 aResult, aSerialization);
1033
1034 if (hasRadii && aFunctionId == eCSSKeyword_ellipse) {
1035 aResult.Append(' ');
1036 AppendPositionCoordinateToString(array->Item(2), aProperty,
1037 aResult, aSerialization);
1038 }
1039 }
1040
1041 if (hasRadii) {
1042 aResult.Append(' ');
1043 }
1044
1045 // Any position specified?
1046 if (array->Item(count).GetUnit() != eCSSUnit_Array) {
1047 MOZ_ASSERT(array->Item(count).GetUnit() == eCSSUnit_Null,
1048 "unexpected value");
1049 // We only serialize to the 2 or 4 value form
1050 // |circle()| is valid, but should be expanded
1051 // to |circle(at 50% 50%)|
1052 aResult.AppendLiteral("at 50% 50%");
1053 return;
1054 }
1055
1056 aResult.AppendLiteral("at ");
1057 array->Item(count).AppendBasicShapePositionToString(aResult, aSerialization);
1058 }
1059
1060 // https://drafts.csswg.org/css-shapes/#basic-shape-serialization
1061 // basic-shape asks us to omit a lot of redundant things whilst serializing
1062 // position values. Other specs are not clear about this
1063 // (https://github.com/w3c/csswg-drafts/issues/368), so for now we special-case
1064 // basic shapes only
1065 void
AppendBasicShapePositionToString(nsAString & aResult,Serialization aSerialization) const1066 nsCSSValue::AppendBasicShapePositionToString(nsAString& aResult,
1067 Serialization aSerialization) const
1068 {
1069 const nsCSSValue::Array* array = GetArrayValue();
1070 // We always parse these into an array of four elements
1071 MOZ_ASSERT(array->Count() == 4,
1072 "basic-shape position value doesn't have enough elements");
1073
1074 const nsCSSValue &xEdge = array->Item(0);
1075 const nsCSSValue &xOffset = array->Item(1);
1076 const nsCSSValue &yEdge = array->Item(2);
1077 const nsCSSValue &yOffset = array->Item(3);
1078
1079 MOZ_ASSERT(xEdge.GetUnit() == eCSSUnit_Enumerated &&
1080 yEdge.GetUnit() == eCSSUnit_Enumerated &&
1081 xOffset.IsLengthPercentCalcUnit() &&
1082 yOffset.IsLengthPercentCalcUnit() &&
1083 xEdge.GetIntValue() != NS_STYLE_IMAGELAYER_POSITION_CENTER &&
1084 yEdge.GetIntValue() != NS_STYLE_IMAGELAYER_POSITION_CENTER,
1085 "Ensure invariants from ParsePositionValueBasicShape "
1086 "haven't been modified");
1087 if (xEdge.GetIntValue() == NS_STYLE_IMAGELAYER_POSITION_LEFT &&
1088 yEdge.GetIntValue() == NS_STYLE_IMAGELAYER_POSITION_TOP) {
1089 // We can omit these defaults
1090 xOffset.AppendToString(eCSSProperty_UNKNOWN, aResult, aSerialization);
1091 aResult.Append(' ');
1092 yOffset.AppendToString(eCSSProperty_UNKNOWN, aResult, aSerialization);
1093 } else {
1094 // We only serialize to the two or four valued form
1095 xEdge.AppendToString(eCSSProperty_object_position, aResult, aSerialization);
1096 aResult.Append(' ');
1097 xOffset.AppendToString(eCSSProperty_UNKNOWN, aResult, aSerialization);
1098 aResult.Append(' ');
1099 yEdge.AppendToString(eCSSProperty_object_position, aResult, aSerialization);
1100 aResult.Append(' ');
1101 yOffset.AppendToString(eCSSProperty_UNKNOWN, aResult, aSerialization);
1102 }
1103 }
1104
1105 // Helper to append |aString| with the shorthand sides notation used in e.g.
1106 // 'padding'. |aProperties| and |aValues| are expected to have 4 elements.
1107 /*static*/ void
AppendSidesShorthandToString(const nsCSSPropertyID aProperties[],const nsCSSValue * aValues[],nsAString & aString,nsCSSValue::Serialization aSerialization)1108 nsCSSValue::AppendSidesShorthandToString(const nsCSSPropertyID aProperties[],
1109 const nsCSSValue* aValues[],
1110 nsAString& aString,
1111 nsCSSValue::Serialization
1112 aSerialization)
1113 {
1114 const nsCSSValue& value1 = *aValues[0];
1115 const nsCSSValue& value2 = *aValues[1];
1116 const nsCSSValue& value3 = *aValues[2];
1117 const nsCSSValue& value4 = *aValues[3];
1118
1119 MOZ_ASSERT(value1.GetUnit() != eCSSUnit_Null, "null value 1");
1120 value1.AppendToString(aProperties[0], aString, aSerialization);
1121 if (value1 != value2 || value1 != value3 || value1 != value4) {
1122 aString.Append(char16_t(' '));
1123 MOZ_ASSERT(value2.GetUnit() != eCSSUnit_Null, "null value 2");
1124 value2.AppendToString(aProperties[1], aString, aSerialization);
1125 if (value1 != value3 || value2 != value4) {
1126 aString.Append(char16_t(' '));
1127 MOZ_ASSERT(value3.GetUnit() != eCSSUnit_Null, "null value 3");
1128 value3.AppendToString(aProperties[2], aString, aSerialization);
1129 if (value2 != value4) {
1130 aString.Append(char16_t(' '));
1131 MOZ_ASSERT(value4.GetUnit() != eCSSUnit_Null, "null value 4");
1132 value4.AppendToString(aProperties[3], aString, aSerialization);
1133 }
1134 }
1135 }
1136 }
1137
1138 /*static*/ void
AppendBasicShapeRadiusToString(const nsCSSPropertyID aProperties[],const nsCSSValue * aValues[],nsAString & aResult,Serialization aSerialization)1139 nsCSSValue::AppendBasicShapeRadiusToString(const nsCSSPropertyID aProperties[],
1140 const nsCSSValue* aValues[],
1141 nsAString& aResult,
1142 Serialization aSerialization)
1143 {
1144 bool needY = false;
1145 const nsCSSValue* xVals[4];
1146 const nsCSSValue* yVals[4];
1147 for (int i = 0; i < 4; i++) {
1148 if (aValues[i]->GetUnit() == eCSSUnit_Pair) {
1149 needY = true;
1150 xVals[i] = &aValues[i]->GetPairValue().mXValue;
1151 yVals[i] = &aValues[i]->GetPairValue().mYValue;
1152 } else {
1153 xVals[i] = yVals[i] = aValues[i];
1154 }
1155 }
1156
1157 AppendSidesShorthandToString(aProperties, xVals, aResult, aSerialization);
1158 if (needY) {
1159 aResult.AppendLiteral(" / ");
1160 AppendSidesShorthandToString(aProperties, yVals, aResult, aSerialization);
1161 }
1162 }
1163
1164 void
AppendInsetToString(nsCSSPropertyID aProperty,nsAString & aResult,Serialization aSerialization) const1165 nsCSSValue::AppendInsetToString(nsCSSPropertyID aProperty, nsAString& aResult,
1166 Serialization aSerialization) const
1167 {
1168 const nsCSSValue::Array* array = GetArrayValue();
1169 MOZ_ASSERT(array->Count() == 6,
1170 "inset function has wrong number of arguments");
1171 if (array->Item(1).GetUnit() != eCSSUnit_Null) {
1172 array->Item(1).AppendToString(aProperty, aResult, aSerialization);
1173 if (array->Item(2).GetUnit() != eCSSUnit_Null) {
1174 aResult.Append(' ');
1175 array->Item(2).AppendToString(aProperty, aResult, aSerialization);
1176 if (array->Item(3).GetUnit() != eCSSUnit_Null) {
1177 aResult.Append(' ');
1178 array->Item(3).AppendToString(aProperty, aResult, aSerialization);
1179 if (array->Item(4).GetUnit() != eCSSUnit_Null) {
1180 aResult.Append(' ');
1181 array->Item(4).AppendToString(aProperty, aResult, aSerialization);
1182 }
1183 }
1184 }
1185 }
1186
1187 if (array->Item(5).GetUnit() == eCSSUnit_Array) {
1188 const nsCSSPropertyID* subprops =
1189 nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_radius);
1190 const nsCSSValue::Array* radius = array->Item(5).GetArrayValue();
1191 MOZ_ASSERT(radius->Count() == 4, "expected 4 radii values");
1192 const nsCSSValue* vals[4] = {
1193 &(radius->Item(0)),
1194 &(radius->Item(1)),
1195 &(radius->Item(2)),
1196 &(radius->Item(3))
1197 };
1198 aResult.AppendLiteral(" round ");
1199 AppendBasicShapeRadiusToString(subprops, vals, aResult,
1200 aSerialization);
1201 } else {
1202 MOZ_ASSERT(array->Item(5).GetUnit() == eCSSUnit_Null,
1203 "unexpected value");
1204 }
1205 }
1206
1207 /* static */ void
AppendAlignJustifyValueToString(int32_t aValue,nsAString & aResult)1208 nsCSSValue::AppendAlignJustifyValueToString(int32_t aValue, nsAString& aResult)
1209 {
1210 auto legacy = aValue & NS_STYLE_ALIGN_LEGACY;
1211 if (legacy) {
1212 aValue &= ~legacy;
1213 aResult.AppendLiteral("legacy ");
1214 }
1215 auto overflowPos = aValue & (NS_STYLE_ALIGN_SAFE | NS_STYLE_ALIGN_UNSAFE);
1216 aValue &= ~overflowPos;
1217 MOZ_ASSERT(!(aValue & NS_STYLE_ALIGN_FLAG_BITS),
1218 "unknown bits in align/justify value");
1219 MOZ_ASSERT((aValue != NS_STYLE_ALIGN_AUTO &&
1220 aValue != NS_STYLE_ALIGN_NORMAL &&
1221 aValue != NS_STYLE_ALIGN_BASELINE &&
1222 aValue != NS_STYLE_ALIGN_LAST_BASELINE) ||
1223 (!legacy && !overflowPos),
1224 "auto/normal/baseline/'last baseline' never have any flags");
1225 MOZ_ASSERT(legacy == 0 || overflowPos == 0,
1226 "'legacy' together with <overflow-position>");
1227 if (aValue == NS_STYLE_ALIGN_LAST_BASELINE) {
1228 aResult.AppendLiteral("last ");
1229 aValue = NS_STYLE_ALIGN_BASELINE;
1230 }
1231 const auto& kwtable(nsCSSProps::kAlignAllKeywords);
1232 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(aValue, kwtable), aResult);
1233 // Don't serialize the 'unsafe' keyword; it's the default.
1234 if (MOZ_UNLIKELY(overflowPos == NS_STYLE_ALIGN_SAFE)) {
1235 aResult.Append(' ');
1236 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(overflowPos, kwtable),
1237 aResult);
1238 }
1239 }
1240
1241 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,Serialization aSerialization) const1242 nsCSSValue::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
1243 Serialization aSerialization) const
1244 {
1245 // eCSSProperty_UNKNOWN gets used for some recursive calls below.
1246 MOZ_ASSERT((0 <= aProperty &&
1247 aProperty <= eCSSProperty_COUNT_no_shorthands) ||
1248 aProperty == eCSSProperty_UNKNOWN ||
1249 aProperty == eCSSProperty_DOM,
1250 "property ID out of range");
1251
1252 nsCSSUnit unit = GetUnit();
1253 if (unit == eCSSUnit_Null) {
1254 return;
1255 }
1256
1257 if (eCSSUnit_String <= unit && unit <= eCSSUnit_Attr) {
1258 if (unit == eCSSUnit_Attr) {
1259 aResult.AppendLiteral("attr(");
1260 }
1261 nsAutoString buffer;
1262 GetStringValue(buffer);
1263 if (unit == eCSSUnit_String) {
1264 nsStyleUtil::AppendEscapedCSSString(buffer, aResult);
1265 } else {
1266 nsStyleUtil::AppendEscapedCSSIdent(buffer, aResult);
1267 }
1268 }
1269 else if (eCSSUnit_Array <= unit && unit <= eCSSUnit_Symbols) {
1270 switch (unit) {
1271 case eCSSUnit_Counter: aResult.AppendLiteral("counter("); break;
1272 case eCSSUnit_Counters: aResult.AppendLiteral("counters("); break;
1273 case eCSSUnit_Cubic_Bezier: aResult.AppendLiteral("cubic-bezier("); break;
1274 case eCSSUnit_Steps: aResult.AppendLiteral("steps("); break;
1275 case eCSSUnit_Symbols: aResult.AppendLiteral("symbols("); break;
1276 default: break;
1277 }
1278
1279 nsCSSValue::Array *array = GetArrayValue();
1280 bool mark = false;
1281 for (size_t i = 0, i_end = array->Count(); i < i_end; ++i) {
1282 if (mark && array->Item(i).GetUnit() != eCSSUnit_Null) {
1283 if ((unit == eCSSUnit_Array &&
1284 eCSSProperty_transition_timing_function != aProperty) ||
1285 unit == eCSSUnit_Symbols)
1286 aResult.Append(' ');
1287 else if (unit != eCSSUnit_Steps)
1288 aResult.AppendLiteral(", ");
1289 }
1290 if (unit == eCSSUnit_Steps && i == 1) {
1291 MOZ_ASSERT(array->Item(i).GetUnit() == eCSSUnit_Enumerated,
1292 "unexpected value");
1293 int32_t side = array->Item(i).GetIntValue();
1294 MOZ_ASSERT(side == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START ||
1295 side == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END ||
1296 side == -1,
1297 "unexpected value");
1298 if (side == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START) {
1299 aResult.AppendLiteral(", start");
1300 } else if (side == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END) {
1301 aResult.AppendLiteral(", end");
1302 }
1303 continue;
1304 }
1305 if (unit == eCSSUnit_Symbols && i == 0) {
1306 MOZ_ASSERT(array->Item(i).GetUnit() == eCSSUnit_Enumerated,
1307 "unexpected value");
1308 int32_t system = array->Item(i).GetIntValue();
1309 if (system != NS_STYLE_COUNTER_SYSTEM_SYMBOLIC) {
1310 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(
1311 system, nsCSSProps::kCounterSystemKTable), aResult);
1312 mark = true;
1313 }
1314 continue;
1315 }
1316 nsCSSPropertyID prop =
1317 ((eCSSUnit_Counter <= unit && unit <= eCSSUnit_Counters) &&
1318 i == array->Count() - 1)
1319 ? eCSSProperty_list_style_type : aProperty;
1320 if (array->Item(i).GetUnit() != eCSSUnit_Null) {
1321 array->Item(i).AppendToString(prop, aResult, aSerialization);
1322 mark = true;
1323 }
1324 }
1325 if (eCSSUnit_Array == unit &&
1326 aProperty == eCSSProperty_transition_timing_function) {
1327 aResult.Append(')');
1328 }
1329 }
1330 /* Although Function is backed by an Array, we'll handle it separately
1331 * because it's a bit quirky.
1332 */
1333 else if (eCSSUnit_Function == unit) {
1334 const nsCSSValue::Array* array = GetArrayValue();
1335 MOZ_ASSERT(array->Count() >= 1,
1336 "Functions must have at least one element for the name.");
1337
1338 const nsCSSValue& functionName = array->Item(0);
1339 MOZ_ASSERT(functionName.GetUnit() == eCSSUnit_Enumerated,
1340 "Functions must have an enumerated name.");
1341 // The first argument is always of nsCSSKeyword type.
1342 const nsCSSKeyword functionId = functionName.GetKeywordValue();
1343
1344 // minmax(auto, <flex>) is equivalent to (and is our internal representation
1345 // of) <flex>, and both are serialized as <flex>
1346 if (functionId == eCSSKeyword_minmax &&
1347 array->Count() == 3 &&
1348 array->Item(1).GetUnit() == eCSSUnit_Auto &&
1349 array->Item(2).GetUnit() == eCSSUnit_FlexFraction) {
1350 array->Item(2).AppendToString(aProperty, aResult, aSerialization);
1351 MOZ_ASSERT(aProperty == eCSSProperty_grid_template_columns ||
1352 aProperty == eCSSProperty_grid_template_rows ||
1353 aProperty == eCSSProperty_grid_auto_columns ||
1354 aProperty == eCSSProperty_grid_auto_rows);
1355 return;
1356 }
1357
1358 /* Append the function name. */
1359 NS_ConvertASCIItoUTF16 ident(nsCSSKeywords::GetStringValue(functionId));
1360 // Bug 721136: Normalize the identifier to lowercase, except that things
1361 // like scaleX should have the last character capitalized. This matches
1362 // what other browsers do.
1363 switch (functionId) {
1364 case eCSSKeyword_rotatex:
1365 case eCSSKeyword_scalex:
1366 case eCSSKeyword_skewx:
1367 case eCSSKeyword_translatex:
1368 ident.Replace(ident.Length() - 1, 1, char16_t('X'));
1369 break;
1370
1371 case eCSSKeyword_rotatey:
1372 case eCSSKeyword_scaley:
1373 case eCSSKeyword_skewy:
1374 case eCSSKeyword_translatey:
1375 ident.Replace(ident.Length() - 1, 1, char16_t('Y'));
1376 break;
1377
1378 case eCSSKeyword_rotatez:
1379 case eCSSKeyword_scalez:
1380 case eCSSKeyword_translatez:
1381 ident.Replace(ident.Length() - 1, 1, char16_t('Z'));
1382 break;
1383
1384 default:
1385 break;
1386 }
1387 nsStyleUtil::AppendEscapedCSSIdent(ident, aResult);
1388 aResult.Append('(');
1389
1390 switch (functionId) {
1391 case eCSSKeyword_polygon:
1392 AppendPolygonToString(aProperty, aResult, aSerialization);
1393 break;
1394
1395 case eCSSKeyword_circle:
1396 case eCSSKeyword_ellipse:
1397 AppendCircleOrEllipseToString(functionId, aProperty, aResult,
1398 aSerialization);
1399 break;
1400
1401 case eCSSKeyword_inset:
1402 AppendInsetToString(aProperty, aResult, aSerialization);
1403 break;
1404
1405 default: {
1406 // Now, step through the function contents, writing each of
1407 // them as we go.
1408 for (size_t index = 1; index < array->Count(); ++index) {
1409 array->Item(index).AppendToString(aProperty, aResult,
1410 aSerialization);
1411
1412 /* If we're not at the final element, append a comma. */
1413 if (index + 1 != array->Count())
1414 aResult.AppendLiteral(", ");
1415 }
1416 }
1417 }
1418
1419 /* Finally, append the closing parenthesis. */
1420 aResult.Append(')');
1421 }
1422 else if (IsCalcUnit()) {
1423 MOZ_ASSERT(GetUnit() == eCSSUnit_Calc, "unexpected unit");
1424 CSSValueSerializeCalcOps ops(aProperty, aResult, aSerialization);
1425 css::SerializeCalc(*this, ops);
1426 }
1427 else if (eCSSUnit_Integer == unit) {
1428 aResult.AppendInt(GetIntValue(), 10);
1429 }
1430 else if (eCSSUnit_Enumerated == unit) {
1431 int32_t intValue = GetIntValue();
1432 switch(aProperty) {
1433
1434
1435 case eCSSProperty_text_combine_upright:
1436 if (intValue <= NS_STYLE_TEXT_COMBINE_UPRIGHT_ALL) {
1437 AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
1438 aResult);
1439 } else if (intValue == NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_2) {
1440 aResult.AppendLiteral("digits 2");
1441 } else if (intValue == NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_3) {
1442 aResult.AppendLiteral("digits 3");
1443 } else {
1444 aResult.AppendLiteral("digits 4");
1445 }
1446 break;
1447
1448 case eCSSProperty_text_decoration_line:
1449 if (NS_STYLE_TEXT_DECORATION_LINE_NONE == intValue) {
1450 AppendASCIItoUTF16(nsCSSProps::LookupPropertyValue(aProperty, intValue),
1451 aResult);
1452 } else {
1453 // Ignore the "override all" internal value.
1454 // (It doesn't have a string representation.)
1455 intValue &= ~NS_STYLE_TEXT_DECORATION_LINE_OVERRIDE_ALL;
1456 nsStyleUtil::AppendBitmaskCSSValue(
1457 aProperty, intValue,
1458 NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE,
1459 NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS,
1460 aResult);
1461 }
1462 break;
1463
1464 case eCSSProperty_paint_order:
1465 static_assert
1466 (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8,
1467 "SVGStyleStruct::mPaintOrder and the following cast not big enough");
1468 nsStyleUtil::AppendPaintOrderValue(static_cast<uint8_t>(GetIntValue()),
1469 aResult);
1470 break;
1471
1472 case eCSSProperty_font_synthesis:
1473 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1474 NS_FONT_SYNTHESIS_WEIGHT,
1475 NS_FONT_SYNTHESIS_STYLE,
1476 aResult);
1477 break;
1478
1479 case eCSSProperty_font_variant_east_asian:
1480 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1481 NS_FONT_VARIANT_EAST_ASIAN_JIS78,
1482 NS_FONT_VARIANT_EAST_ASIAN_RUBY,
1483 aResult);
1484 break;
1485
1486 case eCSSProperty_font_variant_ligatures:
1487 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1488 NS_FONT_VARIANT_LIGATURES_NONE,
1489 NS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL,
1490 aResult);
1491 break;
1492
1493 case eCSSProperty_font_variant_numeric:
1494 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1495 NS_FONT_VARIANT_NUMERIC_LINING,
1496 NS_FONT_VARIANT_NUMERIC_ORDINAL,
1497 aResult);
1498 break;
1499
1500 case eCSSProperty_grid_auto_flow:
1501 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1502 NS_STYLE_GRID_AUTO_FLOW_ROW,
1503 NS_STYLE_GRID_AUTO_FLOW_DENSE,
1504 aResult);
1505 break;
1506
1507 case eCSSProperty_grid_column_start:
1508 case eCSSProperty_grid_column_end:
1509 case eCSSProperty_grid_row_start:
1510 case eCSSProperty_grid_row_end:
1511 // "span" is the only enumerated-unit value for these properties
1512 aResult.AppendLiteral("span");
1513 break;
1514
1515 case eCSSProperty_touch_action:
1516 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1517 NS_STYLE_TOUCH_ACTION_NONE,
1518 NS_STYLE_TOUCH_ACTION_MANIPULATION,
1519 aResult);
1520 break;
1521
1522 case eCSSProperty_clip_path:
1523 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1524 nsCSSProps::kClipPathGeometryBoxKTable),
1525 aResult);
1526 break;
1527
1528 case eCSSProperty_shape_outside:
1529 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1530 nsCSSProps::kShapeOutsideShapeBoxKTable),
1531 aResult);
1532 break;
1533
1534 case eCSSProperty_contain:
1535 if (intValue & NS_STYLE_CONTAIN_STRICT) {
1536 NS_ASSERTION(intValue == (NS_STYLE_CONTAIN_STRICT | NS_STYLE_CONTAIN_ALL_BITS),
1537 "contain: strict should imply contain: layout style paint");
1538 // Only output strict.
1539 intValue = NS_STYLE_CONTAIN_STRICT;
1540 }
1541 nsStyleUtil::AppendBitmaskCSSValue(aProperty,
1542 intValue,
1543 NS_STYLE_CONTAIN_STRICT,
1544 NS_STYLE_CONTAIN_PAINT,
1545 aResult);
1546 break;
1547
1548 case eCSSProperty_align_content:
1549 case eCSSProperty_justify_content: {
1550 AppendAlignJustifyValueToString(intValue & NS_STYLE_ALIGN_ALL_BITS, aResult);
1551 auto fallback = intValue >> NS_STYLE_ALIGN_ALL_SHIFT;
1552 if (fallback) {
1553 MOZ_ASSERT(nsCSSProps::ValueToKeywordEnum(fallback & ~NS_STYLE_ALIGN_FLAG_BITS,
1554 nsCSSProps::kAlignSelfPosition)
1555 != eCSSKeyword_UNKNOWN, "unknown fallback value");
1556 aResult.Append(' ');
1557 AppendAlignJustifyValueToString(fallback, aResult);
1558 }
1559 break;
1560 }
1561
1562 case eCSSProperty_align_items:
1563 case eCSSProperty_align_self:
1564 case eCSSProperty_justify_items:
1565 case eCSSProperty_justify_self:
1566 AppendAlignJustifyValueToString(intValue, aResult);
1567 break;
1568
1569 case eCSSProperty_text_emphasis_position: {
1570 nsStyleUtil::AppendBitmaskCSSValue(aProperty, intValue,
1571 NS_STYLE_TEXT_EMPHASIS_POSITION_OVER,
1572 NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT,
1573 aResult);
1574 break;
1575 }
1576
1577 case eCSSProperty_text_emphasis_style: {
1578 auto fill = intValue & NS_STYLE_TEXT_EMPHASIS_STYLE_FILL_MASK;
1579 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(
1580 fill, nsCSSProps::kTextEmphasisStyleFillKTable), aResult);
1581 aResult.Append(' ');
1582 auto shape = intValue & NS_STYLE_TEXT_EMPHASIS_STYLE_SHAPE_MASK;
1583 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(
1584 shape, nsCSSProps::kTextEmphasisStyleShapeKTable), aResult);
1585 break;
1586 }
1587
1588 default:
1589 const nsAFlatCString& name = nsCSSProps::LookupPropertyValue(aProperty, intValue);
1590 AppendASCIItoUTF16(name, aResult);
1591 break;
1592 }
1593 }
1594 else if (eCSSUnit_EnumColor == unit) {
1595 // we can lookup the property in the ColorTable and then
1596 // get a string mapping the name
1597 nsAutoCString str;
1598 if (nsCSSProps::GetColorName(GetIntValue(), str)){
1599 AppendASCIItoUTF16(str, aResult);
1600 } else {
1601 MOZ_ASSERT(false, "bad color value");
1602 }
1603 }
1604 else if (IsNumericColorUnit(unit)) {
1605 if (aSerialization == eNormalized ||
1606 unit == eCSSUnit_RGBColor ||
1607 unit == eCSSUnit_RGBAColor) {
1608 nscolor color = GetColorValue();
1609 if (aSerialization == eNormalized &&
1610 color == NS_RGBA(0, 0, 0, 0)) {
1611 // Use the strictest match for 'transparent' so we do correct
1612 // round-tripping of all other rgba() values.
1613 aResult.AppendLiteral("transparent");
1614 } else {
1615 // For brevity, we omit the alpha component if it's equal to 255 (full
1616 // opaque). Also, we use "rgba" rather than "rgb" when the color includes
1617 // the non-opaque alpha value, for backwards-compat (even though they're
1618 // aliases as of css-color-4).
1619 // e.g.:
1620 // rgba(1, 2, 3, 1.0) => rgb(1, 2, 3)
1621 // rgba(1, 2, 3, 0.5) => rgba(1, 2, 3, 0.5)
1622 uint8_t a = NS_GET_A(color);
1623 bool showAlpha = (a != 255);
1624
1625 if (showAlpha) {
1626 aResult.AppendLiteral("rgba(");
1627 } else {
1628 aResult.AppendLiteral("rgb(");
1629 }
1630
1631 NS_NAMED_LITERAL_STRING(comma, ", ");
1632
1633 aResult.AppendInt(NS_GET_R(color), 10);
1634 aResult.Append(comma);
1635 aResult.AppendInt(NS_GET_G(color), 10);
1636 aResult.Append(comma);
1637 aResult.AppendInt(NS_GET_B(color), 10);
1638 if (showAlpha) {
1639 aResult.Append(comma);
1640 aResult.AppendFloat(nsStyleUtil::ColorComponentToFloat(a));
1641 }
1642 aResult.Append(char16_t(')'));
1643 }
1644 } else if (eCSSUnit_HexColor == unit ||
1645 eCSSUnit_HexColorAlpha == unit) {
1646 nscolor color = GetColorValue();
1647 aResult.Append('#');
1648 aResult.AppendPrintf("%02x", NS_GET_R(color));
1649 aResult.AppendPrintf("%02x", NS_GET_G(color));
1650 aResult.AppendPrintf("%02x", NS_GET_B(color));
1651 if (eCSSUnit_HexColorAlpha == unit) {
1652 aResult.AppendPrintf("%02x", NS_GET_A(color));
1653 }
1654 } else if (eCSSUnit_ShortHexColor == unit ||
1655 eCSSUnit_ShortHexColorAlpha == unit) {
1656 nscolor color = GetColorValue();
1657 aResult.Append('#');
1658 aResult.AppendInt(NS_GET_R(color) / 0x11, 16);
1659 aResult.AppendInt(NS_GET_G(color) / 0x11, 16);
1660 aResult.AppendInt(NS_GET_B(color) / 0x11, 16);
1661 if (eCSSUnit_ShortHexColorAlpha == unit) {
1662 aResult.AppendInt(NS_GET_A(color) / 0x11, 16);
1663 }
1664 } else {
1665 MOZ_ASSERT(IsFloatColorUnit());
1666 mValue.mFloatColor->AppendToString(unit, aResult);
1667 }
1668 }
1669 else if (eCSSUnit_ComplexColor == unit) {
1670 StyleComplexColor color = GetStyleComplexColorValue();
1671 nsCSSValue serializable;
1672 if (color.IsCurrentColor()) {
1673 serializable.SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor);
1674 } else if (color.IsNumericColor()) {
1675 serializable.SetColorValue(color.mColor);
1676 } else {
1677 MOZ_ASSERT_UNREACHABLE("Cannot serialize a complex color");
1678 }
1679 serializable.AppendToString(aProperty, aResult, aSerialization);
1680 }
1681 else if (eCSSUnit_URL == unit || eCSSUnit_Image == unit) {
1682 aResult.AppendLiteral("url(");
1683 nsStyleUtil::AppendEscapedCSSString(
1684 nsDependentString(GetOriginalURLValue()), aResult);
1685 aResult.Append(')');
1686 }
1687 else if (eCSSUnit_Element == unit) {
1688 aResult.AppendLiteral("-moz-element(#");
1689 nsAutoString tmpStr;
1690 GetStringValue(tmpStr);
1691 nsStyleUtil::AppendEscapedCSSIdent(tmpStr, aResult);
1692 aResult.Append(')');
1693 }
1694 else if (eCSSUnit_Percent == unit) {
1695 aResult.AppendFloat(GetPercentValue() * 100.0f);
1696 }
1697 else if (eCSSUnit_Percent < unit) { // length unit
1698 aResult.AppendFloat(GetFloatValue());
1699 }
1700 else if (eCSSUnit_Gradient == unit) {
1701 nsCSSValueGradient* gradient = GetGradientValue();
1702
1703 if (gradient->mIsLegacySyntax) {
1704 aResult.AppendLiteral("-moz-");
1705 }
1706 if (gradient->mIsRepeating) {
1707 aResult.AppendLiteral("repeating-");
1708 }
1709 if (gradient->mIsRadial) {
1710 aResult.AppendLiteral("radial-gradient(");
1711 } else {
1712 aResult.AppendLiteral("linear-gradient(");
1713 }
1714
1715 bool needSep = false;
1716 if (gradient->mIsRadial && !gradient->mIsLegacySyntax) {
1717 if (!gradient->mIsExplicitSize) {
1718 if (gradient->GetRadialShape().GetUnit() != eCSSUnit_None) {
1719 MOZ_ASSERT(gradient->GetRadialShape().GetUnit() ==
1720 eCSSUnit_Enumerated,
1721 "bad unit for radial gradient shape");
1722 int32_t intValue = gradient->GetRadialShape().GetIntValue();
1723 MOZ_ASSERT(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR,
1724 "radial gradient with linear shape?!");
1725 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1726 nsCSSProps::kRadialGradientShapeKTable),
1727 aResult);
1728 needSep = true;
1729 }
1730
1731 if (gradient->GetRadialSize().GetUnit() != eCSSUnit_None) {
1732 if (needSep) {
1733 aResult.Append(' ');
1734 }
1735 MOZ_ASSERT(gradient->GetRadialSize().GetUnit() == eCSSUnit_Enumerated,
1736 "bad unit for radial gradient size");
1737 int32_t intValue = gradient->GetRadialSize().GetIntValue();
1738 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1739 nsCSSProps::kRadialGradientSizeKTable),
1740 aResult);
1741 needSep = true;
1742 }
1743 } else {
1744 MOZ_ASSERT(gradient->GetRadiusX().GetUnit() != eCSSUnit_None,
1745 "bad unit for radial gradient explicit size");
1746 gradient->GetRadiusX().AppendToString(aProperty, aResult,
1747 aSerialization);
1748 if (gradient->GetRadiusY().GetUnit() != eCSSUnit_None) {
1749 aResult.Append(' ');
1750 gradient->GetRadiusY().AppendToString(aProperty, aResult,
1751 aSerialization);
1752 }
1753 needSep = true;
1754 }
1755 }
1756 if (!gradient->mIsRadial && !gradient->mIsLegacySyntax) {
1757 if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None ||
1758 gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None) {
1759 MOZ_ASSERT(gradient->mAngle.GetUnit() == eCSSUnit_None);
1760 MOZ_ASSERT(gradient->mBgPos.mXValue.GetUnit() == eCSSUnit_Enumerated &&
1761 gradient->mBgPos.mYValue.GetUnit() == eCSSUnit_Enumerated,
1762 "unexpected unit");
1763 aResult.AppendLiteral("to");
1764 if (!(gradient->mBgPos.mXValue.GetIntValue() & NS_STYLE_IMAGELAYER_POSITION_CENTER)) {
1765 aResult.Append(' ');
1766 gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position_x,
1767 aResult, aSerialization);
1768 }
1769 if (!(gradient->mBgPos.mYValue.GetIntValue() & NS_STYLE_IMAGELAYER_POSITION_CENTER)) {
1770 aResult.Append(' ');
1771 gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position_y,
1772 aResult, aSerialization);
1773 }
1774 needSep = true;
1775 } else if (gradient->mAngle.GetUnit() != eCSSUnit_None) {
1776 gradient->mAngle.AppendToString(aProperty, aResult, aSerialization);
1777 needSep = true;
1778 }
1779 } else if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None ||
1780 gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None ||
1781 gradient->mAngle.GetUnit() != eCSSUnit_None) {
1782 if (needSep) {
1783 aResult.Append(' ');
1784 }
1785 if (gradient->mIsRadial && !gradient->mIsLegacySyntax) {
1786 aResult.AppendLiteral("at ");
1787 }
1788 if (gradient->mBgPos.mXValue.GetUnit() != eCSSUnit_None) {
1789 gradient->mBgPos.mXValue.AppendToString(eCSSProperty_background_position_x,
1790 aResult, aSerialization);
1791 aResult.Append(' ');
1792 }
1793 if (gradient->mBgPos.mYValue.GetUnit() != eCSSUnit_None) {
1794 gradient->mBgPos.mYValue.AppendToString(eCSSProperty_background_position_y,
1795 aResult, aSerialization);
1796 aResult.Append(' ');
1797 }
1798 if (gradient->mAngle.GetUnit() != eCSSUnit_None) {
1799 MOZ_ASSERT(gradient->mIsLegacySyntax,
1800 "angle is allowed only for legacy syntax");
1801 gradient->mAngle.AppendToString(aProperty, aResult, aSerialization);
1802 }
1803 needSep = true;
1804 }
1805
1806 if (gradient->mIsRadial && gradient->mIsLegacySyntax &&
1807 (gradient->GetRadialShape().GetUnit() != eCSSUnit_None ||
1808 gradient->GetRadialSize().GetUnit() != eCSSUnit_None)) {
1809 MOZ_ASSERT(!gradient->mIsExplicitSize);
1810 if (needSep) {
1811 aResult.AppendLiteral(", ");
1812 }
1813 if (gradient->GetRadialShape().GetUnit() != eCSSUnit_None) {
1814 MOZ_ASSERT(gradient->GetRadialShape().GetUnit() == eCSSUnit_Enumerated,
1815 "bad unit for radial gradient shape");
1816 int32_t intValue = gradient->GetRadialShape().GetIntValue();
1817 MOZ_ASSERT(intValue != NS_STYLE_GRADIENT_SHAPE_LINEAR,
1818 "radial gradient with linear shape?!");
1819 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1820 nsCSSProps::kRadialGradientShapeKTable),
1821 aResult);
1822 aResult.Append(' ');
1823 }
1824
1825 if (gradient->GetRadialSize().GetUnit() != eCSSUnit_None) {
1826 MOZ_ASSERT(gradient->GetRadialSize().GetUnit() == eCSSUnit_Enumerated,
1827 "bad unit for radial gradient size");
1828 int32_t intValue = gradient->GetRadialSize().GetIntValue();
1829 AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
1830 nsCSSProps::kRadialGradientSizeKTable),
1831 aResult);
1832 }
1833 needSep = true;
1834 }
1835 if (needSep) {
1836 aResult.AppendLiteral(", ");
1837 }
1838
1839 for (uint32_t i = 0 ;;) {
1840 bool isInterpolationHint = gradient->mStops[i].mIsInterpolationHint;
1841 if (!isInterpolationHint) {
1842 gradient->mStops[i].mColor.AppendToString(aProperty, aResult,
1843 aSerialization);
1844 }
1845 if (gradient->mStops[i].mLocation.GetUnit() != eCSSUnit_None) {
1846 if (!isInterpolationHint) {
1847 aResult.Append(' ');
1848 }
1849 gradient->mStops[i].mLocation.AppendToString(aProperty, aResult,
1850 aSerialization);
1851 }
1852 if (++i == gradient->mStops.Length()) {
1853 break;
1854 }
1855 aResult.AppendLiteral(", ");
1856 }
1857
1858 aResult.Append(')');
1859 } else if (eCSSUnit_TokenStream == unit) {
1860 nsCSSPropertyID shorthand = mValue.mTokenStream->mShorthandPropertyID;
1861 if (shorthand == eCSSProperty_UNKNOWN ||
1862 nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS) ||
1863 aProperty == eCSSProperty__x_system_font) {
1864 // We treat serialization of aliases like '-moz-transform' as a special
1865 // case, since it really wants to be serialized as if it were a longhand
1866 // even though it is implemented as a shorthand. We also need to
1867 // serialize -x-system-font's token stream value, even though the
1868 // value is set through the font shorthand. This serialization
1869 // of -x-system-font is needed when we need to output the
1870 // 'font' shorthand followed by a number of overriding font
1871 // longhand components.
1872 aResult.Append(mValue.mTokenStream->mTokenStream);
1873 }
1874 } else if (eCSSUnit_Pair == unit) {
1875 if (eCSSProperty_font_variant_alternates == aProperty) {
1876 int32_t intValue = GetPairValue().mXValue.GetIntValue();
1877 nsAutoString out;
1878
1879 // simple, enumerated values
1880 nsStyleUtil::AppendBitmaskCSSValue(aProperty,
1881 intValue & NS_FONT_VARIANT_ALTERNATES_ENUMERATED_MASK,
1882 NS_FONT_VARIANT_ALTERNATES_HISTORICAL,
1883 NS_FONT_VARIANT_ALTERNATES_HISTORICAL,
1884 out);
1885
1886 // functional values
1887 const nsCSSValueList *list = GetPairValue().mYValue.GetListValue();
1888 AutoTArray<gfxAlternateValue,8> altValues;
1889
1890 nsStyleUtil::ComputeFunctionalAlternates(list, altValues);
1891 nsStyleUtil::SerializeFunctionalAlternates(altValues, out);
1892 aResult.Append(out);
1893 } else {
1894 GetPairValue().AppendToString(aProperty, aResult, aSerialization);
1895 }
1896 } else if (eCSSUnit_Triplet == unit) {
1897 GetTripletValue().AppendToString(aProperty, aResult, aSerialization);
1898 } else if (eCSSUnit_Rect == unit) {
1899 GetRectValue().AppendToString(aProperty, aResult, aSerialization);
1900 } else if (eCSSUnit_List == unit || eCSSUnit_ListDep == unit) {
1901 GetListValue()->AppendToString(aProperty, aResult, aSerialization);
1902 } else if (eCSSUnit_SharedList == unit) {
1903 GetSharedListValue()->AppendToString(aProperty, aResult, aSerialization);
1904 } else if (eCSSUnit_PairList == unit || eCSSUnit_PairListDep == unit) {
1905 switch (aProperty) {
1906 case eCSSProperty_font_feature_settings:
1907 nsStyleUtil::AppendFontFeatureSettings(*this, aResult);
1908 break;
1909 default:
1910 GetPairListValue()->AppendToString(aProperty, aResult, aSerialization);
1911 break;
1912 }
1913 } else if (eCSSUnit_GridTemplateAreas == unit) {
1914 const mozilla::css::GridTemplateAreasValue* areas = GetGridTemplateAreas();
1915 MOZ_ASSERT(!areas->mTemplates.IsEmpty(),
1916 "Unexpected empty array in GridTemplateAreasValue");
1917 nsStyleUtil::AppendEscapedCSSString(areas->mTemplates[0], aResult);
1918 for (uint32_t i = 1; i < areas->mTemplates.Length(); i++) {
1919 aResult.Append(char16_t(' '));
1920 nsStyleUtil::AppendEscapedCSSString(areas->mTemplates[i], aResult);
1921 }
1922 } else if (eCSSUnit_FontFamilyList == unit) {
1923 nsStyleUtil::AppendEscapedCSSFontFamilyList(*mValue.mFontFamilyList,
1924 aResult);
1925 }
1926
1927 switch (unit) {
1928 case eCSSUnit_Null: break;
1929 case eCSSUnit_Auto: aResult.AppendLiteral("auto"); break;
1930 case eCSSUnit_Inherit: aResult.AppendLiteral("inherit"); break;
1931 case eCSSUnit_Initial: aResult.AppendLiteral("initial"); break;
1932 case eCSSUnit_Unset: aResult.AppendLiteral("unset"); break;
1933 case eCSSUnit_None: aResult.AppendLiteral("none"); break;
1934 case eCSSUnit_Normal: aResult.AppendLiteral("normal"); break;
1935 case eCSSUnit_System_Font: aResult.AppendLiteral("-moz-use-system-font"); break;
1936 case eCSSUnit_All: aResult.AppendLiteral("all"); break;
1937 case eCSSUnit_Dummy:
1938 case eCSSUnit_DummyInherit:
1939 MOZ_ASSERT(false, "should never serialize");
1940 break;
1941
1942 case eCSSUnit_FontFamilyList: break;
1943 case eCSSUnit_String: break;
1944 case eCSSUnit_Ident: break;
1945 case eCSSUnit_URL: break;
1946 case eCSSUnit_Image: break;
1947 case eCSSUnit_Element: break;
1948 case eCSSUnit_Array: break;
1949 case eCSSUnit_Attr:
1950 case eCSSUnit_Cubic_Bezier:
1951 case eCSSUnit_Steps:
1952 case eCSSUnit_Symbols:
1953 case eCSSUnit_Counter:
1954 case eCSSUnit_Counters: aResult.Append(char16_t(')')); break;
1955 case eCSSUnit_Local_Font: break;
1956 case eCSSUnit_Font_Format: break;
1957 case eCSSUnit_Function: break;
1958 case eCSSUnit_Calc: break;
1959 case eCSSUnit_Calc_Plus: break;
1960 case eCSSUnit_Calc_Minus: break;
1961 case eCSSUnit_Calc_Times_L: break;
1962 case eCSSUnit_Calc_Times_R: break;
1963 case eCSSUnit_Calc_Divided: break;
1964 case eCSSUnit_Integer: break;
1965 case eCSSUnit_Enumerated: break;
1966 case eCSSUnit_EnumColor: break;
1967 case eCSSUnit_RGBColor: break;
1968 case eCSSUnit_RGBAColor: break;
1969 case eCSSUnit_HexColor: break;
1970 case eCSSUnit_ShortHexColor: break;
1971 case eCSSUnit_HexColorAlpha: break;
1972 case eCSSUnit_ShortHexColorAlpha: break;
1973 case eCSSUnit_PercentageRGBColor: break;
1974 case eCSSUnit_PercentageRGBAColor: break;
1975 case eCSSUnit_HSLColor: break;
1976 case eCSSUnit_HSLAColor: break;
1977 case eCSSUnit_ComplexColor: break;
1978 case eCSSUnit_Percent: aResult.Append(char16_t('%')); break;
1979 case eCSSUnit_Number: break;
1980 case eCSSUnit_Gradient: break;
1981 case eCSSUnit_TokenStream: break;
1982 case eCSSUnit_Pair: break;
1983 case eCSSUnit_Triplet: break;
1984 case eCSSUnit_Rect: break;
1985 case eCSSUnit_List: break;
1986 case eCSSUnit_ListDep: break;
1987 case eCSSUnit_SharedList: break;
1988 case eCSSUnit_PairList: break;
1989 case eCSSUnit_PairListDep: break;
1990 case eCSSUnit_GridTemplateAreas: break;
1991
1992 case eCSSUnit_Inch: aResult.AppendLiteral("in"); break;
1993 case eCSSUnit_Millimeter: aResult.AppendLiteral("mm"); break;
1994 case eCSSUnit_PhysicalMillimeter: aResult.AppendLiteral("mozmm"); break;
1995 case eCSSUnit_Centimeter: aResult.AppendLiteral("cm"); break;
1996 case eCSSUnit_Point: aResult.AppendLiteral("pt"); break;
1997 case eCSSUnit_Pica: aResult.AppendLiteral("pc"); break;
1998 case eCSSUnit_Quarter: aResult.AppendLiteral("q"); break;
1999
2000 case eCSSUnit_ViewportWidth: aResult.AppendLiteral("vw"); break;
2001 case eCSSUnit_ViewportHeight: aResult.AppendLiteral("vh"); break;
2002 case eCSSUnit_ViewportMin: aResult.AppendLiteral("vmin"); break;
2003 case eCSSUnit_ViewportMax: aResult.AppendLiteral("vmax"); break;
2004
2005 case eCSSUnit_EM: aResult.AppendLiteral("em"); break;
2006 case eCSSUnit_XHeight: aResult.AppendLiteral("ex"); break;
2007 case eCSSUnit_Char: aResult.AppendLiteral("ch"); break;
2008 case eCSSUnit_RootEM: aResult.AppendLiteral("rem"); break;
2009
2010 case eCSSUnit_Pixel: aResult.AppendLiteral("px"); break;
2011
2012 case eCSSUnit_Degree: aResult.AppendLiteral("deg"); break;
2013 case eCSSUnit_Grad: aResult.AppendLiteral("grad"); break;
2014 case eCSSUnit_Radian: aResult.AppendLiteral("rad"); break;
2015 case eCSSUnit_Turn: aResult.AppendLiteral("turn"); break;
2016
2017 case eCSSUnit_Hertz: aResult.AppendLiteral("Hz"); break;
2018 case eCSSUnit_Kilohertz: aResult.AppendLiteral("kHz"); break;
2019
2020 case eCSSUnit_Seconds: aResult.Append(char16_t('s')); break;
2021 case eCSSUnit_Milliseconds: aResult.AppendLiteral("ms"); break;
2022
2023 case eCSSUnit_FlexFraction: aResult.AppendLiteral("fr"); break;
2024 }
2025 }
2026
2027 size_t
SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2028 nsCSSValue::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2029 {
2030 size_t n = 0;
2031
2032 switch (GetUnit()) {
2033 // No value: nothing extra to measure.
2034 case eCSSUnit_Null:
2035 case eCSSUnit_Auto:
2036 case eCSSUnit_Inherit:
2037 case eCSSUnit_Initial:
2038 case eCSSUnit_Unset:
2039 case eCSSUnit_None:
2040 case eCSSUnit_Normal:
2041 case eCSSUnit_System_Font:
2042 case eCSSUnit_All:
2043 case eCSSUnit_Dummy:
2044 case eCSSUnit_DummyInherit:
2045 break;
2046
2047 // String
2048 case eCSSUnit_String:
2049 case eCSSUnit_Ident:
2050 case eCSSUnit_Attr:
2051 case eCSSUnit_Local_Font:
2052 case eCSSUnit_Font_Format:
2053 case eCSSUnit_Element:
2054 n += mValue.mString->SizeOfIncludingThisIfUnshared(aMallocSizeOf);
2055 break;
2056
2057 // Array
2058 case eCSSUnit_Array:
2059 case eCSSUnit_Counter:
2060 case eCSSUnit_Counters:
2061 case eCSSUnit_Cubic_Bezier:
2062 case eCSSUnit_Steps:
2063 case eCSSUnit_Symbols:
2064 case eCSSUnit_Function:
2065 case eCSSUnit_Calc:
2066 case eCSSUnit_Calc_Plus:
2067 case eCSSUnit_Calc_Minus:
2068 case eCSSUnit_Calc_Times_L:
2069 case eCSSUnit_Calc_Times_R:
2070 case eCSSUnit_Calc_Divided:
2071 break;
2072
2073 // URL
2074 case eCSSUnit_URL:
2075 n += mValue.mURL->SizeOfIncludingThis(aMallocSizeOf);
2076 break;
2077
2078 // Image
2079 case eCSSUnit_Image:
2080 // Not yet measured. Measurement may be added later if DMD finds it
2081 // worthwhile.
2082 break;
2083
2084 // Gradient
2085 case eCSSUnit_Gradient:
2086 n += mValue.mGradient->SizeOfIncludingThis(aMallocSizeOf);
2087 break;
2088
2089 // TokenStream
2090 case eCSSUnit_TokenStream:
2091 n += mValue.mTokenStream->SizeOfIncludingThis(aMallocSizeOf);
2092 break;
2093
2094 // Pair
2095 case eCSSUnit_Pair:
2096 n += mValue.mPair->SizeOfIncludingThis(aMallocSizeOf);
2097 break;
2098
2099 // Triplet
2100 case eCSSUnit_Triplet:
2101 n += mValue.mTriplet->SizeOfIncludingThis(aMallocSizeOf);
2102 break;
2103
2104 // Rect
2105 case eCSSUnit_Rect:
2106 n += mValue.mRect->SizeOfIncludingThis(aMallocSizeOf);
2107 break;
2108
2109 // List
2110 case eCSSUnit_List:
2111 n += mValue.mList->SizeOfIncludingThis(aMallocSizeOf);
2112 break;
2113
2114 // ListDep: not measured because it's non-owning.
2115 case eCSSUnit_ListDep:
2116 break;
2117
2118 // SharedList
2119 case eCSSUnit_SharedList:
2120 // Makes more sense not to measure, since it most cases the list
2121 // will be shared.
2122 break;
2123
2124 // PairList
2125 case eCSSUnit_PairList:
2126 n += mValue.mPairList->SizeOfIncludingThis(aMallocSizeOf);
2127 break;
2128
2129 // PairListDep: not measured because it's non-owning.
2130 case eCSSUnit_PairListDep:
2131 break;
2132
2133 // GridTemplateAreas
2134 case eCSSUnit_GridTemplateAreas:
2135 n += mValue.mGridTemplateAreas->SizeOfIncludingThis(aMallocSizeOf);
2136 break;
2137
2138 case eCSSUnit_FontFamilyList:
2139 n += mValue.mFontFamilyList->SizeOfIncludingThis(aMallocSizeOf);
2140 break;
2141
2142 // Int: nothing extra to measure.
2143 case eCSSUnit_Integer:
2144 case eCSSUnit_Enumerated:
2145 case eCSSUnit_EnumColor:
2146 break;
2147
2148 // Integer Color: nothing extra to measure.
2149 case eCSSUnit_RGBColor:
2150 case eCSSUnit_RGBAColor:
2151 case eCSSUnit_HexColor:
2152 case eCSSUnit_ShortHexColor:
2153 case eCSSUnit_HexColorAlpha:
2154 case eCSSUnit_ShortHexColorAlpha:
2155 break;
2156
2157 // Float Color
2158 case eCSSUnit_PercentageRGBColor:
2159 case eCSSUnit_PercentageRGBAColor:
2160 case eCSSUnit_HSLColor:
2161 case eCSSUnit_HSLAColor:
2162 n += mValue.mFloatColor->SizeOfIncludingThis(aMallocSizeOf);
2163 break;
2164
2165 // Complex Color
2166 case eCSSUnit_ComplexColor:
2167 n += mValue.mComplexColor->SizeOfIncludingThis(aMallocSizeOf);
2168 break;
2169
2170 // Float: nothing extra to measure.
2171 case eCSSUnit_Percent:
2172 case eCSSUnit_Number:
2173 case eCSSUnit_PhysicalMillimeter:
2174 case eCSSUnit_ViewportWidth:
2175 case eCSSUnit_ViewportHeight:
2176 case eCSSUnit_ViewportMin:
2177 case eCSSUnit_ViewportMax:
2178 case eCSSUnit_EM:
2179 case eCSSUnit_XHeight:
2180 case eCSSUnit_Char:
2181 case eCSSUnit_RootEM:
2182 case eCSSUnit_Point:
2183 case eCSSUnit_Inch:
2184 case eCSSUnit_Millimeter:
2185 case eCSSUnit_Centimeter:
2186 case eCSSUnit_Pica:
2187 case eCSSUnit_Pixel:
2188 case eCSSUnit_Quarter:
2189 case eCSSUnit_Degree:
2190 case eCSSUnit_Grad:
2191 case eCSSUnit_Turn:
2192 case eCSSUnit_Radian:
2193 case eCSSUnit_Hertz:
2194 case eCSSUnit_Kilohertz:
2195 case eCSSUnit_Seconds:
2196 case eCSSUnit_Milliseconds:
2197 case eCSSUnit_FlexFraction:
2198 break;
2199
2200 default:
2201 MOZ_ASSERT(false, "bad nsCSSUnit");
2202 break;
2203 }
2204
2205 return n;
2206 }
2207
2208 // --- nsCSSValueList -----------------
2209
~nsCSSValueList()2210 nsCSSValueList::~nsCSSValueList()
2211 {
2212 MOZ_COUNT_DTOR(nsCSSValueList);
2213 NS_CSS_DELETE_LIST_MEMBER(nsCSSValueList, this, mNext);
2214 }
2215
2216 nsCSSValueList*
Clone() const2217 nsCSSValueList::Clone() const
2218 {
2219 nsCSSValueList* result = new nsCSSValueList(*this);
2220 nsCSSValueList* dest = result;
2221 const nsCSSValueList* src = this->mNext;
2222 while (src) {
2223 dest->mNext = new nsCSSValueList(*src);
2224 dest = dest->mNext;
2225 src = src->mNext;
2226 }
2227
2228 MOZ_ASSERT(result, "shouldn't return null; supposed to be infallible");
2229 return result;
2230 }
2231
2232 void
CloneInto(nsCSSValueList * aList) const2233 nsCSSValueList::CloneInto(nsCSSValueList* aList) const
2234 {
2235 NS_ASSERTION(!aList->mNext, "Must be an empty list!");
2236 aList->mValue = mValue;
2237 aList->mNext = mNext ? mNext->Clone() : nullptr;
2238 }
2239
2240 static void
AppendValueListToString(const nsCSSValueList * val,nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization)2241 AppendValueListToString(const nsCSSValueList* val,
2242 nsCSSPropertyID aProperty, nsAString& aResult,
2243 nsCSSValue::Serialization aSerialization)
2244 {
2245 for (;;) {
2246 val->mValue.AppendToString(aProperty, aResult, aSerialization);
2247 val = val->mNext;
2248 if (!val)
2249 break;
2250
2251 if (nsCSSProps::PropHasFlags(aProperty,
2252 CSS_PROPERTY_VALUE_LIST_USES_COMMAS))
2253 aResult.Append(char16_t(','));
2254 aResult.Append(char16_t(' '));
2255 }
2256 }
2257
2258 static void
AppendGridTemplateToString(const nsCSSValueList * val,nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization)2259 AppendGridTemplateToString(const nsCSSValueList* val,
2260 nsCSSPropertyID aProperty, nsAString& aResult,
2261 nsCSSValue::Serialization aSerialization)
2262 {
2263 // This is called for the "list" that's the top-level value of the property.
2264 bool isSubgrid = false;
2265 for (;;) {
2266 bool addSpaceSeparator = true;
2267 nsCSSUnit unit = val->mValue.GetUnit();
2268
2269 if (unit == eCSSUnit_Enumerated &&
2270 val->mValue.GetIntValue() == NS_STYLE_GRID_TEMPLATE_SUBGRID) {
2271 MOZ_ASSERT(!isSubgrid, "saw subgrid once already");
2272 isSubgrid = true;
2273 aResult.AppendLiteral("subgrid");
2274
2275 } else if (unit == eCSSUnit_Pair) {
2276 // This is a repeat 'auto-fill' / 'auto-fit'.
2277 const nsCSSValuePair& pair = val->mValue.GetPairValue();
2278 switch (pair.mXValue.GetIntValue()) {
2279 case NS_STYLE_GRID_REPEAT_AUTO_FILL:
2280 aResult.AppendLiteral("repeat(auto-fill, ");
2281 break;
2282 case NS_STYLE_GRID_REPEAT_AUTO_FIT:
2283 aResult.AppendLiteral("repeat(auto-fit, ");
2284 break;
2285 default:
2286 MOZ_ASSERT_UNREACHABLE("unexpected enum value");
2287 }
2288 const nsCSSValueList* repeatList = pair.mYValue.GetListValue();
2289 if (repeatList->mValue.GetUnit() != eCSSUnit_Null) {
2290 aResult.Append('[');
2291 AppendValueListToString(repeatList->mValue.GetListValue(), aProperty,
2292 aResult, aSerialization);
2293 aResult.Append(']');
2294 if (!isSubgrid) {
2295 aResult.Append(' ');
2296 }
2297 } else if (isSubgrid) {
2298 aResult.AppendLiteral("[]");
2299 }
2300 if (!isSubgrid) {
2301 repeatList = repeatList->mNext;
2302 repeatList->mValue.AppendToString(aProperty, aResult, aSerialization);
2303 repeatList = repeatList->mNext;
2304 if (repeatList->mValue.GetUnit() != eCSSUnit_Null) {
2305 aResult.AppendLiteral(" [");
2306 AppendValueListToString(repeatList->mValue.GetListValue(), aProperty,
2307 aResult, aSerialization);
2308 aResult.Append(']');
2309 }
2310 }
2311 aResult.Append(')');
2312
2313 } else if (unit == eCSSUnit_Null) {
2314 // Empty or omitted <line-names>.
2315 if (isSubgrid) {
2316 aResult.AppendLiteral("[]");
2317 } else {
2318 // Serializes to nothing.
2319 addSpaceSeparator = false; // Avoid a double space.
2320 }
2321
2322 } else if (unit == eCSSUnit_List || unit == eCSSUnit_ListDep) {
2323 // Non-empty <line-names>
2324 aResult.Append('[');
2325 AppendValueListToString(val->mValue.GetListValue(), aProperty,
2326 aResult, aSerialization);
2327 aResult.Append(']');
2328
2329 } else {
2330 // <track-size>
2331 val->mValue.AppendToString(aProperty, aResult, aSerialization);
2332 if (!isSubgrid &&
2333 val->mNext &&
2334 val->mNext->mValue.GetUnit() == eCSSUnit_Null &&
2335 !val->mNext->mNext) {
2336 // Break out of the loop early to avoid a trailing space.
2337 break;
2338 }
2339 }
2340
2341 val = val->mNext;
2342 if (!val) {
2343 break;
2344 }
2345
2346 if (addSpaceSeparator) {
2347 aResult.Append(char16_t(' '));
2348 }
2349 }
2350 }
2351
2352 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization) const2353 nsCSSValueList::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
2354 nsCSSValue::Serialization aSerialization) const
2355 {
2356 if (aProperty == eCSSProperty_grid_template_columns ||
2357 aProperty == eCSSProperty_grid_template_rows) {
2358 AppendGridTemplateToString(this, aProperty, aResult, aSerialization);
2359 } else {
2360 AppendValueListToString(this, aProperty, aResult, aSerialization);
2361 }
2362 }
2363
2364 /* static */ bool
Equal(const nsCSSValueList * aList1,const nsCSSValueList * aList2)2365 nsCSSValueList::Equal(const nsCSSValueList* aList1,
2366 const nsCSSValueList* aList2)
2367 {
2368 if (aList1 == aList2) {
2369 return true;
2370 }
2371
2372 const nsCSSValueList *p1 = aList1, *p2 = aList2;
2373 for ( ; p1 && p2; p1 = p1->mNext, p2 = p2->mNext) {
2374 if (p1->mValue != p2->mValue)
2375 return false;
2376 }
2377 return !p1 && !p2; // true if same length, false otherwise
2378 }
2379
2380 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2381 nsCSSValueList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2382 {
2383 size_t n = 0;
2384 const nsCSSValueList* v = this;
2385 while (v) {
2386 n += aMallocSizeOf(v);
2387 n += v->mValue.SizeOfExcludingThis(aMallocSizeOf);
2388 v = v->mNext;
2389 }
2390 return n;
2391 }
2392
2393 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2394 nsCSSValueList_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2395 {
2396 // Only measure it if it's unshared, to avoid double-counting.
2397 size_t n = 0;
2398 if (mRefCnt <= 1) {
2399 n += aMallocSizeOf(this);
2400 n += mValue.SizeOfExcludingThis(aMallocSizeOf);
2401 n += mNext ? mNext->SizeOfIncludingThis(aMallocSizeOf) : 0;
2402 }
2403 return n;
2404 }
2405
2406 // --- nsCSSValueSharedList -----------------
2407
~nsCSSValueSharedList()2408 nsCSSValueSharedList::~nsCSSValueSharedList()
2409 {
2410 MOZ_COUNT_DTOR(nsCSSValueSharedList);
2411 if (mHead) {
2412 NS_CSS_DELETE_LIST_MEMBER(nsCSSValueList, mHead, mNext);
2413 delete mHead;
2414 }
2415 }
2416
2417 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization) const2418 nsCSSValueSharedList::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
2419 nsCSSValue::Serialization aSerialization) const
2420 {
2421 if (mHead) {
2422 mHead->AppendToString(aProperty, aResult, aSerialization);
2423 }
2424 }
2425
2426 bool
operator ==(const nsCSSValueSharedList & aOther) const2427 nsCSSValueSharedList::operator==(const nsCSSValueSharedList& aOther) const
2428 {
2429 return nsCSSValueList::Equal(mHead, aOther.mHead);
2430 }
2431
2432 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2433 nsCSSValueSharedList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2434 {
2435 // Only measure it if it's unshared, to avoid double-counting.
2436 size_t n = 0;
2437 if (mRefCnt <= 1) {
2438 n += aMallocSizeOf(this);
2439 n += mHead->SizeOfIncludingThis(aMallocSizeOf);
2440 }
2441 return n;
2442 }
2443
2444 // --- nsCSSRect -----------------
2445
nsCSSRect(void)2446 nsCSSRect::nsCSSRect(void)
2447 {
2448 MOZ_COUNT_CTOR(nsCSSRect);
2449 }
2450
nsCSSRect(const nsCSSRect & aCopy)2451 nsCSSRect::nsCSSRect(const nsCSSRect& aCopy)
2452 : mTop(aCopy.mTop),
2453 mRight(aCopy.mRight),
2454 mBottom(aCopy.mBottom),
2455 mLeft(aCopy.mLeft)
2456 {
2457 MOZ_COUNT_CTOR(nsCSSRect);
2458 }
2459
~nsCSSRect()2460 nsCSSRect::~nsCSSRect()
2461 {
2462 MOZ_COUNT_DTOR(nsCSSRect);
2463 }
2464
2465 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization) const2466 nsCSSRect::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
2467 nsCSSValue::Serialization aSerialization) const
2468 {
2469 MOZ_ASSERT(mTop.GetUnit() != eCSSUnit_Null &&
2470 mTop.GetUnit() != eCSSUnit_Inherit &&
2471 mTop.GetUnit() != eCSSUnit_Initial &&
2472 mTop.GetUnit() != eCSSUnit_Unset,
2473 "parser should have used a bare value");
2474
2475 if (eCSSProperty_border_image_slice == aProperty ||
2476 eCSSProperty_border_image_width == aProperty ||
2477 eCSSProperty_border_image_outset == aProperty ||
2478 eCSSProperty_DOM == aProperty) {
2479 NS_NAMED_LITERAL_STRING(space, " ");
2480
2481 mTop.AppendToString(aProperty, aResult, aSerialization);
2482 aResult.Append(space);
2483 mRight.AppendToString(aProperty, aResult, aSerialization);
2484 aResult.Append(space);
2485 mBottom.AppendToString(aProperty, aResult, aSerialization);
2486 aResult.Append(space);
2487 mLeft.AppendToString(aProperty, aResult, aSerialization);
2488 } else {
2489 NS_NAMED_LITERAL_STRING(comma, ", ");
2490
2491 aResult.AppendLiteral("rect(");
2492 mTop.AppendToString(aProperty, aResult, aSerialization);
2493 aResult.Append(comma);
2494 mRight.AppendToString(aProperty, aResult, aSerialization);
2495 aResult.Append(comma);
2496 mBottom.AppendToString(aProperty, aResult, aSerialization);
2497 aResult.Append(comma);
2498 mLeft.AppendToString(aProperty, aResult, aSerialization);
2499 aResult.Append(char16_t(')'));
2500 }
2501 }
2502
SetAllSidesTo(const nsCSSValue & aValue)2503 void nsCSSRect::SetAllSidesTo(const nsCSSValue& aValue)
2504 {
2505 mTop = aValue;
2506 mRight = aValue;
2507 mBottom = aValue;
2508 mLeft = aValue;
2509 }
2510
2511 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2512 nsCSSRect_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2513 {
2514 // Only measure it if it's unshared, to avoid double-counting.
2515 size_t n = 0;
2516 if (mRefCnt <= 1) {
2517 n += aMallocSizeOf(this);
2518 n += mTop .SizeOfExcludingThis(aMallocSizeOf);
2519 n += mRight .SizeOfExcludingThis(aMallocSizeOf);
2520 n += mBottom.SizeOfExcludingThis(aMallocSizeOf);
2521 n += mLeft .SizeOfExcludingThis(aMallocSizeOf);
2522 }
2523 return n;
2524 }
2525
2526 static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
2527 NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
2528 "box side constants not top/right/bottom/left == 0/1/2/3");
2529
2530 /* static */ const nsCSSRect::side_type nsCSSRect::sides[4] = {
2531 &nsCSSRect::mTop,
2532 &nsCSSRect::mRight,
2533 &nsCSSRect::mBottom,
2534 &nsCSSRect::mLeft,
2535 };
2536
2537 // --- nsCSSValuePair -----------------
2538
2539 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization) const2540 nsCSSValuePair::AppendToString(nsCSSPropertyID aProperty,
2541 nsAString& aResult,
2542 nsCSSValue::Serialization aSerialization) const
2543 {
2544 mXValue.AppendToString(aProperty, aResult, aSerialization);
2545 if (mYValue.GetUnit() != eCSSUnit_Null) {
2546 aResult.Append(char16_t(' '));
2547 mYValue.AppendToString(aProperty, aResult, aSerialization);
2548 }
2549 }
2550
2551 size_t
SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2552 nsCSSValuePair::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2553 {
2554 size_t n = 0;
2555 n += mXValue.SizeOfExcludingThis(aMallocSizeOf);
2556 n += mYValue.SizeOfExcludingThis(aMallocSizeOf);
2557 return n;
2558 }
2559
2560 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2561 nsCSSValuePair_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2562 {
2563 // Only measure it if it's unshared, to avoid double-counting.
2564 size_t n = 0;
2565 if (mRefCnt <= 1) {
2566 n += aMallocSizeOf(this);
2567 n += mXValue.SizeOfExcludingThis(aMallocSizeOf);
2568 n += mYValue.SizeOfExcludingThis(aMallocSizeOf);
2569 }
2570 return n;
2571 }
2572
2573 // --- nsCSSValueTriplet -----------------
2574
2575 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization) const2576 nsCSSValueTriplet::AppendToString(nsCSSPropertyID aProperty,
2577 nsAString& aResult,
2578 nsCSSValue::Serialization aSerialization) const
2579 {
2580 mXValue.AppendToString(aProperty, aResult, aSerialization);
2581 if (mYValue.GetUnit() != eCSSUnit_Null) {
2582 aResult.Append(char16_t(' '));
2583 mYValue.AppendToString(aProperty, aResult, aSerialization);
2584 if (mZValue.GetUnit() != eCSSUnit_Null) {
2585 aResult.Append(char16_t(' '));
2586 mZValue.AppendToString(aProperty, aResult, aSerialization);
2587 }
2588 }
2589 }
2590
2591 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2592 nsCSSValueTriplet_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2593 {
2594 // Only measure it if it's unshared, to avoid double-counting.
2595 size_t n = 0;
2596 if (mRefCnt <= 1) {
2597 n += aMallocSizeOf(this);
2598 n += mXValue.SizeOfExcludingThis(aMallocSizeOf);
2599 n += mYValue.SizeOfExcludingThis(aMallocSizeOf);
2600 n += mZValue.SizeOfExcludingThis(aMallocSizeOf);
2601 }
2602 return n;
2603 }
2604
2605 // --- nsCSSValuePairList -----------------
2606
~nsCSSValuePairList()2607 nsCSSValuePairList::~nsCSSValuePairList()
2608 {
2609 MOZ_COUNT_DTOR(nsCSSValuePairList);
2610 NS_CSS_DELETE_LIST_MEMBER(nsCSSValuePairList, this, mNext);
2611 }
2612
2613 nsCSSValuePairList*
Clone() const2614 nsCSSValuePairList::Clone() const
2615 {
2616 nsCSSValuePairList* result = new nsCSSValuePairList(*this);
2617 nsCSSValuePairList* dest = result;
2618 const nsCSSValuePairList* src = this->mNext;
2619 while (src) {
2620 dest->mNext = new nsCSSValuePairList(*src);
2621 dest = dest->mNext;
2622 src = src->mNext;
2623 }
2624
2625 MOZ_ASSERT(result, "shouldn't return null; supposed to be infallible");
2626 return result;
2627 }
2628
2629 void
AppendToString(nsCSSPropertyID aProperty,nsAString & aResult,nsCSSValue::Serialization aSerialization) const2630 nsCSSValuePairList::AppendToString(nsCSSPropertyID aProperty,
2631 nsAString& aResult,
2632 nsCSSValue::Serialization aSerialization) const
2633 {
2634 const nsCSSValuePairList* item = this;
2635 for (;;) {
2636 MOZ_ASSERT(item->mXValue.GetUnit() != eCSSUnit_Null,
2637 "unexpected null unit");
2638 item->mXValue.AppendToString(aProperty, aResult, aSerialization);
2639 if (item->mXValue.GetUnit() != eCSSUnit_Inherit &&
2640 item->mXValue.GetUnit() != eCSSUnit_Initial &&
2641 item->mXValue.GetUnit() != eCSSUnit_Unset &&
2642 item->mYValue.GetUnit() != eCSSUnit_Null) {
2643 aResult.Append(char16_t(' '));
2644 item->mYValue.AppendToString(aProperty, aResult, aSerialization);
2645 }
2646 item = item->mNext;
2647 if (!item)
2648 break;
2649
2650 if (nsCSSProps::PropHasFlags(aProperty,
2651 CSS_PROPERTY_VALUE_LIST_USES_COMMAS) ||
2652 aProperty == eCSSProperty_clip_path ||
2653 aProperty == eCSSProperty_shape_outside)
2654 aResult.Append(char16_t(','));
2655 aResult.Append(char16_t(' '));
2656 }
2657 }
2658
2659 /* static */ bool
Equal(const nsCSSValuePairList * aList1,const nsCSSValuePairList * aList2)2660 nsCSSValuePairList::Equal(const nsCSSValuePairList* aList1,
2661 const nsCSSValuePairList* aList2)
2662 {
2663 if (aList1 == aList2) {
2664 return true;
2665 }
2666
2667 const nsCSSValuePairList *p1 = aList1, *p2 = aList2;
2668 for ( ; p1 && p2; p1 = p1->mNext, p2 = p2->mNext) {
2669 if (p1->mXValue != p2->mXValue ||
2670 p1->mYValue != p2->mYValue)
2671 return false;
2672 }
2673 return !p1 && !p2; // true if same length, false otherwise
2674 }
2675
2676 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2677 nsCSSValuePairList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2678 {
2679 size_t n = 0;
2680 const nsCSSValuePairList* v = this;
2681 while (v) {
2682 n += aMallocSizeOf(v);
2683 n += v->mXValue.SizeOfExcludingThis(aMallocSizeOf);
2684 n += v->mYValue.SizeOfExcludingThis(aMallocSizeOf);
2685 v = v->mNext;
2686 }
2687 return n;
2688 }
2689
2690 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2691 nsCSSValuePairList_heap::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2692 {
2693 // Only measure it if it's unshared, to avoid double-counting.
2694 size_t n = 0;
2695 if (mRefCnt <= 1) {
2696 n += aMallocSizeOf(this);
2697 n += mXValue.SizeOfExcludingThis(aMallocSizeOf);
2698 n += mYValue.SizeOfExcludingThis(aMallocSizeOf);
2699 n += mNext ? mNext->SizeOfIncludingThis(aMallocSizeOf) : 0;
2700 }
2701 return n;
2702 }
2703
2704 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2705 nsCSSValue::Array::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2706 {
2707 size_t n = aMallocSizeOf(this);
2708 for (size_t i = 0; i < mCount; i++) {
2709 n += mArray[i].SizeOfExcludingThis(aMallocSizeOf);
2710 }
2711 return n;
2712 }
2713
URLValueData(already_AddRefed<PtrHolder<nsIURI>> aURI,nsStringBuffer * aString,already_AddRefed<PtrHolder<nsIURI>> aBaseURI,already_AddRefed<PtrHolder<nsIURI>> aReferrer,already_AddRefed<PtrHolder<nsIPrincipal>> aOriginPrincipal)2714 css::URLValueData::URLValueData(already_AddRefed<PtrHolder<nsIURI>> aURI,
2715 nsStringBuffer* aString,
2716 already_AddRefed<PtrHolder<nsIURI>> aBaseURI,
2717 already_AddRefed<PtrHolder<nsIURI>> aReferrer,
2718 already_AddRefed<PtrHolder<nsIPrincipal>>
2719 aOriginPrincipal)
2720 : mURI(Move(aURI))
2721 , mBaseURI(Move(aBaseURI))
2722 , mString(aString)
2723 , mReferrer(Move(aReferrer))
2724 , mOriginPrincipal(Move(aOriginPrincipal))
2725 , mURIResolved(true)
2726 , mIsLocalRef(IsLocalRefURL(aString))
2727 {
2728 MOZ_ASSERT(mString);
2729 MOZ_ASSERT(mBaseURI);
2730 MOZ_ASSERT(mOriginPrincipal);
2731 }
2732
URLValueData(nsStringBuffer * aString,already_AddRefed<PtrHolder<nsIURI>> aBaseURI,already_AddRefed<PtrHolder<nsIURI>> aReferrer,already_AddRefed<PtrHolder<nsIPrincipal>> aOriginPrincipal)2733 css::URLValueData::URLValueData(nsStringBuffer* aString,
2734 already_AddRefed<PtrHolder<nsIURI>> aBaseURI,
2735 already_AddRefed<PtrHolder<nsIURI>> aReferrer,
2736 already_AddRefed<PtrHolder<nsIPrincipal>>
2737 aOriginPrincipal)
2738 : mBaseURI(Move(aBaseURI))
2739 , mString(aString)
2740 , mReferrer(Move(aReferrer))
2741 , mOriginPrincipal(Move(aOriginPrincipal))
2742 , mURIResolved(false)
2743 , mIsLocalRef(IsLocalRefURL(aString))
2744 {
2745 MOZ_ASSERT(aString);
2746 MOZ_ASSERT(mBaseURI);
2747 MOZ_ASSERT(mOriginPrincipal);
2748 }
2749
2750 bool
Equals(const URLValueData & aOther) const2751 css::URLValueData::Equals(const URLValueData& aOther) const
2752 {
2753 MOZ_ASSERT(NS_IsMainThread());
2754
2755 bool eq;
2756 // Cast away const so we can call nsIPrincipal::Equals.
2757 auto& self = *const_cast<URLValueData*>(this);
2758 auto& other = const_cast<URLValueData&>(aOther);
2759 return NS_strcmp(nsCSSValue::GetBufferValue(mString),
2760 nsCSSValue::GetBufferValue(aOther.mString)) == 0 &&
2761 (GetURI() == aOther.GetURI() || // handles null == null
2762 (mURI && aOther.mURI &&
2763 NS_SUCCEEDED(mURI->Equals(aOther.mURI, &eq)) &&
2764 eq)) &&
2765 (mBaseURI == aOther.mBaseURI ||
2766 (NS_SUCCEEDED(self.mBaseURI.get()->Equals(other.mBaseURI.get(), &eq)) &&
2767 eq)) &&
2768 (mOriginPrincipal == aOther.mOriginPrincipal ||
2769 self.mOriginPrincipal.get()->Equals(other.mOriginPrincipal.get())) &&
2770 mIsLocalRef == aOther.mIsLocalRef;
2771 }
2772
2773 bool
DefinitelyEqualURIs(const URLValueData & aOther) const2774 css::URLValueData::DefinitelyEqualURIs(const URLValueData& aOther) const
2775 {
2776 return mBaseURI == aOther.mBaseURI &&
2777 (mString == aOther.mString ||
2778 NS_strcmp(nsCSSValue::GetBufferValue(mString),
2779 nsCSSValue::GetBufferValue(aOther.mString)) == 0);
2780 }
2781
2782 bool
DefinitelyEqualURIsAndPrincipal(const URLValueData & aOther) const2783 css::URLValueData::DefinitelyEqualURIsAndPrincipal(
2784 const URLValueData& aOther) const
2785 {
2786 return mOriginPrincipal == aOther.mOriginPrincipal &&
2787 DefinitelyEqualURIs(aOther);
2788 }
2789
2790 nsIURI*
GetURI() const2791 css::URLValueData::GetURI() const
2792 {
2793 MOZ_ASSERT(NS_IsMainThread());
2794
2795 if (!mURIResolved) {
2796 MOZ_ASSERT(!mURI);
2797 nsCOMPtr<nsIURI> newURI;
2798 NS_NewURI(getter_AddRefs(newURI),
2799 NS_ConvertUTF16toUTF8(nsCSSValue::GetBufferValue(mString)),
2800 nullptr, const_cast<nsIURI*>(mBaseURI.get()));
2801 mURI = new PtrHolder<nsIURI>(newURI.forget());
2802 mURIResolved = true;
2803 }
2804
2805 return mURI;
2806 }
2807
2808 already_AddRefed<nsIURI>
ResolveLocalRef(nsIURI * aURI) const2809 css::URLValueData::ResolveLocalRef(nsIURI* aURI) const
2810 {
2811 nsCOMPtr<nsIURI> result = GetURI();
2812
2813 if (result && mIsLocalRef) {
2814 nsCString ref;
2815 mURI->GetRef(ref);
2816
2817 aURI->Clone(getter_AddRefs(result));
2818 result->SetRef(ref);
2819 }
2820
2821 return result.forget();
2822 }
2823
2824 already_AddRefed<nsIURI>
ResolveLocalRef(nsIContent * aContent) const2825 css::URLValueData::ResolveLocalRef(nsIContent* aContent) const
2826 {
2827 nsCOMPtr<nsIURI> url = aContent->GetBaseURI();
2828 return ResolveLocalRef(url);
2829 }
2830
2831 void
GetSourceString(nsString & aRef) const2832 css::URLValueData::GetSourceString(nsString& aRef) const
2833 {
2834 nsIURI* uri = GetURI();
2835 if (!uri) {
2836 aRef.Truncate();
2837 return;
2838 }
2839
2840 nsCString cref;
2841 if (mIsLocalRef) {
2842 // XXXheycam It's possible we can just return mString in this case, since
2843 // it should be the "#fragment" string the URLValueData was created with.
2844 uri->GetRef(cref);
2845 cref.Insert('#', 0);
2846 } else {
2847 // It's not entirely clear how to best handle failure here. Ensuring the
2848 // string is empty seems safest.
2849 nsresult rv = uri->GetSpec(cref);
2850 if (NS_FAILED(rv)) {
2851 cref.Truncate();
2852 }
2853 }
2854
2855 aRef = NS_ConvertUTF8toUTF16(cref);
2856 }
2857
2858 bool
EqualsExceptRef(nsIURI * aURI) const2859 css::URLValueData::EqualsExceptRef(nsIURI* aURI) const
2860 {
2861 nsIURI* uri = GetURI();
2862 if (!uri) {
2863 return false;
2864 }
2865
2866 bool ret = false;
2867 uri->EqualsExceptRef(aURI, &ret);
2868 return ret;
2869 }
2870
2871 size_t
SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2872 css::URLValueData::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2873 {
2874 size_t n = 0;
2875 n += mString->SizeOfIncludingThisIfUnshared(aMallocSizeOf);
2876
2877 // Measurement of the following members may be added later if DMD finds it
2878 // is worthwhile:
2879 // - mURI
2880 // - mReferrer
2881 // - mOriginPrincipal
2882 return n;
2883 }
2884
URLValue(nsStringBuffer * aString,nsIURI * aBaseURI,nsIURI * aReferrer,nsIPrincipal * aOriginPrincipal)2885 URLValue::URLValue(nsStringBuffer* aString, nsIURI* aBaseURI, nsIURI* aReferrer,
2886 nsIPrincipal* aOriginPrincipal)
2887 : URLValueData(aString,
2888 do_AddRef(new PtrHolder<nsIURI>(aBaseURI)),
2889 do_AddRef(new PtrHolder<nsIURI>(aReferrer)),
2890 do_AddRef(new PtrHolder<nsIPrincipal>(aOriginPrincipal)))
2891 {
2892 MOZ_ASSERT(NS_IsMainThread());
2893 }
2894
URLValue(nsIURI * aURI,nsStringBuffer * aString,nsIURI * aBaseURI,nsIURI * aReferrer,nsIPrincipal * aOriginPrincipal)2895 URLValue::URLValue(nsIURI* aURI, nsStringBuffer* aString, nsIURI* aBaseURI,
2896 nsIURI* aReferrer, nsIPrincipal* aOriginPrincipal)
2897 : URLValueData(do_AddRef(new PtrHolder<nsIURI>(aURI)),
2898 aString,
2899 do_AddRef(new PtrHolder<nsIURI>(aBaseURI)),
2900 do_AddRef(new PtrHolder<nsIURI>(aReferrer)),
2901 do_AddRef(new PtrHolder<nsIPrincipal>(aOriginPrincipal)))
2902 {
2903 MOZ_ASSERT(NS_IsMainThread());
2904 }
2905
2906 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const2907 css::URLValue::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
2908 {
2909 // Only measure it if it's unshared, to avoid double-counting.
2910 size_t n = 0;
2911 if (mRefCnt <= 1) {
2912 n += aMallocSizeOf(this);
2913 n += URLValueData::SizeOfExcludingThis(aMallocSizeOf);
2914 }
2915 return n;
2916 }
2917
ImageValue(nsIURI * aURI,nsStringBuffer * aString,nsIURI * aBaseURI,nsIURI * aReferrer,nsIPrincipal * aOriginPrincipal,nsIDocument * aDocument)2918 css::ImageValue::ImageValue(nsIURI* aURI, nsStringBuffer* aString,
2919 nsIURI* aBaseURI, nsIURI* aReferrer,
2920 nsIPrincipal* aOriginPrincipal,
2921 nsIDocument* aDocument)
2922 : URLValueData(do_AddRef(new PtrHolder<nsIURI>(aURI)),
2923 aString,
2924 do_AddRef(new PtrHolder<nsIURI>(aBaseURI, false)),
2925 do_AddRef(new PtrHolder<nsIURI>(aReferrer)),
2926 do_AddRef(new PtrHolder<nsIPrincipal>(aOriginPrincipal)))
2927 {
2928 Initialize(aDocument);
2929 }
2930
ImageValue(nsStringBuffer * aString,already_AddRefed<PtrHolder<nsIURI>> aBaseURI,already_AddRefed<PtrHolder<nsIURI>> aReferrer,already_AddRefed<PtrHolder<nsIPrincipal>> aOriginPrincipal)2931 css::ImageValue::ImageValue(
2932 nsStringBuffer* aString,
2933 already_AddRefed<PtrHolder<nsIURI>> aBaseURI,
2934 already_AddRefed<PtrHolder<nsIURI>> aReferrer,
2935 already_AddRefed<PtrHolder<nsIPrincipal>> aOriginPrincipal)
2936 : URLValueData(aString, Move(aBaseURI), Move(aReferrer),
2937 Move(aOriginPrincipal))
2938 {
2939 }
2940
2941 void
Initialize(nsIDocument * aDocument)2942 css::ImageValue::Initialize(nsIDocument* aDocument)
2943 {
2944 MOZ_ASSERT(NS_IsMainThread());
2945 MOZ_ASSERT(!mInitialized);
2946
2947 // NB: If aDocument is not the original document, we may not be able to load
2948 // images from aDocument. Instead we do the image load from the original doc
2949 // and clone it to aDocument.
2950 nsIDocument* loadingDoc = aDocument->GetOriginalDocument();
2951 if (!loadingDoc) {
2952 loadingDoc = aDocument;
2953 }
2954
2955 loadingDoc->StyleImageLoader()->LoadImage(GetURI(), mOriginPrincipal,
2956 mReferrer, this);
2957
2958 if (loadingDoc != aDocument) {
2959 aDocument->StyleImageLoader()->MaybeRegisterCSSImage(this);
2960 }
2961
2962 #ifdef DEBUG
2963 mInitialized = true;
2964 #endif
2965 }
2966
~ImageValue()2967 css::ImageValue::~ImageValue()
2968 {
2969 MOZ_ASSERT(NS_IsMainThread());
2970
2971 for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) {
2972 nsIDocument* doc = iter.Key();
2973 RefPtr<imgRequestProxy>& proxy = iter.Data();
2974
2975 if (doc) {
2976 doc->StyleImageLoader()->DeregisterCSSImage(this);
2977 }
2978
2979 if (proxy) {
2980 proxy->CancelAndForgetObserver(NS_BINDING_ABORTED);
2981 }
2982
2983 iter.Remove();
2984 }
2985 }
2986
2987 size_t
SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const2988 css::ComplexColorValue::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
2989 {
2990 // Only measure it if it's unshared, to avoid double-counting.
2991 size_t n = 0;
2992 if (mRefCnt <= 1) {
2993 n += aMallocSizeOf(this);
2994 }
2995 return n;
2996 }
2997
nsCSSValueGradientStop()2998 nsCSSValueGradientStop::nsCSSValueGradientStop()
2999 : mLocation(eCSSUnit_None),
3000 mColor(eCSSUnit_Null),
3001 mIsInterpolationHint(false)
3002 {
3003 MOZ_COUNT_CTOR(nsCSSValueGradientStop);
3004 }
3005
nsCSSValueGradientStop(const nsCSSValueGradientStop & aOther)3006 nsCSSValueGradientStop::nsCSSValueGradientStop(const nsCSSValueGradientStop& aOther)
3007 : mLocation(aOther.mLocation),
3008 mColor(aOther.mColor),
3009 mIsInterpolationHint(aOther.mIsInterpolationHint)
3010 {
3011 MOZ_COUNT_CTOR(nsCSSValueGradientStop);
3012 }
3013
~nsCSSValueGradientStop()3014 nsCSSValueGradientStop::~nsCSSValueGradientStop()
3015 {
3016 MOZ_COUNT_DTOR(nsCSSValueGradientStop);
3017 }
3018
3019 size_t
SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const3020 nsCSSValueGradientStop::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
3021 {
3022 size_t n = 0;
3023 n += mLocation.SizeOfExcludingThis(aMallocSizeOf);
3024 n += mColor .SizeOfExcludingThis(aMallocSizeOf);
3025 return n;
3026 }
3027
nsCSSValueGradient(bool aIsRadial,bool aIsRepeating)3028 nsCSSValueGradient::nsCSSValueGradient(bool aIsRadial,
3029 bool aIsRepeating)
3030 : mIsRadial(aIsRadial),
3031 mIsRepeating(aIsRepeating),
3032 mIsLegacySyntax(false),
3033 mIsExplicitSize(false),
3034 mBgPos(eCSSUnit_None),
3035 mAngle(eCSSUnit_None)
3036 {
3037 mRadialValues[0].SetNoneValue();
3038 mRadialValues[1].SetNoneValue();
3039 }
3040
3041 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const3042 nsCSSValueGradient::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
3043 {
3044 // Only measure it if it's unshared, to avoid double-counting.
3045 size_t n = 0;
3046 if (mRefCnt <= 1) {
3047 n += aMallocSizeOf(this);
3048 n += mBgPos.SizeOfExcludingThis(aMallocSizeOf);
3049 n += mAngle.SizeOfExcludingThis(aMallocSizeOf);
3050 n += mRadialValues[0].SizeOfExcludingThis(aMallocSizeOf);
3051 n += mRadialValues[1].SizeOfExcludingThis(aMallocSizeOf);
3052 n += mStops.ShallowSizeOfExcludingThis(aMallocSizeOf);
3053 for (uint32_t i = 0; i < mStops.Length(); i++) {
3054 n += mStops[i].SizeOfExcludingThis(aMallocSizeOf);
3055 }
3056 }
3057 return n;
3058 }
3059
3060 // --- nsCSSValueTokenStream ------------
3061
nsCSSValueTokenStream()3062 nsCSSValueTokenStream::nsCSSValueTokenStream()
3063 : mPropertyID(eCSSProperty_UNKNOWN)
3064 , mShorthandPropertyID(eCSSProperty_UNKNOWN)
3065 , mLevel(SheetType::Count)
3066 {
3067 MOZ_COUNT_CTOR(nsCSSValueTokenStream);
3068 }
3069
~nsCSSValueTokenStream()3070 nsCSSValueTokenStream::~nsCSSValueTokenStream()
3071 {
3072 MOZ_COUNT_DTOR(nsCSSValueTokenStream);
3073 }
3074
3075 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const3076 nsCSSValueTokenStream::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
3077 {
3078 // Only measure it if it's unshared, to avoid double-counting.
3079 size_t n = 0;
3080 if (mRefCnt <= 1) {
3081 n += aMallocSizeOf(this);
3082 n += mTokenStream.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
3083 }
3084 return n;
3085 }
3086
3087 // --- nsCSSValueFloatColor -------------
3088
3089 bool
operator ==(nsCSSValueFloatColor & aOther) const3090 nsCSSValueFloatColor::operator==(nsCSSValueFloatColor& aOther) const
3091 {
3092 return mComponent1 == aOther.mComponent1 &&
3093 mComponent2 == aOther.mComponent2 &&
3094 mComponent3 == aOther.mComponent3 &&
3095 mAlpha == aOther.mAlpha;
3096 }
3097
3098 nscolor
GetColorValue(nsCSSUnit aUnit) const3099 nsCSSValueFloatColor::GetColorValue(nsCSSUnit aUnit) const
3100 {
3101 MOZ_ASSERT(nsCSSValue::IsFloatColorUnit(aUnit), "unexpected unit");
3102
3103 // We should clamp each component value since eCSSUnit_PercentageRGBColor
3104 // and eCSSUnit_PercentageRGBAColor may store values greater than 1.0.
3105 if (aUnit == eCSSUnit_PercentageRGBColor ||
3106 aUnit == eCSSUnit_PercentageRGBAColor) {
3107 return NS_RGBA(
3108 // We need to clamp before multiplying by 255.0f to avoid overflow.
3109 NSToIntRound(mozilla::clamped(mComponent1, 0.0f, 1.0f) * 255.0f),
3110 NSToIntRound(mozilla::clamped(mComponent2, 0.0f, 1.0f) * 255.0f),
3111 NSToIntRound(mozilla::clamped(mComponent3, 0.0f, 1.0f) * 255.0f),
3112 NSToIntRound(mozilla::clamped(mAlpha, 0.0f, 1.0f) * 255.0f));
3113 }
3114
3115 // HSL color
3116 MOZ_ASSERT(aUnit == eCSSUnit_HSLColor ||
3117 aUnit == eCSSUnit_HSLAColor);
3118 nscolor hsl = NS_HSL2RGB(mComponent1, mComponent2, mComponent3);
3119 return NS_RGBA(NS_GET_R(hsl),
3120 NS_GET_G(hsl),
3121 NS_GET_B(hsl),
3122 NSToIntRound(mAlpha * 255.0f));
3123 }
3124
3125 bool
IsNonTransparentColor() const3126 nsCSSValueFloatColor::IsNonTransparentColor() const
3127 {
3128 return mAlpha > 0.0f;
3129 }
3130
3131 void
AppendToString(nsCSSUnit aUnit,nsAString & aResult) const3132 nsCSSValueFloatColor::AppendToString(nsCSSUnit aUnit, nsAString& aResult) const
3133 {
3134 // Similar to the rgb()/rgba() case in nsCSSValue::AppendToString. We omit the
3135 // alpha component if it's equal to 1.0f (full opaque). Also, we try to
3136 // preserve the author-specified function name, unless it's rgba()/hsla() and
3137 // we're omitting the alpha component - then we use rgb()/hsl().
3138 MOZ_ASSERT(nsCSSValue::IsFloatColorUnit(aUnit), "unexpected unit");
3139
3140 bool showAlpha = (mAlpha != 1.0f);
3141 bool isHSL = (aUnit == eCSSUnit_HSLColor ||
3142 aUnit == eCSSUnit_HSLAColor);
3143
3144 if (isHSL) {
3145 aResult.AppendLiteral("hsl");
3146 } else {
3147 aResult.AppendLiteral("rgb");
3148 }
3149 if (showAlpha && (aUnit == eCSSUnit_HSLAColor || aUnit == eCSSUnit_PercentageRGBAColor)) {
3150 aResult.AppendLiteral("a(");
3151 } else {
3152 aResult.Append('(');
3153 }
3154 if (isHSL) {
3155 aResult.AppendFloat(mComponent1 * 360.0f);
3156 aResult.AppendLiteral(", ");
3157 } else {
3158 aResult.AppendFloat(mComponent1 * 100.0f);
3159 aResult.AppendLiteral("%, ");
3160 }
3161 aResult.AppendFloat(mComponent2 * 100.0f);
3162 aResult.AppendLiteral("%, ");
3163 aResult.AppendFloat(mComponent3 * 100.0f);
3164 if (showAlpha) {
3165 aResult.AppendLiteral("%, ");
3166 aResult.AppendFloat(mAlpha);
3167 aResult.Append(')');
3168 } else {
3169 aResult.AppendLiteral("%)");
3170 }
3171 }
3172
3173 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const3174 nsCSSValueFloatColor::SizeOfIncludingThis(
3175 mozilla::MallocSizeOf aMallocSizeOf) const
3176 {
3177 // Only measure it if it's unshared, to avoid double-counting.
3178 size_t n = 0;
3179 if (mRefCnt <= 1) {
3180 n += aMallocSizeOf(this);
3181 }
3182 return n;
3183 }
3184
3185 // --- nsCSSCornerSizes -----------------
3186
nsCSSCornerSizes(void)3187 nsCSSCornerSizes::nsCSSCornerSizes(void)
3188 {
3189 MOZ_COUNT_CTOR(nsCSSCornerSizes);
3190 }
3191
nsCSSCornerSizes(const nsCSSCornerSizes & aCopy)3192 nsCSSCornerSizes::nsCSSCornerSizes(const nsCSSCornerSizes& aCopy)
3193 : mTopLeft(aCopy.mTopLeft),
3194 mTopRight(aCopy.mTopRight),
3195 mBottomRight(aCopy.mBottomRight),
3196 mBottomLeft(aCopy.mBottomLeft)
3197 {
3198 MOZ_COUNT_CTOR(nsCSSCornerSizes);
3199 }
3200
~nsCSSCornerSizes()3201 nsCSSCornerSizes::~nsCSSCornerSizes()
3202 {
3203 MOZ_COUNT_DTOR(nsCSSCornerSizes);
3204 }
3205
3206 void
Reset()3207 nsCSSCornerSizes::Reset()
3208 {
3209 NS_FOR_CSS_FULL_CORNERS(corner) {
3210 this->GetCorner(corner).Reset();
3211 }
3212 }
3213
3214 static_assert(NS_CORNER_TOP_LEFT == 0 && NS_CORNER_TOP_RIGHT == 1 &&
3215 NS_CORNER_BOTTOM_RIGHT == 2 && NS_CORNER_BOTTOM_LEFT == 3,
3216 "box corner constants not tl/tr/br/bl == 0/1/2/3");
3217
3218 /* static */ const nsCSSCornerSizes::corner_type
3219 nsCSSCornerSizes::corners[4] = {
3220 &nsCSSCornerSizes::mTopLeft,
3221 &nsCSSCornerSizes::mTopRight,
3222 &nsCSSCornerSizes::mBottomRight,
3223 &nsCSSCornerSizes::mBottomLeft,
3224 };
3225
3226 size_t
SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const3227 mozilla::css::GridTemplateAreasValue::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
3228 {
3229 // Only measure it if it's unshared, to avoid double-counting.
3230 size_t n = 0;
3231 if (mRefCnt <= 1) {
3232 n += aMallocSizeOf(this);
3233 n += mNamedAreas.ShallowSizeOfExcludingThis(aMallocSizeOf);
3234 n += mTemplates.ShallowSizeOfExcludingThis(aMallocSizeOf);
3235 }
3236 return n;
3237 }
3238