mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 16:25:38 +00:00
3b4ca07db8
Backed out changeset 6b740afea403 (bug 1496486) Backed out changeset 5cf44e254ac3 (bug 1496486) Backed out changeset 8e465202c355 (bug 1496486) Backed out changeset 86382b2249f6 (bug 1496486) Backed out changeset ab92ed3e0a23 (bug 1496486)
1162 lines
40 KiB
C++
1162 lines
40 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/* representation of simple property values within CSS declarations */
|
|
|
|
#ifndef nsCSSValue_h___
|
|
#define nsCSSValue_h___
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/CORSMode.h"
|
|
#include "mozilla/FontPropertyTypes.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/ServoTypes.h"
|
|
#include "mozilla/SheetType.h"
|
|
#include "mozilla/URLExtraData.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
|
|
#include "nsCSSKeywords.h"
|
|
#include "nsCSSPropertyID.h"
|
|
#include "nsCoord.h"
|
|
#include "nsProxyRelease.h"
|
|
#include "nsRefPtrHashtable.h"
|
|
#include "nsString.h"
|
|
#include "nsStringBuffer.h"
|
|
#include "nsTArray.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsStyleCoord.h"
|
|
#include "gfxFontFamilyList.h"
|
|
|
|
#include <type_traits>
|
|
|
|
class imgRequestProxy;
|
|
class nsAtom;
|
|
class nsIContent;
|
|
class nsIDocument;
|
|
class nsIPrincipal;
|
|
class nsIURI;
|
|
class nsPresContext;
|
|
template <class T>
|
|
class nsPtrHashKey;
|
|
struct RustString;
|
|
|
|
namespace mozilla {
|
|
class CSSStyleSheet;
|
|
} // namespace mozilla
|
|
|
|
// Deletes a linked list iteratively to avoid blowing up the stack (bug 456196).
|
|
#define NS_CSS_DELETE_LIST_MEMBER(type_, ptr_, member_) \
|
|
{ \
|
|
type_ *cur = (ptr_)->member_; \
|
|
(ptr_)->member_ = nullptr; \
|
|
while (cur) { \
|
|
type_ *dlm_next = cur->member_; \
|
|
cur->member_ = nullptr; \
|
|
delete cur; \
|
|
cur = dlm_next; \
|
|
} \
|
|
}
|
|
// Ditto, but use NS_RELEASE instead of 'delete' (bug 1221902).
|
|
#define NS_CSS_NS_RELEASE_LIST_MEMBER(type_, ptr_, member_) \
|
|
{ \
|
|
type_ *cur = (ptr_)->member_; \
|
|
(ptr_)->member_ = nullptr; \
|
|
while (cur) { \
|
|
type_ *dlm_next = cur->member_; \
|
|
cur->member_ = nullptr; \
|
|
NS_RELEASE(cur); \
|
|
cur = dlm_next; \
|
|
} \
|
|
}
|
|
|
|
// Clones a linked list iteratively to avoid blowing up the stack.
|
|
// If it fails to clone the entire list then 'to_' is deleted and
|
|
// we return null.
|
|
#define NS_CSS_CLONE_LIST_MEMBER(type_, from_, member_, to_, args_) \
|
|
{ \
|
|
type_ *dest = (to_); \
|
|
(to_)->member_ = nullptr; \
|
|
for (const type_ *src = (from_)->member_; src; src = src->member_) { \
|
|
type_ *clm_clone = src->Clone args_; \
|
|
if (!clm_clone) { \
|
|
delete (to_); \
|
|
return nullptr; \
|
|
} \
|
|
dest->member_ = clm_clone; \
|
|
dest = clm_clone; \
|
|
} \
|
|
}
|
|
|
|
namespace mozilla {
|
|
namespace css {
|
|
|
|
struct URLValueData
|
|
{
|
|
protected:
|
|
// Methods are not inline because using an nsIPrincipal means requiring
|
|
// caps, which leads to REQUIRES hell, since this header is included all
|
|
// over.
|
|
|
|
// aString must not be null.
|
|
// principal of aExtraData must not be null.
|
|
// Construct with a base URI; this will create the actual URI lazily from
|
|
// aString and aExtraData.
|
|
URLValueData(ServoRawOffsetArc<RustString> aString,
|
|
already_AddRefed<URLExtraData> aExtraData,
|
|
CORSMode aCORSMode);
|
|
// Construct with the actual URI.
|
|
URLValueData(already_AddRefed<nsIURI> aURI,
|
|
ServoRawOffsetArc<RustString> aString,
|
|
already_AddRefed<URLExtraData> aExtraData,
|
|
CORSMode aCORSMode);
|
|
|
|
public:
|
|
// Returns true iff all fields of the two URLValueData objects are equal.
|
|
//
|
|
// Only safe to call on the main thread, since this will call Equals on the
|
|
// nsIURI and nsIPrincipal objects stored on the URLValueData objects.
|
|
bool Equals(const URLValueData& aOther) const;
|
|
|
|
// Returns true iff we know for sure, by comparing the mBaseURI pointer,
|
|
// the specified url() value mString, and the mIsLocalRef, that these
|
|
// two URLValueData objects represent the same computed url() value.
|
|
//
|
|
// Doesn't look at mReferrer or mOriginPrincipal.
|
|
//
|
|
// Safe to call from any thread.
|
|
bool DefinitelyEqualURIs(const URLValueData& aOther) const;
|
|
|
|
// Smae as DefinitelyEqualURIs but additionally compares the nsIPrincipal
|
|
// pointers of the two URLValueData objects.
|
|
bool DefinitelyEqualURIsAndPrincipal(const URLValueData& aOther) const;
|
|
|
|
nsIURI* GetURI() const;
|
|
|
|
bool IsLocalRef() const;
|
|
|
|
bool HasRef() const;
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(URLValueData)
|
|
|
|
// When matching a url with mIsLocalRef set, resolve it against aURI;
|
|
// Otherwise, ignore aURL and return mURL directly.
|
|
already_AddRefed<nsIURI> ResolveLocalRef(nsIURI* aURI) const;
|
|
already_AddRefed<nsIURI> ResolveLocalRef(nsIContent* aContent) const;
|
|
|
|
// Serializes mURI as a computed URI value, taking into account mIsLocalRef
|
|
// and serializing just the fragment if true.
|
|
void GetSourceString(nsString& aRef) const;
|
|
|
|
bool EqualsExceptRef(nsIURI* aURI) const;
|
|
|
|
bool IsStringEmpty() const
|
|
{
|
|
return GetString().IsEmpty();
|
|
}
|
|
|
|
nsDependentCSubstring GetString() const;
|
|
|
|
private:
|
|
// mURI stores the lazily resolved URI. This may be null if the URI is
|
|
// invalid, even once resolved.
|
|
mutable nsCOMPtr<nsIURI> mURI;
|
|
|
|
public:
|
|
RefPtr<URLExtraData> mExtraData;
|
|
|
|
private:
|
|
mutable bool mURIResolved;
|
|
|
|
// mIsLocalRef is set when url starts with a U+0023 number sign(#) character.
|
|
mutable Maybe<bool> mIsLocalRef;
|
|
|
|
mozilla::ServoRawOffsetArc<RustString> mString;
|
|
|
|
protected:
|
|
const CORSMode mCORSMode;
|
|
|
|
virtual ~URLValueData();
|
|
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
URLValueData(const URLValueData& aOther) = delete;
|
|
URLValueData& operator=(const URLValueData& aOther) = delete;
|
|
|
|
friend struct ImageValue;
|
|
};
|
|
|
|
struct URLValue final : public URLValueData
|
|
{
|
|
URLValue(ServoRawOffsetArc<RustString> aString,
|
|
already_AddRefed<URLExtraData> aExtraData)
|
|
: URLValueData(aString, std::move(aExtraData), CORSMode::CORS_NONE)
|
|
{ }
|
|
|
|
URLValue(const URLValue&) = delete;
|
|
URLValue& operator=(const URLValue&) = delete;
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
};
|
|
|
|
struct ImageValue final : public URLValueData
|
|
{
|
|
// Not making the constructor and destructor inline because that would
|
|
// force us to include imgIRequest.h, which leads to REQUIRES hell, since
|
|
// this header is included all over.
|
|
//
|
|
// This constructor is only safe to call from the main thread.
|
|
ImageValue(nsIURI* aURI, const nsAString& aString,
|
|
already_AddRefed<URLExtraData> aExtraData,
|
|
nsIDocument* aDocument,
|
|
CORSMode aCORSMode);
|
|
|
|
// This constructor is only safe to call from the main thread.
|
|
ImageValue(nsIURI* aURI, ServoRawOffsetArc<RustString> aString,
|
|
already_AddRefed<URLExtraData> aExtraData,
|
|
nsIDocument* aDocument,
|
|
CORSMode aCORSMode);
|
|
|
|
// This constructor is safe to call from any thread, but Initialize
|
|
// must be called later for the object to be useful.
|
|
ImageValue(const nsAString& aString,
|
|
already_AddRefed<URLExtraData> aExtraData,
|
|
CORSMode aCORSMode);
|
|
|
|
// This constructor is safe to call from any thread, but Initialize
|
|
// must be called later for the object to be useful.
|
|
ImageValue(ServoRawOffsetArc<RustString> aURIString,
|
|
already_AddRefed<URLExtraData> aExtraData,
|
|
CORSMode aCORSMode);
|
|
|
|
ImageValue(const ImageValue&) = delete;
|
|
ImageValue& operator=(const ImageValue&) = delete;
|
|
|
|
imgRequestProxy* LoadImage(nsIDocument* aDocument);
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
uint64_t LoadID() const { return mLoadID; }
|
|
|
|
protected:
|
|
~ImageValue();
|
|
|
|
private:
|
|
// A unique, non-reused ID value for this ImageValue over the life of the
|
|
// process. This value is only valid after LoadImage has been called.
|
|
//
|
|
// We use this as a key in some tables in ImageLoader. This is better than
|
|
// using the pointer value of the ImageValue object, since we can sometimes
|
|
// delete ImageValues OMT but cannot update the ImageLoader tables until
|
|
// we're back on the main thread. So to avoid dangling pointers that might
|
|
// get re-used by the time we want to update the ImageLoader tables, we use
|
|
// these IDs.
|
|
uint64_t mLoadID = 0;
|
|
};
|
|
|
|
struct GridNamedArea {
|
|
nsString mName;
|
|
uint32_t mColumnStart;
|
|
uint32_t mColumnEnd;
|
|
uint32_t mRowStart;
|
|
uint32_t mRowEnd;
|
|
};
|
|
|
|
struct GridTemplateAreasValue final {
|
|
// Parsed value
|
|
nsTArray<GridNamedArea> mNamedAreas;
|
|
|
|
// Original <string> values. Length gives the number of rows,
|
|
// content makes serialization easier.
|
|
nsTArray<nsString> mTemplates;
|
|
|
|
// How many columns grid-template-areas contributes to the explicit grid.
|
|
// http://dev.w3.org/csswg/css-grid/#explicit-grid
|
|
uint32_t mNColumns;
|
|
|
|
// How many rows grid-template-areas contributes to the explicit grid.
|
|
// http://dev.w3.org/csswg/css-grid/#explicit-grid
|
|
uint32_t NRows() const {
|
|
return mTemplates.Length();
|
|
}
|
|
|
|
GridTemplateAreasValue()
|
|
: mNColumns(0)
|
|
// Default constructors for mNamedAreas and mTemplates: empty arrays.
|
|
{
|
|
}
|
|
|
|
bool operator==(const GridTemplateAreasValue& aOther) const
|
|
{
|
|
return mTemplates == aOther.mTemplates;
|
|
}
|
|
|
|
bool operator!=(const GridTemplateAreasValue& aOther) const
|
|
{
|
|
return !(*this == aOther);
|
|
}
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GridTemplateAreasValue)
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
// Private destructor to make sure this isn't used as a stack variable
|
|
// or member variable.
|
|
~GridTemplateAreasValue()
|
|
{
|
|
}
|
|
|
|
GridTemplateAreasValue(const GridTemplateAreasValue& aOther) = delete;
|
|
GridTemplateAreasValue&
|
|
operator=(const GridTemplateAreasValue& aOther) = delete;
|
|
};
|
|
|
|
} // namespace css
|
|
} // namespace mozilla
|
|
|
|
enum nsCSSUnit {
|
|
eCSSUnit_Null = 0, // (n/a) null unit, value is not specified
|
|
eCSSUnit_Auto = 1, // (n/a) value is algorithmic
|
|
eCSSUnit_Inherit = 2, // (n/a) value is inherited
|
|
eCSSUnit_Initial = 3, // (n/a) value is default UA value
|
|
eCSSUnit_Unset = 4, // (n/a) value equivalent to 'initial' if on a reset property, 'inherit' otherwise
|
|
eCSSUnit_None = 5, // (n/a) value is none
|
|
eCSSUnit_Normal = 6, // (n/a) value is normal (algorithmic, different than auto)
|
|
eCSSUnit_System_Font = 7, // (n/a) value is -moz-use-system-font
|
|
eCSSUnit_All = 8, // (n/a) value is all
|
|
eCSSUnit_Dummy = 9, // (n/a) a fake but specified value, used
|
|
// only in temporary values
|
|
eCSSUnit_DummyInherit = 10, // (n/a) a fake but specified value, used
|
|
// only in temporary values
|
|
|
|
eCSSUnit_String = 11, // (char16_t*) a string value
|
|
eCSSUnit_Ident = 12, // (char16_t*) a string value
|
|
eCSSUnit_Attr = 14, // (char16_t*) a attr(string) value
|
|
eCSSUnit_Local_Font = 15, // (char16_t*) a local font name
|
|
eCSSUnit_Font_Format = 16, // (char16_t*) a font format name
|
|
eCSSUnit_Element = 17, // (char16_t*) an element id
|
|
|
|
eCSSUnit_Array = 20, // (nsCSSValue::Array*) a list of values
|
|
eCSSUnit_Counter = 21, // (nsCSSValue::Array*) a counter(string,[string]) value
|
|
eCSSUnit_Counters = 22, // (nsCSSValue::Array*) a counters(string,string[,string]) value
|
|
eCSSUnit_Cubic_Bezier = 23, // (nsCSSValue::Array*) a list of float values
|
|
eCSSUnit_Steps = 24, // (nsCSSValue::Array*) a list of (integer, enumerated)
|
|
eCSSUnit_Symbols = 25, // (nsCSSValue::Array*) a symbols(enumerated, symbols) value
|
|
eCSSUnit_Function = 26, // (nsCSSValue::Array*) a function with
|
|
// parameters. First elem of array is name,
|
|
// an nsCSSKeyword as eCSSUnit_Enumerated,
|
|
// the rest of the values are arguments.
|
|
|
|
// The top level of a calc() expression is eCSSUnit_Calc. All
|
|
// remaining eCSSUnit_Calc_* units only occur inside these toplevel
|
|
// calc values.
|
|
|
|
// eCSSUnit_Calc has an array with exactly 1 element. eCSSUnit_Calc
|
|
// exists so we can distinguish calc(2em) from 2em as specified values
|
|
// (but we drop this distinction for nsStyleCoord when we store
|
|
// computed values).
|
|
eCSSUnit_Calc = 30, // (nsCSSValue::Array*) calc() value
|
|
// Plus, Minus, Times_* and Divided have arrays with exactly 2
|
|
// elements. a + b + c + d is grouped as ((a + b) + c) + d
|
|
eCSSUnit_Calc_Plus = 31, // (nsCSSValue::Array*) + node within calc()
|
|
eCSSUnit_Calc_Minus = 32, // (nsCSSValue::Array*) - within calc
|
|
eCSSUnit_Calc_Times_L = 33, // (nsCSSValue::Array*) num * val within calc
|
|
eCSSUnit_Calc_Times_R = 34, // (nsCSSValue::Array*) val * num within calc
|
|
eCSSUnit_Calc_Divided = 35, // (nsCSSValue::Array*) / within calc
|
|
|
|
eCSSUnit_URL = 40, // (nsCSSValue::URL*) value
|
|
eCSSUnit_GridTemplateAreas = 44, // (GridTemplateAreasValue*)
|
|
// for grid-template-areas
|
|
|
|
eCSSUnit_Pair = 50, // (nsCSSValuePair*) pair of values
|
|
eCSSUnit_List = 53, // (nsCSSValueList*) list of values
|
|
eCSSUnit_ListDep = 54, // (nsCSSValueList*) same as List
|
|
// but does not own the list
|
|
eCSSUnit_SharedList = 55, // (nsCSSValueSharedList*) same as list
|
|
// but reference counted and shared
|
|
eCSSUnit_PairList = 56, // (nsCSSValuePairList*) list of value pairs
|
|
eCSSUnit_PairListDep = 57, // (nsCSSValuePairList*) same as PairList
|
|
// but does not own the list
|
|
|
|
eCSSUnit_FontFamilyList = 58, // (SharedFontList*) value
|
|
|
|
// Atom units
|
|
eCSSUnit_AtomIdent = 60, // (nsAtom*) for its string as an identifier
|
|
|
|
eCSSUnit_Integer = 70, // (int) simple value
|
|
eCSSUnit_Enumerated = 71, // (int) value has enumerated meaning
|
|
|
|
eCSSUnit_Percent = 100, // (float) 1.0 == 100%) value is percentage of something
|
|
eCSSUnit_Number = 101, // (float) value is numeric (usually multiplier, different behavior than percent)
|
|
|
|
// Length units - relative
|
|
// Viewport relative measure
|
|
eCSSUnit_ViewportWidth = 700, // (float) 1% of the width of the initial containing block
|
|
eCSSUnit_ViewportHeight = 701, // (float) 1% of the height of the initial containing block
|
|
eCSSUnit_ViewportMin = 702, // (float) smaller of ViewportWidth and ViewportHeight
|
|
eCSSUnit_ViewportMax = 703, // (float) larger of ViewportWidth and ViewportHeight
|
|
|
|
// Font relative measure
|
|
eCSSUnit_EM = 800, // (float) == current font size
|
|
eCSSUnit_XHeight = 801, // (float) distance from top of lower case x to baseline
|
|
eCSSUnit_Char = 802, // (float) number of characters, used for width with monospace font
|
|
eCSSUnit_RootEM = 803, // (float) == root element font size
|
|
|
|
// Screen relative measure
|
|
eCSSUnit_Point = 900, // (float) 4/3 of a CSS pixel
|
|
eCSSUnit_Inch = 901, // (float) 96 CSS pixels
|
|
eCSSUnit_Millimeter = 902, // (float) 96/25.4 CSS pixels
|
|
eCSSUnit_Centimeter = 903, // (float) 96/2.54 CSS pixels
|
|
eCSSUnit_Pica = 904, // (float) 12 points == 16 CSS pixls
|
|
eCSSUnit_Quarter = 905, // (float) 96/101.6 CSS pixels
|
|
eCSSUnit_Pixel = 906, // (float) CSS pixel unit
|
|
|
|
// Angular units
|
|
eCSSUnit_Degree = 1000, // (float) 360 per circle
|
|
eCSSUnit_Grad = 1001, // (float) 400 per circle
|
|
eCSSUnit_Radian = 1002, // (float) 2*pi per circle
|
|
eCSSUnit_Turn = 1003, // (float) 1 per circle
|
|
|
|
// Frequency units
|
|
eCSSUnit_Hertz = 2000, // (float) 1/seconds
|
|
eCSSUnit_Kilohertz = 2001, // (float) 1000 Hertz
|
|
|
|
// Time units
|
|
eCSSUnit_Seconds = 3000, // (float) Standard time
|
|
eCSSUnit_Milliseconds = 3001, // (float) 1/1000 second
|
|
|
|
// Flexible fraction (CSS Grid)
|
|
eCSSUnit_FlexFraction = 4000, // (float) Fraction of free space
|
|
|
|
// Font property types
|
|
eCSSUnit_FontWeight = 5000, // An encoded font-weight
|
|
eCSSUnit_FontStretch = 5001, // An encoded font-stretch
|
|
eCSSUnit_FontSlantStyle = 5002, // An encoded font-style
|
|
};
|
|
|
|
struct nsCSSValuePair;
|
|
struct nsCSSValuePair_heap;
|
|
struct nsCSSValueList;
|
|
struct nsCSSValueList_heap;
|
|
struct nsCSSValueSharedList;
|
|
struct nsCSSValuePairList;
|
|
struct nsCSSValuePairList_heap;
|
|
|
|
class nsCSSValue {
|
|
public:
|
|
struct Array;
|
|
friend struct Array;
|
|
|
|
friend struct mozilla::css::URLValueData;
|
|
|
|
friend struct mozilla::css::ImageValue;
|
|
|
|
// for valueless units only (null, auto, inherit, none, all, normal)
|
|
explicit nsCSSValue(nsCSSUnit aUnit = eCSSUnit_Null)
|
|
: mUnit(aUnit)
|
|
{
|
|
MOZ_ASSERT(aUnit <= eCSSUnit_DummyInherit, "not a valueless unit");
|
|
}
|
|
|
|
nsCSSValue(int32_t aValue, nsCSSUnit aUnit);
|
|
nsCSSValue(float aValue, nsCSSUnit aUnit);
|
|
nsCSSValue(const nsString& aValue, nsCSSUnit aUnit);
|
|
nsCSSValue(Array* aArray, nsCSSUnit aUnit);
|
|
explicit nsCSSValue(mozilla::css::URLValue* aValue);
|
|
explicit nsCSSValue(mozilla::css::ImageValue* aValue);
|
|
explicit nsCSSValue(mozilla::css::GridTemplateAreasValue* aValue);
|
|
explicit nsCSSValue(mozilla::SharedFontList* aValue);
|
|
explicit nsCSSValue(mozilla::FontStretch aStretch);
|
|
explicit nsCSSValue(mozilla::FontSlantStyle aStyle);
|
|
explicit nsCSSValue(mozilla::FontWeight aWeight);
|
|
nsCSSValue(const nsCSSValue& aCopy);
|
|
nsCSSValue(nsCSSValue&& aOther)
|
|
: mUnit(aOther.mUnit)
|
|
, mValue(aOther.mValue)
|
|
{
|
|
aOther.mUnit = eCSSUnit_Null;
|
|
}
|
|
template<typename T,
|
|
typename = typename std::enable_if<std::is_enum<T>::value>::type>
|
|
explicit nsCSSValue(T aValue)
|
|
: mUnit(eCSSUnit_Enumerated)
|
|
{
|
|
static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
|
|
"aValue must be an enum that fits within mValue.mInt");
|
|
mValue.mInt = static_cast<int32_t>(aValue);
|
|
}
|
|
|
|
~nsCSSValue() { Reset(); }
|
|
|
|
nsCSSValue& operator=(const nsCSSValue& aCopy);
|
|
nsCSSValue& operator=(nsCSSValue&& aCopy);
|
|
bool operator==(const nsCSSValue& aOther) const;
|
|
|
|
bool operator!=(const nsCSSValue& aOther) const
|
|
{
|
|
return !(*this == aOther);
|
|
}
|
|
|
|
nsCSSUnit GetUnit() const { return mUnit; }
|
|
bool IsLengthUnit() const
|
|
{ return eCSSUnit_ViewportWidth <= mUnit && mUnit <= eCSSUnit_Pixel; }
|
|
bool IsLengthPercentCalcUnit() const
|
|
{ return IsLengthUnit() || mUnit == eCSSUnit_Percent || IsCalcUnit(); }
|
|
/**
|
|
* What the spec calls relative length units is, for us, split
|
|
* between relative length units and pixel length units.
|
|
*
|
|
* A "relative" length unit is a multiple of some derived metric,
|
|
* such as a font em-size, which itself was controlled by an input CSS
|
|
* length. Relative length units should not be scaled by zooming, since
|
|
* the underlying CSS length would already have been scaled.
|
|
*/
|
|
bool IsRelativeLengthUnit() const
|
|
{ return eCSSUnit_EM <= mUnit && mUnit <= eCSSUnit_RootEM; }
|
|
/**
|
|
* A "pixel" length unit is a some multiple of CSS pixels.
|
|
*/
|
|
static bool IsPixelLengthUnit(nsCSSUnit aUnit)
|
|
{ return eCSSUnit_Point <= aUnit && aUnit <= eCSSUnit_Pixel; }
|
|
bool IsPixelLengthUnit() const
|
|
{ return IsPixelLengthUnit(mUnit); }
|
|
static bool IsPercentLengthUnit(nsCSSUnit aUnit)
|
|
{ return aUnit == eCSSUnit_Percent; }
|
|
bool IsPercentLengthUnit()
|
|
{ return IsPercentLengthUnit(mUnit); }
|
|
static bool IsFloatUnit(nsCSSUnit aUnit)
|
|
{ return eCSSUnit_Number <= aUnit; }
|
|
bool IsAngularUnit() const
|
|
{ return eCSSUnit_Degree <= mUnit && mUnit <= eCSSUnit_Turn; }
|
|
bool IsFrequencyUnit() const
|
|
{ return eCSSUnit_Hertz <= mUnit && mUnit <= eCSSUnit_Kilohertz; }
|
|
bool IsTimeUnit() const
|
|
{ return eCSSUnit_Seconds <= mUnit && mUnit <= eCSSUnit_Milliseconds; }
|
|
bool IsCalcUnit() const
|
|
{ return eCSSUnit_Calc <= mUnit && mUnit <= eCSSUnit_Calc_Divided; }
|
|
|
|
bool UnitHasStringValue() const
|
|
{ return eCSSUnit_String <= mUnit && mUnit <= eCSSUnit_Element; }
|
|
bool UnitHasArrayValue() const
|
|
{ return eCSSUnit_Array <= mUnit && mUnit <= eCSSUnit_Calc_Divided; }
|
|
|
|
int32_t GetIntValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_Integer ||
|
|
mUnit == eCSSUnit_Enumerated,
|
|
"not an int value");
|
|
return mValue.mInt;
|
|
}
|
|
|
|
nsCSSKeyword GetKeywordValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_Enumerated, "not a keyword value");
|
|
return static_cast<nsCSSKeyword>(mValue.mInt);
|
|
}
|
|
|
|
float GetPercentValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_Percent, "not a percent value");
|
|
return mValue.mFloat;
|
|
}
|
|
|
|
float GetFloatValue() const
|
|
{
|
|
MOZ_ASSERT(eCSSUnit_Number <= mUnit, "not a float value");
|
|
MOZ_ASSERT(!mozilla::IsNaN(mValue.mFloat));
|
|
return mValue.mFloat;
|
|
}
|
|
|
|
float GetAngleValue() const
|
|
{
|
|
MOZ_ASSERT(eCSSUnit_Degree <= mUnit && mUnit <= eCSSUnit_Turn,
|
|
"not an angle value");
|
|
return mValue.mFloat;
|
|
}
|
|
|
|
// Converts any angle to radians.
|
|
double GetAngleValueInRadians() const;
|
|
|
|
// Converts any angle to degrees.
|
|
double GetAngleValueInDegrees() const;
|
|
|
|
nsAString& GetStringValue(nsAString& aBuffer) const
|
|
{
|
|
MOZ_ASSERT(UnitHasStringValue(), "not a string value");
|
|
aBuffer.Truncate();
|
|
uint32_t len = NS_strlen(GetBufferValue(mValue.mString));
|
|
mValue.mString->ToString(len, aBuffer);
|
|
return aBuffer;
|
|
}
|
|
|
|
const char16_t* GetStringBufferValue() const
|
|
{
|
|
MOZ_ASSERT(UnitHasStringValue(), "not a string value");
|
|
return GetBufferValue(mValue.mString);
|
|
}
|
|
|
|
Array* GetArrayValue() const
|
|
{
|
|
MOZ_ASSERT(UnitHasArrayValue(), "not an array value");
|
|
return mValue.mArray;
|
|
}
|
|
|
|
nsIURI* GetURLValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_URL, "not a URL value");
|
|
return mValue.mURL->GetURI();
|
|
}
|
|
|
|
nsCSSValueSharedList* GetSharedListValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_SharedList, "not a shared list value");
|
|
return mValue.mSharedList;
|
|
}
|
|
|
|
mozilla::NotNull<mozilla::SharedFontList*> GetFontFamilyListValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_FontFamilyList,
|
|
"not a font family list value");
|
|
NS_ASSERTION(mValue.mFontFamilyList != nullptr,
|
|
"font family list value should never be null");
|
|
return mozilla::WrapNotNull(mValue.mFontFamilyList);
|
|
}
|
|
|
|
mozilla::FontStretch GetFontStretch() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_FontStretch, "not a font stretch value");
|
|
return mValue.mFontStretch;
|
|
}
|
|
|
|
mozilla::FontSlantStyle GetFontSlantStyle() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_FontSlantStyle, "not a font style value");
|
|
return mValue.mFontSlantStyle;
|
|
}
|
|
|
|
mozilla::FontWeight GetFontWeight() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_FontWeight, "not a font weight value");
|
|
return mValue.mFontWeight;
|
|
}
|
|
|
|
// bodies of these are below
|
|
inline nsCSSValuePair& GetPairValue();
|
|
inline const nsCSSValuePair& GetPairValue() const;
|
|
|
|
inline nsCSSValueList* GetListValue();
|
|
inline const nsCSSValueList* GetListValue() const;
|
|
|
|
inline nsCSSValuePairList* GetPairListValue();
|
|
inline const nsCSSValuePairList* GetPairListValue() const;
|
|
|
|
mozilla::css::URLValue* GetURLStructValue() const
|
|
{
|
|
// Not allowing this for Image values, because if the caller takes
|
|
// a ref to them they won't be able to delete them properly.
|
|
MOZ_ASSERT(mUnit == eCSSUnit_URL, "not a URL value");
|
|
return mValue.mURL;
|
|
}
|
|
|
|
mozilla::css::GridTemplateAreasValue* GetGridTemplateAreas() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_GridTemplateAreas,
|
|
"not a grid-template-areas value");
|
|
return mValue.mGridTemplateAreas;
|
|
}
|
|
|
|
// Not making this inline because that would force us to include
|
|
// imgIRequest.h, which leads to REQUIRES hell, since this header is included
|
|
// all over.
|
|
imgRequestProxy* GetImageValue(nsIDocument* aDocument) const;
|
|
|
|
// Like GetImageValue, but additionally will pass the imgRequestProxy
|
|
// through nsContentUtils::GetStaticRequest if aPresContent is static.
|
|
already_AddRefed<imgRequestProxy> GetPossiblyStaticImageValue(
|
|
nsIDocument* aDocument, nsPresContext* aPresContext) const;
|
|
|
|
nscoord GetPixelLength() const;
|
|
|
|
nsAtom* GetAtomValue() const {
|
|
MOZ_ASSERT(mUnit == eCSSUnit_AtomIdent);
|
|
return mValue.mAtom;
|
|
}
|
|
|
|
void Reset() // sets to null
|
|
{
|
|
if (mUnit != eCSSUnit_Null)
|
|
DoReset();
|
|
}
|
|
private:
|
|
void DoReset();
|
|
|
|
public:
|
|
void SetIntValue(int32_t aValue, nsCSSUnit aUnit);
|
|
template<typename T,
|
|
typename = typename std::enable_if<std::is_enum<T>::value>::type>
|
|
void SetEnumValue(T aValue)
|
|
{
|
|
static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
|
|
"aValue must be an enum that fits within mValue.mInt");
|
|
SetIntValue(static_cast<int32_t>(aValue), eCSSUnit_Enumerated);
|
|
}
|
|
void SetPercentValue(float aValue);
|
|
void SetFloatValue(float aValue, nsCSSUnit aUnit);
|
|
void SetStringValue(const nsString& aValue, nsCSSUnit aUnit);
|
|
void SetAtomIdentValue(already_AddRefed<nsAtom> aValue);
|
|
// converts the nscoord to pixels
|
|
void SetIntegerCoordValue(nscoord aCoord);
|
|
void SetArrayValue(nsCSSValue::Array* aArray, nsCSSUnit aUnit);
|
|
void SetURLValue(mozilla::css::URLValue* aURI);
|
|
void SetGridTemplateAreas(mozilla::css::GridTemplateAreasValue* aValue);
|
|
void SetFontFamilyListValue(already_AddRefed<mozilla::SharedFontList> aFontListValue);
|
|
void SetFontStretch(mozilla::FontStretch aStretch);
|
|
void SetFontSlantStyle(mozilla::FontSlantStyle aStyle);
|
|
void SetFontWeight(mozilla::FontWeight aWeight);
|
|
void SetPairValue(const nsCSSValuePair* aPair);
|
|
void SetPairValue(const nsCSSValue& xValue, const nsCSSValue& yValue);
|
|
void SetSharedListValue(nsCSSValueSharedList* aList);
|
|
void SetDependentListValue(nsCSSValueList* aList);
|
|
void SetDependentPairListValue(nsCSSValuePairList* aList);
|
|
void SetAutoValue();
|
|
void SetInheritValue();
|
|
void SetInitialValue();
|
|
void SetUnsetValue();
|
|
void SetNoneValue();
|
|
void SetAllValue();
|
|
void SetNormalValue();
|
|
void SetSystemFontValue();
|
|
void SetDummyValue();
|
|
void SetDummyInheritValue();
|
|
|
|
// Converts an nsStyleCoord::CalcValue back into a CSSValue
|
|
void SetCalcValue(const nsStyleCoord::CalcValue* aCalc);
|
|
|
|
nsStyleCoord::CalcValue GetCalcValue() const;
|
|
|
|
// These are a little different - they allocate storage for you and
|
|
// return a handle.
|
|
nsCSSValueList* SetListValue();
|
|
nsCSSValuePairList* SetPairListValue();
|
|
|
|
// These take ownership of the passed-in resource.
|
|
void AdoptListValue(mozilla::UniquePtr<nsCSSValueList> aValue);
|
|
void AdoptPairListValue(mozilla::UniquePtr<nsCSSValuePairList> aValue);
|
|
|
|
void StartImageLoad(nsIDocument* aDocument,
|
|
mozilla::CORSMode aCORSMode) const; // Only pretend const
|
|
|
|
// Initializes as a function value with the specified function id.
|
|
Array* InitFunction(nsCSSKeyword aFunctionId, uint32_t aNumArgs);
|
|
// Checks if this is a function value with the specified function id.
|
|
bool EqualsFunction(nsCSSKeyword aFunctionId) const;
|
|
|
|
// Returns an already addrefed buffer. Guaranteed to return non-null.
|
|
// (Will abort on allocation failure.)
|
|
static already_AddRefed<nsStringBuffer>
|
|
BufferFromString(const nsString& aValue);
|
|
|
|
// Convert the given Ident value into AtomIdent.
|
|
void AtomizeIdentValue();
|
|
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
static void
|
|
AppendAlignJustifyValueToString(int32_t aValue, nsAString& aResult);
|
|
|
|
private:
|
|
static const char16_t* GetBufferValue(nsStringBuffer* aBuffer) {
|
|
return static_cast<char16_t*>(aBuffer->Data());
|
|
}
|
|
|
|
protected:
|
|
nsCSSUnit mUnit;
|
|
union {
|
|
int32_t mInt;
|
|
float mFloat;
|
|
// Note: the capacity of the buffer may exceed the length of the string.
|
|
// If we're of a string type, mString is not null.
|
|
nsStringBuffer* MOZ_OWNING_REF mString;
|
|
nsAtom* MOZ_OWNING_REF mAtom;
|
|
Array* MOZ_OWNING_REF mArray;
|
|
mozilla::css::URLValue* MOZ_OWNING_REF mURL;
|
|
mozilla::css::GridTemplateAreasValue* MOZ_OWNING_REF mGridTemplateAreas;
|
|
nsCSSValuePair_heap* MOZ_OWNING_REF mPair;
|
|
nsCSSValueList_heap* MOZ_OWNING_REF mList;
|
|
nsCSSValueList* mListDependent;
|
|
nsCSSValueSharedList* MOZ_OWNING_REF mSharedList;
|
|
nsCSSValuePairList_heap* MOZ_OWNING_REF mPairList;
|
|
nsCSSValuePairList* mPairListDependent;
|
|
mozilla::SharedFontList* MOZ_OWNING_REF mFontFamilyList;
|
|
mozilla::FontStretch mFontStretch;
|
|
mozilla::FontSlantStyle mFontSlantStyle;
|
|
mozilla::FontWeight mFontWeight;
|
|
} mValue;
|
|
};
|
|
|
|
struct nsCSSValue::Array final {
|
|
|
|
// return |Array| with reference count of zero
|
|
static Array* Create(size_t aItemCount) {
|
|
return new (aItemCount) Array(aItemCount);
|
|
}
|
|
|
|
nsCSSValue& operator[](size_t aIndex) {
|
|
MOZ_ASSERT(aIndex < mCount, "out of range");
|
|
return mArray[aIndex];
|
|
}
|
|
|
|
const nsCSSValue& operator[](size_t aIndex) const {
|
|
MOZ_ASSERT(aIndex < mCount, "out of range");
|
|
return mArray[aIndex];
|
|
}
|
|
|
|
nsCSSValue& Item(size_t aIndex) { return (*this)[aIndex]; }
|
|
const nsCSSValue& Item(size_t aIndex) const { return (*this)[aIndex]; }
|
|
|
|
size_t Count() const { return mCount; }
|
|
|
|
// callers depend on the items being contiguous
|
|
nsCSSValue* ItemStorage() {
|
|
return this->First();
|
|
}
|
|
|
|
bool operator==(const Array& aOther) const
|
|
{
|
|
if (mCount != aOther.mCount)
|
|
return false;
|
|
for (size_t i = 0; i < mCount; ++i)
|
|
if ((*this)[i] != aOther[i])
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Array);
|
|
private:
|
|
|
|
const size_t mCount;
|
|
// This must be the last sub-object, since we extend this array to
|
|
// be of size mCount; it needs to be a sub-object so it gets proper
|
|
// alignment.
|
|
nsCSSValue mArray[1];
|
|
|
|
void* operator new(size_t aSelfSize, size_t aItemCount) CPP_THROW_NEW {
|
|
MOZ_ASSERT(aItemCount > 0, "cannot have a 0 item count");
|
|
return ::operator new(aSelfSize + sizeof(nsCSSValue) * (aItemCount - 1));
|
|
}
|
|
|
|
void operator delete(void* aPtr) { ::operator delete(aPtr); }
|
|
|
|
nsCSSValue* First() { return mArray; }
|
|
|
|
const nsCSSValue* First() const { return mArray; }
|
|
|
|
#define CSSVALUE_LIST_FOR_EXTRA_VALUES(var) \
|
|
for (nsCSSValue *var = First() + 1, *var##_end = First() + mCount; \
|
|
var != var##_end; ++var)
|
|
|
|
explicit Array(size_t aItemCount)
|
|
: mRefCnt(0)
|
|
, mCount(aItemCount)
|
|
{
|
|
CSSVALUE_LIST_FOR_EXTRA_VALUES(val) {
|
|
new (val) nsCSSValue();
|
|
}
|
|
}
|
|
|
|
~Array()
|
|
{
|
|
CSSVALUE_LIST_FOR_EXTRA_VALUES(val) {
|
|
val->~nsCSSValue();
|
|
}
|
|
}
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
#undef CSSVALUE_LIST_FOR_EXTRA_VALUES
|
|
|
|
private:
|
|
Array(const Array& aOther) = delete;
|
|
Array& operator=(const Array& aOther) = delete;
|
|
};
|
|
|
|
// Prefer nsCSSValue::Array for lists of fixed size.
|
|
struct nsCSSValueList {
|
|
nsCSSValueList() : mNext(nullptr) { MOZ_COUNT_CTOR(nsCSSValueList); }
|
|
~nsCSSValueList();
|
|
|
|
nsCSSValueList* Clone() const; // makes a deep copy. Infallible.
|
|
void CloneInto(nsCSSValueList* aList) const; // makes a deep copy into aList
|
|
|
|
static bool Equal(const nsCSSValueList* aList1,
|
|
const nsCSSValueList* aList2);
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
nsCSSValue mValue;
|
|
nsCSSValueList* mNext;
|
|
|
|
private:
|
|
nsCSSValueList(const nsCSSValueList& aCopy) // makes a shallow copy
|
|
: mValue(aCopy.mValue), mNext(nullptr)
|
|
{
|
|
MOZ_COUNT_CTOR(nsCSSValueList);
|
|
}
|
|
|
|
// We don't want operator== or operator!= because they wouldn't be
|
|
// null-safe, which is generally what we need. Use |Equal| method
|
|
// above instead.
|
|
bool operator==(nsCSSValueList const& aOther) const = delete;
|
|
bool operator!=(const nsCSSValueList& aOther) const = delete;
|
|
};
|
|
|
|
// nsCSSValueList_heap differs from nsCSSValueList only in being
|
|
// refcounted. It should not be necessary to use this class directly;
|
|
// it's an implementation detail of nsCSSValue.
|
|
struct nsCSSValueList_heap final : public nsCSSValueList {
|
|
NS_INLINE_DECL_REFCOUNTING(nsCSSValueList_heap)
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
// Private destructor, to discourage deletion outside of Release():
|
|
~nsCSSValueList_heap()
|
|
{
|
|
}
|
|
};
|
|
|
|
// This is a reference counted list value. Note that the object is
|
|
// a wrapper for the reference count and a pointer to the head of the
|
|
// list, whereas the other list types (such as nsCSSValueList) do
|
|
// not have such a wrapper.
|
|
struct nsCSSValueSharedList final {
|
|
nsCSSValueSharedList()
|
|
: mHead(nullptr)
|
|
{
|
|
}
|
|
|
|
// Takes ownership of aList.
|
|
explicit nsCSSValueSharedList(nsCSSValueList* aList)
|
|
: mHead(aList)
|
|
{
|
|
}
|
|
|
|
private:
|
|
// Private destructor, to discourage deletion outside of Release():
|
|
~nsCSSValueSharedList();
|
|
|
|
public:
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsCSSValueSharedList)
|
|
|
|
bool operator==(nsCSSValueSharedList const& aOther) const;
|
|
bool operator!=(const nsCSSValueSharedList& aOther) const
|
|
{ return !(*this == aOther); }
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
nsCSSValueList* mHead;
|
|
};
|
|
|
|
// This has to be here so that the relationship between nsCSSValueList
|
|
// and nsCSSValueList_heap is visible.
|
|
inline nsCSSValueList*
|
|
nsCSSValue::GetListValue()
|
|
{
|
|
if (mUnit == eCSSUnit_List)
|
|
return mValue.mList;
|
|
else {
|
|
MOZ_ASSERT(mUnit == eCSSUnit_ListDep, "not a list value");
|
|
return mValue.mListDependent;
|
|
}
|
|
}
|
|
|
|
inline const nsCSSValueList*
|
|
nsCSSValue::GetListValue() const
|
|
{
|
|
if (mUnit == eCSSUnit_List)
|
|
return mValue.mList;
|
|
else {
|
|
MOZ_ASSERT(mUnit == eCSSUnit_ListDep, "not a list value");
|
|
return mValue.mListDependent;
|
|
}
|
|
}
|
|
|
|
struct nsCSSValuePair {
|
|
nsCSSValuePair()
|
|
{
|
|
MOZ_COUNT_CTOR(nsCSSValuePair);
|
|
}
|
|
explicit nsCSSValuePair(nsCSSUnit aUnit)
|
|
: mXValue(aUnit), mYValue(aUnit)
|
|
{
|
|
MOZ_COUNT_CTOR(nsCSSValuePair);
|
|
}
|
|
nsCSSValuePair(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
|
|
: mXValue(aXValue), mYValue(aYValue)
|
|
{
|
|
MOZ_COUNT_CTOR(nsCSSValuePair);
|
|
}
|
|
nsCSSValuePair(const nsCSSValuePair& aCopy)
|
|
: mXValue(aCopy.mXValue), mYValue(aCopy.mYValue)
|
|
{
|
|
MOZ_COUNT_CTOR(nsCSSValuePair);
|
|
}
|
|
~nsCSSValuePair()
|
|
{
|
|
MOZ_COUNT_DTOR(nsCSSValuePair);
|
|
}
|
|
|
|
nsCSSValuePair& operator=(const nsCSSValuePair& aOther) {
|
|
mXValue = aOther.mXValue;
|
|
mYValue = aOther.mYValue;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const nsCSSValuePair& aOther) const {
|
|
return mXValue == aOther.mXValue &&
|
|
mYValue == aOther.mYValue;
|
|
}
|
|
|
|
bool operator!=(const nsCSSValuePair& aOther) const {
|
|
return mXValue != aOther.mXValue ||
|
|
mYValue != aOther.mYValue;
|
|
}
|
|
|
|
bool BothValuesEqualTo(const nsCSSValue& aValue) const {
|
|
return mXValue == aValue &&
|
|
mYValue == aValue;
|
|
}
|
|
|
|
void SetBothValuesTo(const nsCSSValue& aValue) {
|
|
mXValue = aValue;
|
|
mYValue = aValue;
|
|
}
|
|
|
|
void Reset() {
|
|
mXValue.Reset();
|
|
mYValue.Reset();
|
|
}
|
|
|
|
bool HasValue() const {
|
|
return mXValue.GetUnit() != eCSSUnit_Null ||
|
|
mYValue.GetUnit() != eCSSUnit_Null;
|
|
}
|
|
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
nsCSSValue mXValue;
|
|
nsCSSValue mYValue;
|
|
};
|
|
|
|
// nsCSSValuePair_heap differs from nsCSSValuePair only in being
|
|
// refcounted. It should not be necessary to use this class directly;
|
|
// it's an implementation detail of nsCSSValue.
|
|
struct nsCSSValuePair_heap final : public nsCSSValuePair {
|
|
// forward constructor
|
|
nsCSSValuePair_heap(const nsCSSValue& aXValue, const nsCSSValue& aYValue)
|
|
: nsCSSValuePair(aXValue, aYValue)
|
|
{}
|
|
|
|
NS_INLINE_DECL_REFCOUNTING(nsCSSValuePair_heap)
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
// Private destructor, to discourage deletion outside of Release():
|
|
~nsCSSValuePair_heap()
|
|
{
|
|
}
|
|
};
|
|
|
|
// This has to be here so that the relationship between nsCSSValuePair
|
|
// and nsCSSValuePair_heap is visible.
|
|
inline nsCSSValuePair&
|
|
nsCSSValue::GetPairValue()
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_Pair, "not a pair value");
|
|
return *mValue.mPair;
|
|
}
|
|
|
|
inline const nsCSSValuePair&
|
|
nsCSSValue::GetPairValue() const
|
|
{
|
|
MOZ_ASSERT(mUnit == eCSSUnit_Pair, "not a pair value");
|
|
return *mValue.mPair;
|
|
}
|
|
|
|
// Maybe should be replaced with nsCSSValueList and nsCSSValue::Array?
|
|
struct nsCSSValuePairList {
|
|
nsCSSValuePairList() : mNext(nullptr) { MOZ_COUNT_CTOR(nsCSSValuePairList); }
|
|
~nsCSSValuePairList();
|
|
|
|
nsCSSValuePairList* Clone() const; // makes a deep copy. Infallible.
|
|
|
|
static bool Equal(const nsCSSValuePairList* aList1,
|
|
const nsCSSValuePairList* aList2);
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
nsCSSValue mXValue;
|
|
nsCSSValue mYValue;
|
|
nsCSSValuePairList* mNext;
|
|
|
|
private:
|
|
nsCSSValuePairList(const nsCSSValuePairList& aCopy) // makes a shallow copy
|
|
: mXValue(aCopy.mXValue), mYValue(aCopy.mYValue), mNext(nullptr)
|
|
{
|
|
MOZ_COUNT_CTOR(nsCSSValuePairList);
|
|
}
|
|
|
|
// We don't want operator== or operator!= because they wouldn't be
|
|
// null-safe, which is generally what we need. Use |Equal| method
|
|
// above instead.
|
|
bool operator==(const nsCSSValuePairList& aOther) const = delete;
|
|
bool operator!=(const nsCSSValuePairList& aOther) const = delete;
|
|
};
|
|
|
|
// nsCSSValuePairList_heap differs from nsCSSValuePairList only in being
|
|
// refcounted. It should not be necessary to use this class directly;
|
|
// it's an implementation detail of nsCSSValue.
|
|
struct nsCSSValuePairList_heap final : public nsCSSValuePairList {
|
|
NS_INLINE_DECL_REFCOUNTING(nsCSSValuePairList_heap)
|
|
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
// Private destructor, to discourage deletion outside of Release():
|
|
~nsCSSValuePairList_heap()
|
|
{
|
|
}
|
|
};
|
|
|
|
// This has to be here so that the relationship between nsCSSValuePairList
|
|
// and nsCSSValuePairList_heap is visible.
|
|
inline nsCSSValuePairList*
|
|
nsCSSValue::GetPairListValue()
|
|
{
|
|
if (mUnit == eCSSUnit_PairList)
|
|
return mValue.mPairList;
|
|
else {
|
|
MOZ_ASSERT (mUnit == eCSSUnit_PairListDep, "not a pairlist value");
|
|
return mValue.mPairListDependent;
|
|
}
|
|
}
|
|
|
|
inline const nsCSSValuePairList*
|
|
nsCSSValue::GetPairListValue() const
|
|
{
|
|
if (mUnit == eCSSUnit_PairList)
|
|
return mValue.mPairList;
|
|
else {
|
|
MOZ_ASSERT (mUnit == eCSSUnit_PairListDep, "not a pairlist value");
|
|
return mValue.mPairListDependent;
|
|
}
|
|
}
|
|
|
|
#endif /* nsCSSValue_h___ */
|
|
|