summaryrefslogtreecommitdiffstats
path: root/layout/style/nsComputedDOMStyle.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/style/nsComputedDOMStyle.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/style/nsComputedDOMStyle.cpp')
-rw-r--r--layout/style/nsComputedDOMStyle.cpp6698
1 files changed, 6698 insertions, 0 deletions
diff --git a/layout/style/nsComputedDOMStyle.cpp b/layout/style/nsComputedDOMStyle.cpp
new file mode 100644
index 000000000..4eb24b76b
--- /dev/null
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -0,0 +1,6698 @@
+/* -*- 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/. */
+
+/* DOM object returned from element.getComputedStyle() */
+
+#include "nsComputedDOMStyle.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Preferences.h"
+
+#include "nsError.h"
+#include "nsDOMString.h"
+#include "nsIDOMCSSPrimitiveValue.h"
+#include "nsIFrame.h"
+#include "nsIFrameInlines.h"
+#include "nsStyleContext.h"
+#include "nsIScrollableFrame.h"
+#include "nsContentUtils.h"
+#include "nsIContent.h"
+
+#include "nsDOMCSSRect.h"
+#include "nsDOMCSSRGBColor.h"
+#include "nsDOMCSSValueList.h"
+#include "nsFlexContainerFrame.h"
+#include "nsGridContainerFrame.h"
+#include "nsGkAtoms.h"
+#include "mozilla/ReflowInput.h"
+#include "nsStyleUtil.h"
+#include "nsStyleStructInlines.h"
+#include "nsROCSSPrimitiveValue.h"
+
+#include "nsPresContext.h"
+#include "nsIDocument.h"
+
+#include "nsCSSPseudoElements.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "imgIRequest.h"
+#include "nsLayoutUtils.h"
+#include "nsCSSKeywords.h"
+#include "nsStyleCoord.h"
+#include "nsDisplayList.h"
+#include "nsDOMCSSDeclaration.h"
+#include "nsStyleTransformMatrix.h"
+#include "mozilla/dom/Element.h"
+#include "prtime.h"
+#include "nsWrapperCacheInlines.h"
+#include "mozilla/AppUnits.h"
+#include <algorithm>
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#if defined(DEBUG_bzbarsky) || defined(DEBUG_caillon)
+#define DEBUG_ComputedDOMStyle
+#endif
+
+/*
+ * This is the implementation of the readonly CSSStyleDeclaration that is
+ * returned by the getComputedStyle() function.
+ */
+
+already_AddRefed<nsComputedDOMStyle>
+NS_NewComputedDOMStyle(dom::Element* aElement, const nsAString& aPseudoElt,
+ nsIPresShell* aPresShell,
+ nsComputedDOMStyle::StyleType aStyleType)
+{
+ RefPtr<nsComputedDOMStyle> computedStyle;
+ computedStyle = new nsComputedDOMStyle(aElement, aPseudoElt, aPresShell,
+ aStyleType);
+ return computedStyle.forget();
+}
+
+/**
+ * An object that represents the ordered set of properties that are exposed on
+ * an nsComputedDOMStyle object and how their computed values can be obtained.
+ */
+struct nsComputedStyleMap
+{
+ friend class nsComputedDOMStyle;
+
+ struct Entry
+ {
+ // Create a pointer-to-member-function type.
+ typedef already_AddRefed<CSSValue> (nsComputedDOMStyle::*ComputeMethod)();
+
+ nsCSSPropertyID mProperty;
+ ComputeMethod mGetter;
+
+ bool IsLayoutFlushNeeded() const
+ {
+ return nsCSSProps::PropHasFlags(mProperty,
+ CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH);
+ }
+
+ bool IsEnabled() const
+ {
+ return nsCSSProps::IsEnabled(mProperty, CSSEnabledState::eForAllContent);
+ }
+ };
+
+ // We define this enum just to count the total number of properties that can
+ // be exposed on an nsComputedDOMStyle, including properties that may be
+ // disabled.
+ enum {
+#define COMPUTED_STYLE_PROP(prop_, method_) \
+ eComputedStyleProperty_##prop_,
+#include "nsComputedDOMStylePropertyList.h"
+#undef COMPUTED_STYLE_PROP
+ eComputedStyleProperty_COUNT
+ };
+
+ /**
+ * Returns the number of properties that should be exposed on an
+ * nsComputedDOMStyle, ecxluding any disabled properties.
+ */
+ uint32_t Length()
+ {
+ Update();
+ return mExposedPropertyCount;
+ }
+
+ /**
+ * Returns the property at the given index in the list of properties
+ * that should be exposed on an nsComputedDOMStyle, excluding any
+ * disabled properties.
+ */
+ nsCSSPropertyID PropertyAt(uint32_t aIndex)
+ {
+ Update();
+ return kEntries[EntryIndex(aIndex)].mProperty;
+ }
+
+ /**
+ * Searches for and returns the computed style map entry for the given
+ * property, or nullptr if the property is not exposed on nsComputedDOMStyle
+ * or is currently disabled.
+ */
+ const Entry* FindEntryForProperty(nsCSSPropertyID aPropID)
+ {
+ Update();
+ for (uint32_t i = 0; i < mExposedPropertyCount; i++) {
+ const Entry* entry = &kEntries[EntryIndex(i)];
+ if (entry->mProperty == aPropID) {
+ return entry;
+ }
+ }
+ return nullptr;
+ }
+
+ /**
+ * Records that mIndexMap needs updating, due to prefs changing that could
+ * affect the set of properties exposed on an nsComputedDOMStyle.
+ */
+ void MarkDirty() { mExposedPropertyCount = 0; }
+
+ // The member variables are public so that we can use an initializer in
+ // nsComputedDOMStyle::GetComputedStyleMap. Use the member functions
+ // above to get information from this object.
+
+ /**
+ * An entry for each property that can be exposed on an nsComputedDOMStyle.
+ */
+ const Entry kEntries[eComputedStyleProperty_COUNT];
+
+ /**
+ * The number of properties that should be exposed on an nsComputedDOMStyle.
+ * This will be less than eComputedStyleProperty_COUNT if some property
+ * prefs are disabled. A value of 0 indicates that it and mIndexMap are out
+ * of date.
+ */
+ uint32_t mExposedPropertyCount;
+
+ /**
+ * A map of indexes on the nsComputedDOMStyle object to indexes into kEntries.
+ */
+ uint32_t mIndexMap[eComputedStyleProperty_COUNT];
+
+private:
+ /**
+ * Returns whether mExposedPropertyCount and mIndexMap are out of date.
+ */
+ bool IsDirty() { return mExposedPropertyCount == 0; }
+
+ /**
+ * Updates mExposedPropertyCount and mIndexMap to take into account properties
+ * whose prefs are currently disabled.
+ */
+ void Update();
+
+ /**
+ * Maps an nsComputedDOMStyle indexed getter index to an index into kEntries.
+ */
+ uint32_t EntryIndex(uint32_t aIndex) const
+ {
+ MOZ_ASSERT(aIndex < mExposedPropertyCount);
+ return mIndexMap[aIndex];
+ }
+};
+
+void
+nsComputedStyleMap::Update()
+{
+ if (!IsDirty()) {
+ return;
+ }
+
+ uint32_t index = 0;
+ for (uint32_t i = 0; i < eComputedStyleProperty_COUNT; i++) {
+ if (kEntries[i].IsEnabled()) {
+ mIndexMap[index++] = i;
+ }
+ }
+ mExposedPropertyCount = index;
+}
+
+nsComputedDOMStyle::nsComputedDOMStyle(dom::Element* aElement,
+ const nsAString& aPseudoElt,
+ nsIPresShell* aPresShell,
+ StyleType aStyleType)
+ : mDocumentWeak(nullptr)
+ , mOuterFrame(nullptr)
+ , mInnerFrame(nullptr)
+ , mPresShell(nullptr)
+ , mStyleType(aStyleType)
+ , mStyleContextGeneration(0)
+ , mExposeVisitedStyle(false)
+ , mResolvedStyleContext(false)
+{
+ MOZ_ASSERT(aElement && aPresShell);
+
+ mDocumentWeak = do_GetWeakReference(aPresShell->GetDocument());
+
+ mContent = aElement;
+
+ if (!DOMStringIsNull(aPseudoElt) && !aPseudoElt.IsEmpty() &&
+ aPseudoElt.First() == char16_t(':')) {
+ // deal with two-colon forms of aPseudoElt
+ nsAString::const_iterator start, end;
+ aPseudoElt.BeginReading(start);
+ aPseudoElt.EndReading(end);
+ NS_ASSERTION(start != end, "aPseudoElt is not empty!");
+ ++start;
+ bool haveTwoColons = true;
+ if (start == end || *start != char16_t(':')) {
+ --start;
+ haveTwoColons = false;
+ }
+ mPseudo = NS_Atomize(Substring(start, end));
+ MOZ_ASSERT(mPseudo);
+
+ // There aren't any non-CSS2 pseudo-elements with a single ':'
+ if (!haveTwoColons &&
+ (!nsCSSPseudoElements::IsPseudoElement(mPseudo) ||
+ !nsCSSPseudoElements::IsCSS2PseudoElement(mPseudo))) {
+ // XXXbz I'd really rather we threw an exception or something, but
+ // the DOM spec sucks.
+ mPseudo = nullptr;
+ }
+ }
+
+ MOZ_ASSERT(aPresShell->GetPresContext());
+}
+
+nsComputedDOMStyle::~nsComputedDOMStyle()
+{
+ ClearStyleContext();
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsComputedDOMStyle)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsComputedDOMStyle)
+ tmp->ClearStyleContext(); // remove observer before clearing mContent
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mContent)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsComputedDOMStyle)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContent)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(nsComputedDOMStyle)
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsComputedDOMStyle)
+ return tmp->IsBlack();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsComputedDOMStyle)
+ return tmp->IsBlack();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsComputedDOMStyle)
+ return tmp->IsBlack();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
+
+// QueryInterface implementation for nsComputedDOMStyle
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsComputedDOMStyle)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
+NS_INTERFACE_MAP_END_INHERITING(nsDOMCSSDeclaration)
+
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsComputedDOMStyle)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsComputedDOMStyle)
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetPropertyValue(const nsCSSPropertyID aPropID,
+ nsAString& aValue)
+{
+ // This is mostly to avoid code duplication with GetPropertyCSSValue(); if
+ // perf ever becomes an issue here (doubtful), we can look into changing
+ // this.
+ return GetPropertyValue(
+ NS_ConvertASCIItoUTF16(nsCSSProps::GetStringValue(aPropID)),
+ aValue);
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::SetPropertyValue(const nsCSSPropertyID aPropID,
+ const nsAString& aValue)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetCssText(nsAString& aCssText)
+{
+ aCssText.Truncate();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::SetCssText(const nsAString& aCssText)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetLength(uint32_t* aLength)
+{
+ NS_PRECONDITION(aLength, "Null aLength! Prepare to die!");
+
+ uint32_t length = GetComputedStyleMap()->Length();
+
+ // Make sure we have up to date style so that we can include custom
+ // properties.
+ UpdateCurrentStyleSources(false);
+ if (mStyleContext) {
+ length += StyleVariables()->mVariables.Count();
+ }
+
+ *aLength = length;
+
+ ClearCurrentStyleSources();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetParentRule(nsIDOMCSSRule** aParentRule)
+{
+ *aParentRule = nullptr;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetPropertyValue(const nsAString& aPropertyName,
+ nsAString& aReturn)
+{
+ aReturn.Truncate();
+
+ ErrorResult error;
+ RefPtr<CSSValue> val = GetPropertyCSSValue(aPropertyName, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ if (val) {
+ nsString text;
+ val->GetCssText(text, error);
+ aReturn.Assign(text);
+ return error.StealNSResult();
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetAuthoredPropertyValue(const nsAString& aPropertyName,
+ nsAString& aReturn)
+{
+ // Authored style doesn't make sense to return from computed DOM style,
+ // so just return whatever GetPropertyValue() returns.
+ return GetPropertyValue(aPropertyName, aReturn);
+}
+
+/* static */
+already_AddRefed<nsStyleContext>
+nsComputedDOMStyle::GetStyleContextForElement(Element* aElement,
+ nsIAtom* aPseudo,
+ nsIPresShell* aPresShell,
+ StyleType aStyleType)
+{
+ // If the content has a pres shell, we must use it. Otherwise we'd
+ // potentially mix rule trees by using the wrong pres shell's style
+ // set. Using the pres shell from the content also means that any
+ // content that's actually *in* a document will get the style from the
+ // correct document.
+ nsCOMPtr<nsIPresShell> presShell = GetPresShellForContent(aElement);
+ if (!presShell) {
+ presShell = aPresShell;
+ if (!presShell)
+ return nullptr;
+ }
+
+ presShell->FlushPendingNotifications(Flush_Style);
+
+ return GetStyleContextForElementNoFlush(aElement, aPseudo, presShell,
+ aStyleType);
+}
+
+/* static */
+already_AddRefed<nsStyleContext>
+nsComputedDOMStyle::GetStyleContextForElementNoFlush(Element* aElement,
+ nsIAtom* aPseudo,
+ nsIPresShell* aPresShell,
+ StyleType aStyleType)
+{
+ MOZ_ASSERT(aElement, "NULL element");
+ // If the content has a pres shell, we must use it. Otherwise we'd
+ // potentially mix rule trees by using the wrong pres shell's style
+ // set. Using the pres shell from the content also means that any
+ // content that's actually *in* a document will get the style from the
+ // correct document.
+ nsIPresShell *presShell = GetPresShellForContent(aElement);
+ bool inDocWithShell = true;
+ if (!presShell) {
+ inDocWithShell = false;
+ presShell = aPresShell;
+ if (!presShell)
+ return nullptr;
+ }
+
+ // XXX the !aElement->IsHTMLElement(nsGkAtoms::area)
+ // check is needed due to bug 135040 (to avoid using
+ // mPrimaryFrame). Remove it once that's fixed.
+ if (!aPseudo && aStyleType == eAll && inDocWithShell &&
+ !aElement->IsHTMLElement(nsGkAtoms::area)) {
+ nsIFrame* frame = nsLayoutUtils::GetStyleFrame(aElement);
+ if (frame) {
+ nsStyleContext* result = frame->StyleContext();
+ // Don't use the style context if it was influenced by
+ // pseudo-elements, since then it's not the primary style
+ // for this element.
+ if (!result->HasPseudoElementData()) {
+ // this function returns an addrefed style context
+ RefPtr<nsStyleContext> ret = result;
+ return ret.forget();
+ }
+ }
+ }
+
+ // No frame has been created, or we have a pseudo, or we're looking
+ // for the default style, so resolve the style ourselves.
+ RefPtr<nsStyleContext> parentContext;
+ nsIContent* parent = aPseudo ? aElement : aElement->GetParent();
+ // Don't resolve parent context for document fragments.
+ if (parent && parent->IsElement())
+ parentContext = GetStyleContextForElementNoFlush(parent->AsElement(),
+ nullptr, presShell,
+ aStyleType);
+
+ nsPresContext *presContext = presShell->GetPresContext();
+ if (!presContext)
+ return nullptr;
+
+ StyleSetHandle styleSet = presShell->StyleSet();
+
+ RefPtr<nsStyleContext> sc;
+ if (aPseudo) {
+ CSSPseudoElementType type = nsCSSPseudoElements::
+ GetPseudoType(aPseudo, CSSEnabledState::eIgnoreEnabledState);
+ if (type >= CSSPseudoElementType::Count) {
+ return nullptr;
+ }
+ nsIFrame* frame = nsLayoutUtils::GetStyleFrame(aElement);
+ Element* pseudoElement =
+ frame && inDocWithShell ? frame->GetPseudoElement(type) : nullptr;
+ sc = styleSet->ResolvePseudoElementStyle(aElement, type, parentContext,
+ pseudoElement);
+ } else {
+ sc = styleSet->ResolveStyleFor(aElement, parentContext);
+ }
+
+ if (aStyleType == eDefaultOnly) {
+ if (styleSet->IsServo()) {
+ NS_ERROR("stylo: ServoStyleSets cannot supply UA-only styles yet");
+ return nullptr;
+ }
+
+ // We really only want the user and UA rules. Filter out the other ones.
+ nsTArray< nsCOMPtr<nsIStyleRule> > rules;
+ for (nsRuleNode* ruleNode = sc->RuleNode();
+ !ruleNode->IsRoot();
+ ruleNode = ruleNode->GetParent()) {
+ if (ruleNode->GetLevel() == SheetType::Agent ||
+ ruleNode->GetLevel() == SheetType::User) {
+ rules.AppendElement(ruleNode->GetRule());
+ }
+ }
+
+ // We want to build a list of user/ua rules that is in order from least to
+ // most important, so we have to reverse the list.
+ // Integer division to get "stop" is purposeful here: if length is odd, we
+ // don't have to do anything with the middle element of the array.
+ for (uint32_t i = 0, length = rules.Length(), stop = length / 2;
+ i < stop; ++i) {
+ rules[i].swap(rules[length - i - 1]);
+ }
+
+ sc = styleSet->AsGecko()->ResolveStyleForRules(parentContext, rules);
+ }
+
+ return sc.forget();
+}
+
+nsMargin
+nsComputedDOMStyle::GetAdjustedValuesForBoxSizing()
+{
+ // We want the width/height of whatever parts 'width' or 'height' controls,
+ // which can be different depending on the value of the 'box-sizing' property.
+ const nsStylePosition* stylePos = StylePosition();
+
+ nsMargin adjustment;
+ if (stylePos->mBoxSizing == StyleBoxSizing::Border) {
+ adjustment = mInnerFrame->GetUsedBorderAndPadding();
+ }
+
+ return adjustment;
+}
+
+/* static */
+nsIPresShell*
+nsComputedDOMStyle::GetPresShellForContent(nsIContent* aContent)
+{
+ nsIDocument* composedDoc = aContent->GetComposedDoc();
+ if (!composedDoc)
+ return nullptr;
+
+ return composedDoc->GetShell();
+}
+
+// nsDOMCSSDeclaration abstract methods which should never be called
+// on a nsComputedDOMStyle object, but must be defined to avoid
+// compile errors.
+DeclarationBlock*
+nsComputedDOMStyle::GetCSSDeclaration(Operation)
+{
+ NS_RUNTIMEABORT("called nsComputedDOMStyle::GetCSSDeclaration");
+ return nullptr;
+}
+
+nsresult
+nsComputedDOMStyle::SetCSSDeclaration(DeclarationBlock*)
+{
+ NS_RUNTIMEABORT("called nsComputedDOMStyle::SetCSSDeclaration");
+ return NS_ERROR_FAILURE;
+}
+
+nsIDocument*
+nsComputedDOMStyle::DocToUpdate()
+{
+ NS_RUNTIMEABORT("called nsComputedDOMStyle::DocToUpdate");
+ return nullptr;
+}
+
+void
+nsComputedDOMStyle::GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv)
+{
+ NS_RUNTIMEABORT("called nsComputedDOMStyle::GetCSSParsingEnvironment");
+ // Just in case NS_RUNTIMEABORT ever stops killing us for some reason
+ aCSSParseEnv.mPrincipal = nullptr;
+}
+
+void
+nsComputedDOMStyle::ClearStyleContext()
+{
+ if (mResolvedStyleContext) {
+ mResolvedStyleContext = false;
+ mContent->RemoveMutationObserver(this);
+ }
+ mStyleContext = nullptr;
+}
+
+void
+nsComputedDOMStyle::SetResolvedStyleContext(RefPtr<nsStyleContext>&& aContext)
+{
+ if (!mResolvedStyleContext) {
+ mResolvedStyleContext = true;
+ mContent->AddMutationObserver(this);
+ }
+ mStyleContext = aContext;
+}
+
+void
+nsComputedDOMStyle::SetFrameStyleContext(nsStyleContext* aContext)
+{
+ ClearStyleContext();
+ mStyleContext = aContext;
+}
+
+void
+nsComputedDOMStyle::UpdateCurrentStyleSources(bool aNeedsLayoutFlush)
+{
+ nsCOMPtr<nsIDocument> document = do_QueryReferent(mDocumentWeak);
+ if (!document) {
+ ClearStyleContext();
+ return;
+ }
+
+ document->FlushPendingLinkUpdates();
+
+ // Flush _before_ getting the presshell, since that could create a new
+ // presshell. Also note that we want to flush the style on the document
+ // we're computing style in, not on the document mContent is in -- the two
+ // may be different.
+ document->FlushPendingNotifications(
+ aNeedsLayoutFlush ? Flush_Layout : Flush_Style);
+#ifdef DEBUG
+ mFlushedPendingReflows = aNeedsLayoutFlush;
+#endif
+
+ nsCOMPtr<nsIPresShell> presShellForContent = GetPresShellForContent(mContent);
+ if (presShellForContent && presShellForContent != document->GetShell()) {
+ presShellForContent->FlushPendingNotifications(Flush_Style);
+ }
+
+ mPresShell = document->GetShell();
+ if (!mPresShell || !mPresShell->GetPresContext()) {
+ ClearStyleContext();
+ return;
+ }
+
+ uint64_t currentGeneration =
+ mPresShell->GetPresContext()->GetRestyleGeneration();
+
+ if (mStyleContext) {
+ if (mStyleContextGeneration == currentGeneration) {
+ // Our cached style context is still valid.
+ return;
+ }
+ // We've processed some restyles, so the cached style context might
+ // be out of date.
+ mStyleContext = nullptr;
+ }
+
+ // XXX the !mContent->IsHTMLElement(nsGkAtoms::area)
+ // check is needed due to bug 135040 (to avoid using
+ // mPrimaryFrame). Remove it once that's fixed.
+ if (!mPseudo && mStyleType == eAll &&
+ !mContent->IsHTMLElement(nsGkAtoms::area)) {
+ mOuterFrame = mContent->GetPrimaryFrame();
+ mInnerFrame = mOuterFrame;
+ if (mOuterFrame) {
+ nsIAtom* type = mOuterFrame->GetType();
+ if (type == nsGkAtoms::tableWrapperFrame) {
+ // If the frame is a table wrapper frame then we should get the style
+ // from the inner table frame.
+ mInnerFrame = mOuterFrame->PrincipalChildList().FirstChild();
+ NS_ASSERTION(mInnerFrame, "table wrapper must have an inner");
+ NS_ASSERTION(!mInnerFrame->GetNextSibling(),
+ "table wrapper frames should have just one child, "
+ "the inner table");
+ }
+
+ SetFrameStyleContext(mInnerFrame->StyleContext());
+ NS_ASSERTION(mStyleContext, "Frame without style context?");
+ }
+ }
+
+ if (!mStyleContext || mStyleContext->HasPseudoElementData()) {
+#ifdef DEBUG
+ if (mStyleContext) {
+ // We want to check that going through this path because of
+ // HasPseudoElementData is rare, because it slows us down a good
+ // bit. So check that we're really inside something associated
+ // with a pseudo-element that contains elements.
+ nsStyleContext* topWithPseudoElementData = mStyleContext;
+ while (topWithPseudoElementData->GetParent()->HasPseudoElementData()) {
+ topWithPseudoElementData = topWithPseudoElementData->GetParent();
+ }
+ CSSPseudoElementType pseudo = topWithPseudoElementData->GetPseudoType();
+ nsIAtom* pseudoAtom = nsCSSPseudoElements::GetPseudoAtom(pseudo);
+ nsAutoString assertMsg(
+ NS_LITERAL_STRING("we should be in a pseudo-element that is expected to contain elements ("));
+ assertMsg.Append(nsDependentString(pseudoAtom->GetUTF16String()));
+ assertMsg.Append(')');
+ NS_ASSERTION(nsCSSPseudoElements::PseudoElementContainsElements(pseudo),
+ NS_LossyConvertUTF16toASCII(assertMsg).get());
+ }
+#endif
+ // Need to resolve a style context
+ RefPtr<nsStyleContext> resolvedStyleContext =
+ nsComputedDOMStyle::GetStyleContextForElementNoFlush(
+ mContent->AsElement(),
+ mPseudo,
+ presShellForContent ? presShellForContent.get() : mPresShell,
+ mStyleType);
+ if (!resolvedStyleContext) {
+ ClearStyleContext();
+ return;
+ }
+
+ // No need to re-get the generation, even though GetStyleContextForElement
+ // will flush, since we flushed style at the top of this function.
+ NS_ASSERTION(mPresShell &&
+ currentGeneration ==
+ mPresShell->GetPresContext()->GetRestyleGeneration(),
+ "why should we have flushed style again?");
+
+ SetResolvedStyleContext(Move(resolvedStyleContext));
+ NS_ASSERTION(mPseudo || !mStyleContext->HasPseudoElementData(),
+ "should not have pseudo-element data");
+ }
+
+ // mExposeVisitedStyle is set to true only by testing APIs that
+ // require chrome privilege.
+ MOZ_ASSERT(!mExposeVisitedStyle || nsContentUtils::IsCallerChrome(),
+ "mExposeVisitedStyle set incorrectly");
+ if (mExposeVisitedStyle && mStyleContext->RelevantLinkVisited()) {
+ nsStyleContext *styleIfVisited = mStyleContext->GetStyleIfVisited();
+ if (styleIfVisited) {
+ mStyleContext = styleIfVisited;
+ }
+ }
+}
+
+void
+nsComputedDOMStyle::ClearCurrentStyleSources()
+{
+ mOuterFrame = nullptr;
+ mInnerFrame = nullptr;
+ mPresShell = nullptr;
+
+ // Release the current style context if we got it off the frame.
+ // For a style context we resolved, keep it around so that we
+ // can re-use it next time this object is queried.
+ if (!mResolvedStyleContext) {
+ mStyleContext = nullptr;
+ }
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetPropertyCSSValue(const nsAString& aPropertyName, ErrorResult& aRv)
+{
+ nsCSSPropertyID prop =
+ nsCSSProps::LookupProperty(aPropertyName, CSSEnabledState::eForAllContent);
+
+ bool needsLayoutFlush;
+ nsComputedStyleMap::Entry::ComputeMethod getter;
+
+ if (prop == eCSSPropertyExtra_variable) {
+ needsLayoutFlush = false;
+ getter = nullptr;
+ } else {
+ // We don't (for now, anyway, though it may make sense to change it
+ // for all aliases, including those in nsCSSPropAliasList) want
+ // aliases to be enumerable (via GetLength and IndexedGetter), so
+ // handle them here rather than adding entries to
+ // GetQueryablePropertyMap.
+ if (prop != eCSSProperty_UNKNOWN &&
+ nsCSSProps::PropHasFlags(prop, CSS_PROPERTY_IS_ALIAS)) {
+ const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(prop);
+ MOZ_ASSERT(subprops[1] == eCSSProperty_UNKNOWN,
+ "must have list of length 1");
+ prop = subprops[0];
+ }
+
+ const nsComputedStyleMap::Entry* propEntry =
+ GetComputedStyleMap()->FindEntryForProperty(prop);
+
+ if (!propEntry) {
+#ifdef DEBUG_ComputedDOMStyle
+ NS_WARNING(PromiseFlatCString(NS_ConvertUTF16toUTF8(aPropertyName) +
+ NS_LITERAL_CSTRING(" is not queryable!")).get());
+#endif
+
+ // NOTE: For branches, we should flush here for compatibility!
+ return nullptr;
+ }
+
+ needsLayoutFlush = propEntry->IsLayoutFlushNeeded();
+ getter = propEntry->mGetter;
+ }
+
+ UpdateCurrentStyleSources(needsLayoutFlush);
+ if (!mStyleContext) {
+ aRv.Throw(NS_ERROR_NOT_AVAILABLE);
+ return nullptr;
+ }
+
+ RefPtr<CSSValue> val;
+ if (prop == eCSSPropertyExtra_variable) {
+ val = DoGetCustomProperty(aPropertyName);
+ } else {
+ // Call our pointer-to-member-function.
+ val = (this->*getter)();
+ }
+
+ ClearCurrentStyleSources();
+
+ return val.forget();
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::RemoveProperty(const nsAString& aPropertyName,
+ nsAString& aReturn)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+
+NS_IMETHODIMP
+nsComputedDOMStyle::GetPropertyPriority(const nsAString& aPropertyName,
+ nsAString& aReturn)
+{
+ aReturn.Truncate();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::SetProperty(const nsAString& aPropertyName,
+ const nsAString& aValue,
+ const nsAString& aPriority)
+{
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+}
+
+NS_IMETHODIMP
+nsComputedDOMStyle::Item(uint32_t aIndex, nsAString& aReturn)
+{
+ return nsDOMCSSDeclaration::Item(aIndex, aReturn);
+}
+
+void
+nsComputedDOMStyle::IndexedGetter(uint32_t aIndex,
+ bool& aFound,
+ nsAString& aPropName)
+{
+ nsComputedStyleMap* map = GetComputedStyleMap();
+ uint32_t length = map->Length();
+
+ if (aIndex < length) {
+ aFound = true;
+ CopyASCIItoUTF16(nsCSSProps::GetStringValue(map->PropertyAt(aIndex)),
+ aPropName);
+ return;
+ }
+
+ // Custom properties are exposed with indexed properties just after all
+ // of the built-in properties.
+ UpdateCurrentStyleSources(false);
+ if (!mStyleContext) {
+ aFound = false;
+ return;
+ }
+
+ const nsStyleVariables* variables = StyleVariables();
+ if (aIndex - length < variables->mVariables.Count()) {
+ aFound = true;
+ nsString varName;
+ variables->mVariables.GetVariableAt(aIndex - length, varName);
+ aPropName.AssignLiteral("--");
+ aPropName.Append(varName);
+ } else {
+ aFound = false;
+ }
+
+ ClearCurrentStyleSources();
+}
+
+// Property getters...
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBinding()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleDisplay* display = StyleDisplay();
+
+ if (display->mBinding) {
+ val->SetURI(display->mBinding->GetURI());
+ } else {
+ val->SetIdent(eCSSKeyword_none);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetClear()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mBreakType,
+ nsCSSProps::kClearKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFloat()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mFloat,
+ nsCSSProps::kFloatKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBottom()
+{
+ return GetOffsetWidthFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStackSizing()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(StyleXUL()->mStretchStack ? eCSSKeyword_stretch_to_fit :
+ eCSSKeyword_ignore);
+ return val.forget();
+}
+
+void
+nsComputedDOMStyle::SetToRGBAColor(nsROCSSPrimitiveValue* aValue,
+ nscolor aColor)
+{
+ if (NS_GET_A(aColor) == 0) {
+ aValue->SetIdent(eCSSKeyword_transparent);
+ return;
+ }
+
+ nsROCSSPrimitiveValue *red = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *green = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *blue = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *alpha = new nsROCSSPrimitiveValue;
+
+ uint8_t a = NS_GET_A(aColor);
+ nsDOMCSSRGBColor *rgbColor =
+ new nsDOMCSSRGBColor(red, green, blue, alpha, a < 255);
+
+ red->SetNumber(NS_GET_R(aColor));
+ green->SetNumber(NS_GET_G(aColor));
+ blue->SetNumber(NS_GET_B(aColor));
+ alpha->SetNumber(nsStyleUtil::ColorComponentToFloat(a));
+
+ aValue->SetColor(rgbColor);
+}
+
+void
+nsComputedDOMStyle::SetValueFromComplexColor(nsROCSSPrimitiveValue* aValue,
+ const StyleComplexColor& aColor)
+{
+ SetToRGBAColor(aValue, StyleColor()->CalcComplexColor(aColor));
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetToRGBAColor(val, StyleColor()->mColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColorAdjust()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleVisibility()->mColorAdjust,
+ nsCSSProps::kColorAdjustKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOpacity()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleEffects()->mOpacity);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnCount()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleColumn* column = StyleColumn();
+
+ if (column->mColumnCount == NS_STYLE_COLUMN_COUNT_AUTO) {
+ val->SetIdent(eCSSKeyword_auto);
+ } else {
+ val->SetNumber(column->mColumnCount);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ // XXX fix the auto case. When we actually have a column frame, I think
+ // we should return the computed column width.
+ SetValueToCoord(val, StyleColumn()->mColumnWidth, true);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnGap()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleColumn* column = StyleColumn();
+ if (column->mColumnGap.GetUnit() == eStyleUnit_Normal) {
+ val->SetAppUnits(StyleFont()->mFont.size);
+ } else {
+ SetValueToCoord(val, StyleColumn()->mColumnGap, true);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnFill()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleColumn()->mColumnFill,
+ nsCSSProps::kColumnFillKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnRuleWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(StyleColumn()->GetComputedColumnRuleWidth());
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnRuleStyle()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleColumn()->mColumnRuleStyle,
+ nsCSSProps::kBorderStyleKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColumnRuleColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleColumn()->mColumnRuleColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetContent()
+{
+ const nsStyleContent *content = StyleContent();
+
+ if (content->ContentCount() == 0) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ if (content->ContentCount() == 1 &&
+ content->ContentAt(0).mType == eStyleContentType_AltContent) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword__moz_alt_content);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ for (uint32_t i = 0, i_end = content->ContentCount(); i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleContentData &data = content->ContentAt(i);
+ switch (data.mType) {
+ case eStyleContentType_String:
+ {
+ nsAutoString str;
+ nsStyleUtil::AppendEscapedCSSString(
+ nsDependentString(data.mContent.mString), str);
+ val->SetString(str);
+ }
+ break;
+ case eStyleContentType_Image:
+ {
+ nsCOMPtr<nsIURI> uri;
+ if (data.mContent.mImage) {
+ data.mContent.mImage->GetURI(getter_AddRefs(uri));
+ }
+ val->SetURI(uri);
+ }
+ break;
+ case eStyleContentType_Attr:
+ {
+ nsAutoString str;
+ nsStyleUtil::AppendEscapedCSSIdent(
+ nsDependentString(data.mContent.mString), str);
+ val->SetString(str, nsIDOMCSSPrimitiveValue::CSS_ATTR);
+ }
+ break;
+ case eStyleContentType_Counter:
+ case eStyleContentType_Counters:
+ {
+ /* FIXME: counters should really use an object */
+ nsAutoString str;
+ if (data.mType == eStyleContentType_Counter) {
+ str.AppendLiteral("counter(");
+ }
+ else {
+ str.AppendLiteral("counters(");
+ }
+ // WRITE ME
+ nsCSSValue::Array *a = data.mContent.mCounters;
+
+ nsStyleUtil::AppendEscapedCSSIdent(
+ nsDependentString(a->Item(0).GetStringBufferValue()), str);
+ int32_t typeItem = 1;
+ if (data.mType == eStyleContentType_Counters) {
+ typeItem = 2;
+ str.AppendLiteral(", ");
+ nsStyleUtil::AppendEscapedCSSString(
+ nsDependentString(a->Item(1).GetStringBufferValue()), str);
+ }
+ MOZ_ASSERT(eCSSUnit_None != a->Item(typeItem).GetUnit(),
+ "'none' should be handled as identifier value");
+ nsString type;
+ a->Item(typeItem).AppendToString(eCSSProperty_list_style_type,
+ type, nsCSSValue::eNormalized);
+ if (!type.LowerCaseEqualsLiteral("decimal")) {
+ str.AppendLiteral(", ");
+ str.Append(type);
+ }
+
+ str.Append(char16_t(')'));
+ val->SetString(str, nsIDOMCSSPrimitiveValue::CSS_COUNTER);
+ }
+ break;
+ case eStyleContentType_OpenQuote:
+ val->SetIdent(eCSSKeyword_open_quote);
+ break;
+ case eStyleContentType_CloseQuote:
+ val->SetIdent(eCSSKeyword_close_quote);
+ break;
+ case eStyleContentType_NoOpenQuote:
+ val->SetIdent(eCSSKeyword_no_open_quote);
+ break;
+ case eStyleContentType_NoCloseQuote:
+ val->SetIdent(eCSSKeyword_no_close_quote);
+ break;
+ case eStyleContentType_AltContent:
+ default:
+ NS_NOTREACHED("unexpected type");
+ break;
+ }
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetCounterIncrement()
+{
+ const nsStyleContent *content = StyleContent();
+
+ if (content->CounterIncrementCount() == 0) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ for (uint32_t i = 0, i_end = content->CounterIncrementCount(); i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> name = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
+
+ const nsStyleCounterData& data = content->CounterIncrementAt(i);
+ nsAutoString escaped;
+ nsStyleUtil::AppendEscapedCSSIdent(data.mCounter, escaped);
+ name->SetString(escaped);
+ value->SetNumber(data.mValue); // XXX This should really be integer
+
+ valueList->AppendCSSValue(name.forget());
+ valueList->AppendCSSValue(value.forget());
+ }
+
+ return valueList.forget();
+}
+
+/* Convert the stored representation into a list of two values and then hand
+ * it back.
+ */
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransformOrigin()
+{
+ /* We need to build up a list of two values. We'll call them
+ * width and height.
+ */
+
+ /* Store things as a value list */
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ /* Now, get the values. */
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsROCSSPrimitiveValue> width = new nsROCSSPrimitiveValue;
+ SetValueToCoord(width, display->mTransformOrigin[0], false,
+ &nsComputedDOMStyle::GetFrameBoundsWidthForTransform);
+ valueList->AppendCSSValue(width.forget());
+
+ RefPtr<nsROCSSPrimitiveValue> height = new nsROCSSPrimitiveValue;
+ SetValueToCoord(height, display->mTransformOrigin[1], false,
+ &nsComputedDOMStyle::GetFrameBoundsHeightForTransform);
+ valueList->AppendCSSValue(height.forget());
+
+ if (display->mTransformOrigin[2].GetUnit() != eStyleUnit_Coord ||
+ display->mTransformOrigin[2].GetCoordValue() != 0) {
+ RefPtr<nsROCSSPrimitiveValue> depth = new nsROCSSPrimitiveValue;
+ SetValueToCoord(depth, display->mTransformOrigin[2], false,
+ nullptr);
+ valueList->AppendCSSValue(depth.forget());
+ }
+
+ return valueList.forget();
+}
+
+/* Convert the stored representation into a list of two values and then hand
+ * it back.
+ */
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPerspectiveOrigin()
+{
+ /* We need to build up a list of two values. We'll call them
+ * width and height.
+ */
+
+ /* Store things as a value list */
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ /* Now, get the values. */
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsROCSSPrimitiveValue> width = new nsROCSSPrimitiveValue;
+ SetValueToCoord(width, display->mPerspectiveOrigin[0], false,
+ &nsComputedDOMStyle::GetFrameBoundsWidthForTransform);
+ valueList->AppendCSSValue(width.forget());
+
+ RefPtr<nsROCSSPrimitiveValue> height = new nsROCSSPrimitiveValue;
+ SetValueToCoord(height, display->mPerspectiveOrigin[1], false,
+ &nsComputedDOMStyle::GetFrameBoundsHeightForTransform);
+ valueList->AppendCSSValue(height.forget());
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPerspective()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleDisplay()->mChildPerspective, false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackfaceVisibility()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mBackfaceVisibility,
+ nsCSSProps::kBackfaceVisibilityKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransformStyle()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mTransformStyle,
+ nsCSSProps::kTransformStyleKTable));
+ return val.forget();
+}
+
+/* If the property is "none", hand back "none" wrapped in a value.
+ * Otherwise, compute the aggregate transform matrix and hands it back in a
+ * "matrix" wrapper.
+ */
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransform()
+{
+ /* First, get the display data. We'll need it. */
+ const nsStyleDisplay* display = StyleDisplay();
+
+ /* If there are no transforms, then we should construct a single-element
+ * entry and hand it back.
+ */
+ if (!display->mSpecifiedTransform) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ /* Set it to "none." */
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ /* Otherwise, we need to compute the current value of the transform matrix,
+ * store it in a string, and hand it back to the caller.
+ */
+
+ /* Use the inner frame for the reference box. If we don't have an inner
+ * frame we use empty dimensions to allow us to continue (and percentage
+ * values in the transform will simply give broken results).
+ * TODO: There is no good way for us to represent the case where there's no
+ * frame, which is problematic. The reason is that when we have percentage
+ * transforms, there are a total of four stored matrix entries that influence
+ * the transform based on the size of the element. However, this poses a
+ * problem, because only two of these values can be explicitly referenced
+ * using the named transforms. Until a real solution is found, we'll just
+ * use this approach.
+ */
+ nsStyleTransformMatrix::TransformReferenceBox refBox(mInnerFrame,
+ nsSize(0, 0));
+
+ RuleNodeCacheConditions dummy;
+ bool dummyBool;
+ gfx::Matrix4x4 matrix =
+ nsStyleTransformMatrix::ReadTransforms(display->mSpecifiedTransform->mHead,
+ mStyleContext,
+ mStyleContext->PresContext(),
+ dummy,
+ refBox,
+ float(mozilla::AppUnitsPerCSSPixel()),
+ &dummyBool);
+
+ return MatrixToCSSValue(matrix);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransformBox()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mTransformBox,
+ nsCSSProps::kTransformBoxKTable));
+ return val.forget();
+}
+
+/* static */ already_AddRefed<nsROCSSPrimitiveValue>
+nsComputedDOMStyle::MatrixToCSSValue(const mozilla::gfx::Matrix4x4& matrix)
+{
+ bool is3D = !matrix.Is2D();
+
+ nsAutoString resultString(NS_LITERAL_STRING("matrix"));
+ if (is3D) {
+ resultString.AppendLiteral("3d");
+ }
+
+ resultString.Append('(');
+ resultString.AppendFloat(matrix._11);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._12);
+ resultString.AppendLiteral(", ");
+ if (is3D) {
+ resultString.AppendFloat(matrix._13);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._14);
+ resultString.AppendLiteral(", ");
+ }
+ resultString.AppendFloat(matrix._21);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._22);
+ resultString.AppendLiteral(", ");
+ if (is3D) {
+ resultString.AppendFloat(matrix._23);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._24);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._31);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._32);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._33);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._34);
+ resultString.AppendLiteral(", ");
+ }
+ resultString.AppendFloat(matrix._41);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._42);
+ if (is3D) {
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._43);
+ resultString.AppendLiteral(", ");
+ resultString.AppendFloat(matrix._44);
+ }
+ resultString.Append(')');
+
+ /* Create a value to hold our result. */
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ val->SetString(resultString);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetCounterReset()
+{
+ const nsStyleContent *content = StyleContent();
+
+ if (content->CounterResetCount() == 0) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ for (uint32_t i = 0, i_end = content->CounterResetCount(); i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> name = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
+
+ const nsStyleCounterData& data = content->CounterResetAt(i);
+ nsAutoString escaped;
+ nsStyleUtil::AppendEscapedCSSIdent(data.mCounter, escaped);
+ name->SetString(escaped);
+ value->SetNumber(data.mValue); // XXX This should really be integer
+
+ valueList->AppendCSSValue(name.forget());
+ valueList->AppendCSSValue(value.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetQuotes()
+{
+ const auto& quotePairs = StyleList()->GetQuotePairs();
+
+ if (quotePairs.IsEmpty()) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ for (const auto& quotePair : quotePairs) {
+ RefPtr<nsROCSSPrimitiveValue> openVal = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> closeVal = new nsROCSSPrimitiveValue;
+
+ nsAutoString s;
+ nsStyleUtil::AppendEscapedCSSString(quotePair.first, s);
+ openVal->SetString(s);
+ s.Truncate();
+ nsStyleUtil::AppendEscapedCSSString(quotePair.second, s);
+ closeVal->SetString(s);
+
+ valueList->AppendCSSValue(openVal.forget());
+ valueList->AppendCSSValue(closeVal.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontFamily()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleFont* font = StyleFont();
+ nsAutoString fontlistStr;
+ nsStyleUtil::AppendEscapedCSSFontFamilyList(font->mFont.fontlist,
+ fontlistStr);
+ val->SetString(fontlistStr);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontSize()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ // Note: StyleFont()->mSize is the 'computed size';
+ // StyleFont()->mFont.size is the 'actual size'
+ val->SetAppUnits(StyleFont()->mSize);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontSizeAdjust()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleFont *font = StyleFont();
+
+ if (font->mFont.sizeAdjust >= 0.0f) {
+ val->SetNumber(font->mFont.sizeAdjust);
+ } else {
+ val->SetIdent(eCSSKeyword_none);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOsxFontSmoothing()
+{
+ if (nsContentUtils::ShouldResistFingerprinting(
+ mPresShell->GetPresContext()->GetDocShell()))
+ return nullptr;
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleFont()->mFont.smoothing,
+ nsCSSProps::kFontSmoothingKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontStretch()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleFont()->mFont.stretch,
+ nsCSSProps::kFontStretchKTable));
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontStyle()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleFont()->mFont.style,
+ nsCSSProps::kFontStyleKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontWeight()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleFont* font = StyleFont();
+
+ uint16_t weight = font->mFont.weight;
+ NS_ASSERTION(weight % 100 == 0, "unexpected value of font-weight");
+ val->SetNumber(weight);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontFeatureSettings()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleFont* font = StyleFont();
+ if (font->mFont.fontFeatureSettings.IsEmpty()) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else {
+ nsAutoString result;
+ nsStyleUtil::AppendFontFeatureSettings(font->mFont.fontFeatureSettings,
+ result);
+ val->SetString(result);
+ }
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontKerning()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleFont()->mFont.kerning,
+ nsCSSProps::kFontKerningKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontLanguageOverride()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleFont* font = StyleFont();
+ if (font->mFont.languageOverride.IsEmpty()) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else {
+ nsAutoString str;
+ nsStyleUtil::AppendEscapedCSSString(font->mFont.languageOverride, str);
+ val->SetString(str);
+ }
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontSynthesis()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.synthesis;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_none);
+ } else {
+ nsAutoString valueStr;
+
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_font_synthesis,
+ intValue, NS_FONT_SYNTHESIS_WEIGHT,
+ NS_FONT_SYNTHESIS_STYLE, valueStr);
+ val->SetString(valueStr);
+ }
+
+ return val.forget();
+}
+
+// return a value *only* for valid longhand values from CSS 2.1, either
+// normal or small-caps only
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariant()
+{
+ const nsFont& f = StyleFont()->mFont;
+
+ // if any of the other font-variant subproperties other than
+ // font-variant-caps are not normal then can't calculate a computed value
+ if (f.variantAlternates || f.variantEastAsian || f.variantLigatures ||
+ f.variantNumeric || f.variantPosition) {
+ return nullptr;
+ }
+
+ nsCSSKeyword keyword;
+ switch (f.variantCaps) {
+ case 0:
+ keyword = eCSSKeyword_normal;
+ break;
+ case NS_FONT_VARIANT_CAPS_SMALLCAPS:
+ keyword = eCSSKeyword_small_caps;
+ break;
+ default:
+ return nullptr;
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(keyword);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariantAlternates()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.variantAlternates;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_normal);
+ return val.forget();
+ }
+
+ // first, include enumerated values
+ nsAutoString valueStr;
+
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_font_variant_alternates,
+ intValue & NS_FONT_VARIANT_ALTERNATES_ENUMERATED_MASK,
+ NS_FONT_VARIANT_ALTERNATES_HISTORICAL,
+ NS_FONT_VARIANT_ALTERNATES_HISTORICAL, valueStr);
+
+ // next, include functional values if present
+ if (intValue & NS_FONT_VARIANT_ALTERNATES_FUNCTIONAL_MASK) {
+ nsStyleUtil::SerializeFunctionalAlternates(StyleFont()->mFont.alternateValues,
+ valueStr);
+ }
+
+ val->SetString(valueStr);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariantCaps()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.variantCaps;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else {
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(intValue,
+ nsCSSProps::kFontVariantCapsKTable));
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariantEastAsian()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.variantEastAsian;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else {
+ nsAutoString valueStr;
+
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_font_variant_east_asian,
+ intValue, NS_FONT_VARIANT_EAST_ASIAN_JIS78,
+ NS_FONT_VARIANT_EAST_ASIAN_RUBY, valueStr);
+ val->SetString(valueStr);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariantLigatures()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.variantLigatures;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else if (NS_FONT_VARIANT_LIGATURES_NONE == intValue) {
+ val->SetIdent(eCSSKeyword_none);
+ } else {
+ nsAutoString valueStr;
+
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_font_variant_ligatures,
+ intValue, NS_FONT_VARIANT_LIGATURES_NONE,
+ NS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL, valueStr);
+ val->SetString(valueStr);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariantNumeric()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.variantNumeric;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else {
+ nsAutoString valueStr;
+
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_font_variant_numeric,
+ intValue, NS_FONT_VARIANT_NUMERIC_LINING,
+ NS_FONT_VARIANT_NUMERIC_ORDINAL, valueStr);
+ val->SetString(valueStr);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFontVariantPosition()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleFont()->mFont.variantPosition;
+
+ if (0 == intValue) {
+ val->SetIdent(eCSSKeyword_normal);
+ } else {
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(intValue,
+ nsCSSProps::kFontVariantPositionKTable));
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetBackgroundList(uint8_t nsStyleImageLayers::Layer::* aMember,
+ uint32_t nsStyleImageLayers::* aCount,
+ const nsStyleImageLayers& aLayers,
+ const KTableEntry aTable[])
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ for (uint32_t i = 0, i_end = aLayers.*aCount; i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(aLayers.mLayers[i].*aMember,
+ aTable));
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundAttachment()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mAttachment,
+ &nsStyleImageLayers::mAttachmentCount,
+ StyleBackground()->mImage,
+ nsCSSProps::kImageLayerAttachmentKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundClip()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mClip,
+ &nsStyleImageLayers::mClipCount,
+ StyleBackground()->mImage,
+ nsCSSProps::kBackgroundClipKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetToRGBAColor(val, StyleBackground()->mBackgroundColor);
+ return val.forget();
+}
+
+static void
+SetValueToCalc(const nsStyleCoord::CalcValue* aCalc,
+ nsROCSSPrimitiveValue* aValue)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString tmp, result;
+
+ result.AppendLiteral("calc(");
+
+ val->SetAppUnits(aCalc->mLength);
+ val->GetCssText(tmp);
+ result.Append(tmp);
+
+ if (aCalc->mHasPercent) {
+ result.AppendLiteral(" + ");
+
+ val->SetPercent(aCalc->mPercent);
+ val->GetCssText(tmp);
+ result.Append(tmp);
+ }
+
+ result.Append(')');
+
+ aValue->SetString(result); // not really SetString
+}
+
+static void
+AppendCSSGradientLength(const nsStyleCoord& aValue,
+ nsROCSSPrimitiveValue* aPrimitive,
+ nsAString& aString)
+{
+ nsAutoString tokenString;
+ if (aValue.IsCalcUnit())
+ SetValueToCalc(aValue.GetCalcValue(), aPrimitive);
+ else if (aValue.GetUnit() == eStyleUnit_Coord)
+ aPrimitive->SetAppUnits(aValue.GetCoordValue());
+ else
+ aPrimitive->SetPercent(aValue.GetPercentValue());
+ aPrimitive->GetCssText(tokenString);
+ aString.Append(tokenString);
+}
+
+static void
+AppendCSSGradientToBoxPosition(const nsStyleGradient* aGradient,
+ nsAString& aString,
+ bool& aNeedSep)
+{
+ float xValue = aGradient->mBgPosX.GetPercentValue();
+ float yValue = aGradient->mBgPosY.GetPercentValue();
+
+ if (yValue == 1.0f && xValue == 0.5f) {
+ // omit "to bottom"
+ return;
+ }
+ NS_ASSERTION(yValue != 0.5f || xValue != 0.5f, "invalid box position");
+
+ aString.AppendLiteral("to");
+
+ if (yValue == 0.0f) {
+ aString.AppendLiteral(" top");
+ } else if (yValue == 1.0f) {
+ aString.AppendLiteral(" bottom");
+ } else if (yValue != 0.5f) { // do not write "center" keyword
+ NS_NOTREACHED("invalid box position");
+ }
+
+ if (xValue == 0.0f) {
+ aString.AppendLiteral(" left");
+ } else if (xValue == 1.0f) {
+ aString.AppendLiteral(" right");
+ } else if (xValue != 0.5f) { // do not write "center" keyword
+ NS_NOTREACHED("invalid box position");
+ }
+
+ aNeedSep = true;
+}
+
+void
+nsComputedDOMStyle::GetCSSGradientString(const nsStyleGradient* aGradient,
+ nsAString& aString)
+{
+ if (!aGradient->mLegacySyntax) {
+ aString.Truncate();
+ } else {
+ aString.AssignLiteral("-moz-");
+ }
+ if (aGradient->mRepeating) {
+ aString.AppendLiteral("repeating-");
+ }
+ bool isRadial = aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR;
+ if (isRadial) {
+ aString.AppendLiteral("radial-gradient(");
+ } else {
+ aString.AppendLiteral("linear-gradient(");
+ }
+
+ bool needSep = false;
+ nsAutoString tokenString;
+ RefPtr<nsROCSSPrimitiveValue> tmpVal = new nsROCSSPrimitiveValue;
+
+ if (isRadial && !aGradient->mLegacySyntax) {
+ if (aGradient->mSize != NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE) {
+ if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR) {
+ aString.AppendLiteral("circle");
+ needSep = true;
+ }
+ if (aGradient->mSize != NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER) {
+ if (needSep) {
+ aString.Append(' ');
+ }
+ AppendASCIItoUTF16(nsCSSProps::
+ ValueToKeyword(aGradient->mSize,
+ nsCSSProps::kRadialGradientSizeKTable),
+ aString);
+ needSep = true;
+ }
+ } else {
+ AppendCSSGradientLength(aGradient->mRadiusX, tmpVal, aString);
+ if (aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_CIRCULAR) {
+ aString.Append(' ');
+ AppendCSSGradientLength(aGradient->mRadiusY, tmpVal, aString);
+ }
+ needSep = true;
+ }
+ }
+ if (aGradient->mBgPosX.GetUnit() != eStyleUnit_None) {
+ MOZ_ASSERT(aGradient->mBgPosY.GetUnit() != eStyleUnit_None);
+ if (!isRadial && !aGradient->mLegacySyntax) {
+ AppendCSSGradientToBoxPosition(aGradient, aString, needSep);
+ } else if (aGradient->mBgPosX.GetUnit() != eStyleUnit_Percent ||
+ aGradient->mBgPosX.GetPercentValue() != 0.5f ||
+ aGradient->mBgPosY.GetUnit() != eStyleUnit_Percent ||
+ aGradient->mBgPosY.GetPercentValue() != (isRadial ? 0.5f : 1.0f)) {
+ if (isRadial && !aGradient->mLegacySyntax) {
+ if (needSep) {
+ aString.Append(' ');
+ }
+ aString.AppendLiteral("at ");
+ needSep = false;
+ }
+ AppendCSSGradientLength(aGradient->mBgPosX, tmpVal, aString);
+ if (aGradient->mBgPosY.GetUnit() != eStyleUnit_None) {
+ aString.Append(' ');
+ AppendCSSGradientLength(aGradient->mBgPosY, tmpVal, aString);
+ }
+ needSep = true;
+ }
+ }
+ if (aGradient->mAngle.GetUnit() != eStyleUnit_None) {
+ MOZ_ASSERT(!isRadial || aGradient->mLegacySyntax);
+ if (needSep) {
+ aString.Append(' ');
+ }
+ nsStyleUtil::AppendAngleValue(aGradient->mAngle, aString);
+ needSep = true;
+ }
+
+ if (isRadial && aGradient->mLegacySyntax &&
+ (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR ||
+ aGradient->mSize != NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER)) {
+ MOZ_ASSERT(aGradient->mSize != NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE);
+ if (needSep) {
+ aString.AppendLiteral(", ");
+ needSep = false;
+ }
+ if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_CIRCULAR) {
+ aString.AppendLiteral("circle");
+ needSep = true;
+ }
+ if (aGradient->mSize != NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER) {
+ if (needSep) {
+ aString.Append(' ');
+ }
+ AppendASCIItoUTF16(nsCSSProps::
+ ValueToKeyword(aGradient->mSize,
+ nsCSSProps::kRadialGradientSizeKTable),
+ aString);
+ }
+ needSep = true;
+ }
+
+
+ // color stops
+ for (uint32_t i = 0; i < aGradient->mStops.Length(); ++i) {
+ if (needSep) {
+ aString.AppendLiteral(", ");
+ }
+
+ const auto& stop = aGradient->mStops[i];
+ if (!stop.mIsInterpolationHint) {
+ SetToRGBAColor(tmpVal, stop.mColor);
+ tmpVal->GetCssText(tokenString);
+ aString.Append(tokenString);
+ }
+
+ if (stop.mLocation.GetUnit() != eStyleUnit_None) {
+ if (!stop.mIsInterpolationHint) {
+ aString.Append(' ');
+ }
+ AppendCSSGradientLength(stop.mLocation, tmpVal, aString);
+ }
+ needSep = true;
+ }
+
+ aString.Append(')');
+}
+
+// -moz-image-rect(<uri>, <top>, <right>, <bottom>, <left>)
+void
+nsComputedDOMStyle::GetImageRectString(nsIURI* aURI,
+ const nsStyleSides& aCropRect,
+ nsString& aString)
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ // <uri>
+ RefPtr<nsROCSSPrimitiveValue> valURI = new nsROCSSPrimitiveValue;
+ valURI->SetURI(aURI);
+ valueList->AppendCSSValue(valURI.forget());
+
+ // <top>, <right>, <bottom>, <left>
+ NS_FOR_CSS_SIDES(side) {
+ RefPtr<nsROCSSPrimitiveValue> valSide = new nsROCSSPrimitiveValue;
+ SetValueToCoord(valSide, aCropRect.Get(side), false);
+ valueList->AppendCSSValue(valSide.forget());
+ }
+
+ nsAutoString argumentString;
+ valueList->GetCssText(argumentString);
+
+ aString = NS_LITERAL_STRING("-moz-image-rect(") +
+ argumentString +
+ NS_LITERAL_STRING(")");
+}
+
+void
+nsComputedDOMStyle::SetValueToStyleImage(const nsStyleImage& aStyleImage,
+ nsROCSSPrimitiveValue* aValue)
+{
+ switch (aStyleImage.GetType()) {
+ case eStyleImageType_Image:
+ {
+ imgIRequest* req = aStyleImage.GetImageData();
+ if (!req) {
+ // XXXheycam If we had some problem resolving the imgRequestProxy,
+ // maybe we should just use the URL stored in the nsStyleImage's
+ // mImageValue? (Similarly in DoGetListStyleImage.)
+ aValue->SetIdent(eCSSKeyword_none);
+ break;
+ }
+
+ nsCOMPtr<nsIURI> uri;
+ req->GetURI(getter_AddRefs(uri));
+
+ const UniquePtr<nsStyleSides>& cropRect = aStyleImage.GetCropRect();
+ if (cropRect) {
+ nsAutoString imageRectString;
+ GetImageRectString(uri, *cropRect, imageRectString);
+ aValue->SetString(imageRectString);
+ } else {
+ aValue->SetURI(uri);
+ }
+ break;
+ }
+ case eStyleImageType_Gradient:
+ {
+ nsAutoString gradientString;
+ GetCSSGradientString(aStyleImage.GetGradientData(),
+ gradientString);
+ aValue->SetString(gradientString);
+ break;
+ }
+ case eStyleImageType_Element:
+ {
+ nsAutoString elementId;
+ nsStyleUtil::AppendEscapedCSSIdent(
+ nsDependentString(aStyleImage.GetElementId()), elementId);
+ nsAutoString elementString = NS_LITERAL_STRING("-moz-element(#") +
+ elementId +
+ NS_LITERAL_STRING(")");
+ aValue->SetString(elementString);
+ break;
+ }
+ case eStyleImageType_Null:
+ aValue->SetIdent(eCSSKeyword_none);
+ break;
+ default:
+ NS_NOTREACHED("unexpected image type");
+ break;
+ }
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageLayerImage(const nsStyleImageLayers& aLayers)
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ for (uint32_t i = 0, i_end = aLayers.mImageCount; i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleImage& image = aLayers.mLayers[i].mImage;
+ // Layer::mImage::GetType() returns eStyleImageType_Null in two conditions:
+ // 1. The value of mask-image/bg-image is 'none'.
+ // Since this layer does not refer to any source, Layer::mSourceURI must
+ // be nullptr too.
+ // 2. This layer refers to a local resource, e.g. mask-image:url(#mymask).
+ // For local references, there is no need to download any external
+ // resource, so Layer::mImage is not used.
+ // Instead, we store the local URI in one place -- on Layer::mSourceURI.
+ // Hence, we must serialize using mSourceURI (instead of
+ // SetValueToStyleImage()/mImage) in this case.
+ if (aLayers.mLayers[i].mSourceURI &&
+ aLayers.mLayers[i].mSourceURI->IsLocalRef()) {
+ // This is how we represent a 'mask-image' reference for a local URI,
+ // such as 'mask-image:url(#mymask)' or 'mask:url(#mymask)'
+ SetValueToURLValue(aLayers.mLayers[i].mSourceURI, val);
+ } else {
+ SetValueToStyleImage(image, val);
+ }
+
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageLayerPosition(const nsStyleImageLayers& aLayers)
+{
+ if (aLayers.mPositionXCount != aLayers.mPositionYCount) {
+ // No value to return. We can't express this combination of
+ // values as a shorthand.
+ return nullptr;
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+ for (uint32_t i = 0, i_end = aLayers.mPositionXCount; i < i_end; ++i) {
+ RefPtr<nsDOMCSSValueList> itemList = GetROCSSValueList(false);
+
+ SetValueToPosition(aLayers.mLayers[i].mPosition, itemList);
+ valueList->AppendCSSValue(itemList.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageLayerPositionX(const nsStyleImageLayers& aLayers)
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+ for (uint32_t i = 0, i_end = aLayers.mPositionXCount; i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToPositionCoord(aLayers.mLayers[i].mPosition.mXPosition, val);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageLayerPositionY(const nsStyleImageLayers& aLayers)
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+ for (uint32_t i = 0, i_end = aLayers.mPositionYCount; i < i_end; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToPositionCoord(aLayers.mLayers[i].mPosition.mYPosition, val);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageLayerRepeat(const nsStyleImageLayers& aLayers)
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ for (uint32_t i = 0, i_end = aLayers.mRepeatCount; i < i_end; ++i) {
+ RefPtr<nsDOMCSSValueList> itemList = GetROCSSValueList(false);
+ RefPtr<nsROCSSPrimitiveValue> valX = new nsROCSSPrimitiveValue;
+
+ const uint8_t& xRepeat = aLayers.mLayers[i].mRepeat.mXRepeat;
+ const uint8_t& yRepeat = aLayers.mLayers[i].mRepeat.mYRepeat;
+
+ bool hasContraction = true;
+ unsigned contraction;
+ if (xRepeat == yRepeat) {
+ contraction = xRepeat;
+ } else if (xRepeat == NS_STYLE_IMAGELAYER_REPEAT_REPEAT &&
+ yRepeat == NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT) {
+ contraction = NS_STYLE_IMAGELAYER_REPEAT_REPEAT_X;
+ } else if (xRepeat == NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT &&
+ yRepeat == NS_STYLE_IMAGELAYER_REPEAT_REPEAT) {
+ contraction = NS_STYLE_IMAGELAYER_REPEAT_REPEAT_Y;
+ } else {
+ hasContraction = false;
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> valY;
+ if (hasContraction) {
+ valX->SetIdent(nsCSSProps::ValueToKeywordEnum(contraction,
+ nsCSSProps::kImageLayerRepeatKTable));
+ } else {
+ valY = new nsROCSSPrimitiveValue;
+
+ valX->SetIdent(nsCSSProps::ValueToKeywordEnum(xRepeat,
+ nsCSSProps::kImageLayerRepeatKTable));
+ valY->SetIdent(nsCSSProps::ValueToKeywordEnum(yRepeat,
+ nsCSSProps::kImageLayerRepeatKTable));
+ }
+ itemList->AppendCSSValue(valX.forget());
+ if (valY) {
+ itemList->AppendCSSValue(valY.forget());
+ }
+ valueList->AppendCSSValue(itemList.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageLayerSize(const nsStyleImageLayers& aLayers)
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ for (uint32_t i = 0, i_end = aLayers.mSizeCount; i < i_end; ++i) {
+ const nsStyleImageLayers::Size &size = aLayers.mLayers[i].mSize;
+
+ switch (size.mWidthType) {
+ case nsStyleImageLayers::Size::eContain:
+ case nsStyleImageLayers::Size::eCover: {
+ MOZ_ASSERT(size.mWidthType == size.mHeightType,
+ "unsynced types");
+ nsCSSKeyword keyword = size.mWidthType == nsStyleImageLayers::Size::eContain
+ ? eCSSKeyword_contain
+ : eCSSKeyword_cover;
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(keyword);
+ valueList->AppendCSSValue(val.forget());
+ break;
+ }
+ default: {
+ RefPtr<nsDOMCSSValueList> itemList = GetROCSSValueList(false);
+
+ RefPtr<nsROCSSPrimitiveValue> valX = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> valY = new nsROCSSPrimitiveValue;
+
+ if (size.mWidthType == nsStyleImageLayers::Size::eAuto) {
+ valX->SetIdent(eCSSKeyword_auto);
+ } else {
+ MOZ_ASSERT(size.mWidthType ==
+ nsStyleImageLayers::Size::eLengthPercentage,
+ "bad mWidthType");
+ if (!size.mWidth.mHasPercent &&
+ // negative values must have come from calc()
+ size.mWidth.mLength >= 0) {
+ MOZ_ASSERT(size.mWidth.mPercent == 0.0f,
+ "Shouldn't have mPercent");
+ valX->SetAppUnits(size.mWidth.mLength);
+ } else if (size.mWidth.mLength == 0 &&
+ // negative values must have come from calc()
+ size.mWidth.mPercent >= 0.0f) {
+ valX->SetPercent(size.mWidth.mPercent);
+ } else {
+ SetValueToCalc(&size.mWidth, valX);
+ }
+ }
+
+ if (size.mHeightType == nsStyleImageLayers::Size::eAuto) {
+ valY->SetIdent(eCSSKeyword_auto);
+ } else {
+ MOZ_ASSERT(size.mHeightType ==
+ nsStyleImageLayers::Size::eLengthPercentage,
+ "bad mHeightType");
+ if (!size.mHeight.mHasPercent &&
+ // negative values must have come from calc()
+ size.mHeight.mLength >= 0) {
+ MOZ_ASSERT(size.mHeight.mPercent == 0.0f,
+ "Shouldn't have mPercent");
+ valY->SetAppUnits(size.mHeight.mLength);
+ } else if (size.mHeight.mLength == 0 &&
+ // negative values must have come from calc()
+ size.mHeight.mPercent >= 0.0f) {
+ valY->SetPercent(size.mHeight.mPercent);
+ } else {
+ SetValueToCalc(&size.mHeight, valY);
+ }
+ }
+ itemList->AppendCSSValue(valX.forget());
+ itemList->AppendCSSValue(valY.forget());
+ valueList->AppendCSSValue(itemList.forget());
+ break;
+ }
+ }
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundImage()
+{
+ const nsStyleImageLayers& layers = StyleBackground()->mImage;
+ return DoGetImageLayerImage(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundBlendMode()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mBlendMode,
+ &nsStyleImageLayers::mBlendModeCount,
+ StyleBackground()->mImage,
+ nsCSSProps::kBlendModeKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundOrigin()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mOrigin,
+ &nsStyleImageLayers::mOriginCount,
+ StyleBackground()->mImage,
+ nsCSSProps::kImageLayerOriginKTable);
+}
+
+void
+nsComputedDOMStyle::SetValueToPositionCoord(
+ const Position::Coord& aCoord,
+ nsROCSSPrimitiveValue* aValue)
+{
+ if (!aCoord.mHasPercent) {
+ MOZ_ASSERT(aCoord.mPercent == 0.0f,
+ "Shouldn't have mPercent!");
+ aValue->SetAppUnits(aCoord.mLength);
+ } else if (aCoord.mLength == 0) {
+ aValue->SetPercent(aCoord.mPercent);
+ } else {
+ SetValueToCalc(&aCoord, aValue);
+ }
+}
+
+void
+nsComputedDOMStyle::SetValueToPosition(
+ const Position& aPosition,
+ nsDOMCSSValueList* aValueList)
+{
+ RefPtr<nsROCSSPrimitiveValue> valX = new nsROCSSPrimitiveValue;
+ SetValueToPositionCoord(aPosition.mXPosition, valX);
+ aValueList->AppendCSSValue(valX.forget());
+
+ RefPtr<nsROCSSPrimitiveValue> valY = new nsROCSSPrimitiveValue;
+ SetValueToPositionCoord(aPosition.mYPosition, valY);
+ aValueList->AppendCSSValue(valY.forget());
+}
+
+
+void
+nsComputedDOMStyle::SetValueToURLValue(const css::URLValueData* aURL,
+ nsROCSSPrimitiveValue* aValue)
+{
+ if (aURL && aURL->IsLocalRef()) {
+ nsString fragment;
+ aURL->GetSourceString(fragment);
+ fragment.Insert(u"url(\"", 0);
+ fragment.Append(u"\")");
+ aValue->SetString(fragment);
+ } else {
+ nsCOMPtr<nsIURI> url;
+ if (aURL && (url = aURL->GetURI())) {
+ aValue->SetURI(url);
+ } else {
+ aValue->SetIdent(eCSSKeyword_none);
+ }
+ }
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundPosition()
+{
+ const nsStyleImageLayers& layers = StyleBackground()->mImage;
+ return DoGetImageLayerPosition(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundPositionX()
+{
+ const nsStyleImageLayers& layers = StyleBackground()->mImage;
+ return DoGetImageLayerPositionX(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundPositionY()
+{
+ const nsStyleImageLayers& layers = StyleBackground()->mImage;
+ return DoGetImageLayerPositionY(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundRepeat()
+{
+ const nsStyleImageLayers& layers = StyleBackground()->mImage;
+ return DoGetImageLayerRepeat(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBackgroundSize()
+{
+ const nsStyleImageLayers& layers = StyleBackground()->mImage;
+ return DoGetImageLayerSize(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridTemplateAreas()
+{
+ const css::GridTemplateAreasValue* areas =
+ StylePosition()->mGridTemplateAreas;
+ if (!areas) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ MOZ_ASSERT(!areas->mTemplates.IsEmpty(),
+ "Unexpected empty array in GridTemplateAreasValue");
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ for (uint32_t i = 0; i < areas->mTemplates.Length(); i++) {
+ nsAutoString str;
+ nsStyleUtil::AppendEscapedCSSString(areas->mTemplates[i], str);
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetString(str);
+ valueList->AppendCSSValue(val.forget());
+ }
+ return valueList.forget();
+}
+
+void
+nsComputedDOMStyle::AppendGridLineNames(nsString& aResult,
+ const nsTArray<nsString>& aLineNames)
+{
+ uint32_t numLines = aLineNames.Length();
+ if (numLines == 0) {
+ return;
+ }
+ for (uint32_t i = 0;;) {
+ nsStyleUtil::AppendEscapedCSSIdent(aLineNames[i], aResult);
+ if (++i == numLines) {
+ break;
+ }
+ aResult.Append(' ');
+ }
+}
+
+void
+nsComputedDOMStyle::AppendGridLineNames(nsDOMCSSValueList* aValueList,
+ const nsTArray<nsString>& aLineNames,
+ bool aSuppressEmptyList)
+{
+ if (aLineNames.IsEmpty() && aSuppressEmptyList) {
+ return;
+ }
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString lineNamesString;
+ lineNamesString.Assign('[');
+ AppendGridLineNames(lineNamesString, aLineNames);
+ lineNamesString.Append(']');
+ val->SetString(lineNamesString);
+ aValueList->AppendCSSValue(val.forget());
+}
+
+void
+nsComputedDOMStyle::AppendGridLineNames(nsDOMCSSValueList* aValueList,
+ const nsTArray<nsString>& aLineNames1,
+ const nsTArray<nsString>& aLineNames2)
+{
+ if (aLineNames1.IsEmpty() && aLineNames2.IsEmpty()) {
+ return;
+ }
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString lineNamesString;
+ lineNamesString.Assign('[');
+ if (!aLineNames1.IsEmpty()) {
+ AppendGridLineNames(lineNamesString, aLineNames1);
+ }
+ if (!aLineNames2.IsEmpty()) {
+ if (!aLineNames1.IsEmpty()) {
+ lineNamesString.Append(' ');
+ }
+ AppendGridLineNames(lineNamesString, aLineNames2);
+ }
+ lineNamesString.Append(']');
+ val->SetString(lineNamesString);
+ aValueList->AppendCSSValue(val.forget());
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetGridTrackSize(const nsStyleCoord& aMinValue,
+ const nsStyleCoord& aMaxValue)
+{
+ if (aMinValue.GetUnit() == eStyleUnit_None) {
+ // A fit-content() function.
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString argumentStr, fitContentStr;
+ fitContentStr.AppendLiteral("fit-content(");
+ MOZ_ASSERT(aMaxValue.IsCoordPercentCalcUnit(),
+ "unexpected unit for fit-content() argument value");
+ SetValueToCoord(val, aMaxValue, true);
+ val->GetCssText(argumentStr);
+ fitContentStr.Append(argumentStr);
+ fitContentStr.Append(char16_t(')'));
+ val->SetString(fitContentStr);
+ return val.forget();
+ }
+
+ if (aMinValue == aMaxValue) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, aMinValue, true,
+ nullptr, nsCSSProps::kGridTrackBreadthKTable);
+ return val.forget();
+ }
+
+ // minmax(auto, <flex>) is equivalent to (and is our internal representation
+ // of) <flex>, and both compute to <flex>
+ if (aMinValue.GetUnit() == eStyleUnit_Auto &&
+ aMaxValue.GetUnit() == eStyleUnit_FlexFraction) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, aMaxValue, true);
+ return val.forget();
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString argumentStr, minmaxStr;
+ minmaxStr.AppendLiteral("minmax(");
+
+ SetValueToCoord(val, aMinValue, true,
+ nullptr, nsCSSProps::kGridTrackBreadthKTable);
+ val->GetCssText(argumentStr);
+ minmaxStr.Append(argumentStr);
+
+ minmaxStr.AppendLiteral(", ");
+
+ SetValueToCoord(val, aMaxValue, true,
+ nullptr, nsCSSProps::kGridTrackBreadthKTable);
+ val->GetCssText(argumentStr);
+ minmaxStr.Append(argumentStr);
+
+ minmaxStr.Append(char16_t(')'));
+ val->SetString(minmaxStr);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetGridTemplateColumnsRows(
+ const nsStyleGridTemplate& aTrackList,
+ const ComputedGridTrackInfo* aTrackInfo)
+{
+ if (aTrackList.mIsSubgrid) {
+ // XXX TODO: add support for repeat(auto-fill) for 'subgrid' (bug 1234311)
+ NS_ASSERTION(aTrackList.mMinTrackSizingFunctions.IsEmpty() &&
+ aTrackList.mMaxTrackSizingFunctions.IsEmpty(),
+ "Unexpected sizing functions with subgrid");
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ RefPtr<nsROCSSPrimitiveValue> subgridKeyword = new nsROCSSPrimitiveValue;
+ subgridKeyword->SetIdent(eCSSKeyword_subgrid);
+ valueList->AppendCSSValue(subgridKeyword.forget());
+
+ for (uint32_t i = 0, len = aTrackList.mLineNameLists.Length(); ; ++i) {
+ if (MOZ_UNLIKELY(aTrackList.IsRepeatAutoIndex(i))) {
+ MOZ_ASSERT(aTrackList.mIsAutoFill, "subgrid can only have 'auto-fill'");
+ MOZ_ASSERT(aTrackList.mRepeatAutoLineNameListAfter.IsEmpty(),
+ "mRepeatAutoLineNameListAfter isn't used for subgrid");
+ RefPtr<nsROCSSPrimitiveValue> start = new nsROCSSPrimitiveValue;
+ start->SetString(NS_LITERAL_STRING("repeat(auto-fill,"));
+ valueList->AppendCSSValue(start.forget());
+ AppendGridLineNames(valueList, aTrackList.mRepeatAutoLineNameListBefore,
+ /*aSuppressEmptyList*/ false);
+ RefPtr<nsROCSSPrimitiveValue> end = new nsROCSSPrimitiveValue;
+ end->SetString(NS_LITERAL_STRING(")"));
+ valueList->AppendCSSValue(end.forget());
+ }
+ if (i == len) {
+ break;
+ }
+ AppendGridLineNames(valueList, aTrackList.mLineNameLists[i],
+ /*aSuppressEmptyList*/ false);
+ }
+ return valueList.forget();
+ }
+
+ uint32_t numSizes = aTrackList.mMinTrackSizingFunctions.Length();
+ MOZ_ASSERT(aTrackList.mMaxTrackSizingFunctions.Length() == numSizes,
+ "Different number of min and max track sizing functions");
+ if (aTrackInfo) {
+ DebugOnly<bool> isAutoFill =
+ aTrackList.HasRepeatAuto() && aTrackList.mIsAutoFill;
+ DebugOnly<bool> isAutoFit =
+ aTrackList.HasRepeatAuto() && !aTrackList.mIsAutoFill;
+ DebugOnly<uint32_t> numExplicitTracks = aTrackInfo->mNumExplicitTracks;
+ MOZ_ASSERT(numExplicitTracks == numSizes ||
+ (isAutoFill && numExplicitTracks >= numSizes) ||
+ (isAutoFit && numExplicitTracks + 1 >= numSizes),
+ "expected all explicit tracks (or possibly one less, if there's "
+ "an 'auto-fit' track, since that can collapse away)");
+ numSizes = aTrackInfo->mSizes.Length();
+ }
+
+ // An empty <track-list> without repeats is represented as "none" in syntax.
+ if (numSizes == 0 && !aTrackList.HasRepeatAuto()) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ if (aTrackInfo) {
+ // We've done layout on the grid and have resolved the sizes of its tracks,
+ // so we'll return those sizes here. The grid spec says we MAY use
+ // repeat(<positive-integer>, Npx) here for consecutive tracks with the same
+ // size, but that doesn't seem worth doing since even for repeat(auto-*)
+ // the resolved size might differ for the repeated tracks.
+ const nsTArray<nscoord>& trackSizes = aTrackInfo->mSizes;
+ const uint32_t numExplicitTracks = aTrackInfo->mNumExplicitTracks;
+ const uint32_t numLeadingImplicitTracks = aTrackInfo->mNumLeadingImplicitTracks;
+ MOZ_ASSERT(numSizes >= numLeadingImplicitTracks + numExplicitTracks);
+
+ // Add any leading implicit tracks.
+ for (uint32_t i = 0; i < numLeadingImplicitTracks; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(trackSizes[i]);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ // Then add any explicit tracks and removed auto-fit tracks.
+ if (numExplicitTracks || aTrackList.HasRepeatAuto()) {
+ int32_t endOfRepeat = 0; // first index after any repeat() tracks
+ int32_t offsetToLastRepeat = 0;
+ if (aTrackList.HasRepeatAuto()) {
+ // offsetToLastRepeat is -1 if all repeat(auto-fit) tracks are empty
+ offsetToLastRepeat = numExplicitTracks + 1 - aTrackList.mLineNameLists.Length();
+ endOfRepeat = aTrackList.mRepeatAutoIndex + offsetToLastRepeat + 1;
+ }
+
+ uint32_t repeatIndex = 0;
+ uint32_t numRepeatTracks = aTrackInfo->mRemovedRepeatTracks.Length();
+ enum LinePlacement { LinesPrecede, LinesFollow, LinesBetween };
+ auto AppendRemovedAutoFits = [this, aTrackInfo, &valueList, aTrackList,
+ &repeatIndex,
+ numRepeatTracks](LinePlacement aPlacement)
+ {
+ // Add in removed auto-fit tracks and lines here, if necessary
+ bool atLeastOneTrackReported = false;
+ while (repeatIndex < numRepeatTracks &&
+ aTrackInfo->mRemovedRepeatTracks[repeatIndex]) {
+ if ((aPlacement == LinesPrecede) ||
+ ((aPlacement == LinesBetween) && atLeastOneTrackReported)) {
+ // Precede it with the lines between repeats.
+ AppendGridLineNames(valueList,
+ aTrackList.mRepeatAutoLineNameListAfter,
+ aTrackList.mRepeatAutoLineNameListBefore);
+ }
+
+ // Removed 'auto-fit' tracks are reported as 0px.
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(0);
+ valueList->AppendCSSValue(val.forget());
+ atLeastOneTrackReported = true;
+
+ if (aPlacement == LinesFollow) {
+ // Follow it with the lines between repeats.
+ AppendGridLineNames(valueList,
+ aTrackList.mRepeatAutoLineNameListAfter,
+ aTrackList.mRepeatAutoLineNameListBefore);
+ }
+ repeatIndex++;
+ }
+ repeatIndex++;
+ };
+
+ for (int32_t i = 0;; i++) {
+ if (aTrackList.HasRepeatAuto()) {
+ if (i == aTrackList.mRepeatAutoIndex) {
+ const nsTArray<nsString>& lineNames = aTrackList.mLineNameLists[i];
+ if (i == endOfRepeat) {
+ // All auto-fit tracks are empty, but we report them anyway.
+ AppendGridLineNames(valueList, lineNames,
+ aTrackList.mRepeatAutoLineNameListBefore);
+
+ AppendRemovedAutoFits(LinesBetween);
+
+ AppendGridLineNames(valueList,
+ aTrackList.mRepeatAutoLineNameListAfter,
+ aTrackList.mLineNameLists[i + 1]);
+ } else {
+ AppendGridLineNames(valueList, lineNames,
+ aTrackList.mRepeatAutoLineNameListBefore);
+ AppendRemovedAutoFits(LinesFollow);
+ }
+ } else if (i == endOfRepeat) {
+ // Before appending the last line, finish off any removed auto-fits.
+ AppendRemovedAutoFits(LinesPrecede);
+
+ const nsTArray<nsString>& lineNames =
+ aTrackList.mLineNameLists[aTrackList.mRepeatAutoIndex + 1];
+ AppendGridLineNames(valueList,
+ aTrackList.mRepeatAutoLineNameListAfter,
+ lineNames);
+ } else if (i > aTrackList.mRepeatAutoIndex && i < endOfRepeat) {
+ AppendGridLineNames(valueList,
+ aTrackList.mRepeatAutoLineNameListAfter,
+ aTrackList.mRepeatAutoLineNameListBefore);
+ AppendRemovedAutoFits(LinesFollow);
+ } else {
+ uint32_t j = i > endOfRepeat ? i - offsetToLastRepeat : i;
+ const nsTArray<nsString>& lineNames = aTrackList.mLineNameLists[j];
+ AppendGridLineNames(valueList, lineNames);
+ }
+ } else {
+ const nsTArray<nsString>& lineNames = aTrackList.mLineNameLists[i];
+ AppendGridLineNames(valueList, lineNames);
+ }
+ if (uint32_t(i) == numExplicitTracks) {
+ break;
+ }
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(trackSizes[i + numLeadingImplicitTracks]);
+ valueList->AppendCSSValue(val.forget());
+ }
+ }
+
+ // Add any trailing implicit tracks.
+ for (uint32_t i = numLeadingImplicitTracks + numExplicitTracks;
+ i < numSizes; ++i) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(trackSizes[i]);
+ valueList->AppendCSSValue(val.forget());
+ }
+ } else {
+ // We don't have a frame. So, we'll just return a serialization of
+ // the tracks from the style (without resolved sizes).
+ for (uint32_t i = 0;; i++) {
+ const nsTArray<nsString>& lineNames = aTrackList.mLineNameLists[i];
+ if (!lineNames.IsEmpty()) {
+ AppendGridLineNames(valueList, lineNames);
+ }
+ if (i == numSizes) {
+ break;
+ }
+ if (MOZ_UNLIKELY(aTrackList.IsRepeatAutoIndex(i))) {
+ RefPtr<nsROCSSPrimitiveValue> start = new nsROCSSPrimitiveValue;
+ start->SetString(aTrackList.mIsAutoFill ? NS_LITERAL_STRING("repeat(auto-fill,")
+ : NS_LITERAL_STRING("repeat(auto-fit,"));
+ valueList->AppendCSSValue(start.forget());
+ if (!aTrackList.mRepeatAutoLineNameListBefore.IsEmpty()) {
+ AppendGridLineNames(valueList, aTrackList.mRepeatAutoLineNameListBefore);
+ }
+
+ valueList->AppendCSSValue(
+ GetGridTrackSize(aTrackList.mMinTrackSizingFunctions[i],
+ aTrackList.mMaxTrackSizingFunctions[i]));
+ if (!aTrackList.mRepeatAutoLineNameListAfter.IsEmpty()) {
+ AppendGridLineNames(valueList, aTrackList.mRepeatAutoLineNameListAfter);
+ }
+ RefPtr<nsROCSSPrimitiveValue> end = new nsROCSSPrimitiveValue;
+ end->SetString(NS_LITERAL_STRING(")"));
+ valueList->AppendCSSValue(end.forget());
+ } else {
+ valueList->AppendCSSValue(
+ GetGridTrackSize(aTrackList.mMinTrackSizingFunctions[i],
+ aTrackList.mMaxTrackSizingFunctions[i]));
+ }
+ }
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridAutoFlow()
+{
+ nsAutoString str;
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_grid_auto_flow,
+ StylePosition()->mGridAutoFlow,
+ NS_STYLE_GRID_AUTO_FLOW_ROW,
+ NS_STYLE_GRID_AUTO_FLOW_DENSE,
+ str);
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridAutoColumns()
+{
+ return GetGridTrackSize(StylePosition()->mGridAutoColumnsMin,
+ StylePosition()->mGridAutoColumnsMax);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridAutoRows()
+{
+ return GetGridTrackSize(StylePosition()->mGridAutoRowsMin,
+ StylePosition()->mGridAutoRowsMax);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridTemplateColumns()
+{
+ const ComputedGridTrackInfo* info = nullptr;
+
+ nsGridContainerFrame* gridFrame =
+ nsGridContainerFrame::GetGridFrameWithComputedInfo(
+ mContent->GetPrimaryFrame());
+
+ if (gridFrame) {
+ info = gridFrame->GetComputedTemplateColumns();
+ }
+
+ return GetGridTemplateColumnsRows(StylePosition()->mGridTemplateColumns, info);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridTemplateRows()
+{
+ const ComputedGridTrackInfo* info = nullptr;
+
+ nsGridContainerFrame* gridFrame =
+ nsGridContainerFrame::GetGridFrameWithComputedInfo(
+ mContent->GetPrimaryFrame());
+
+ if (gridFrame) {
+ info = gridFrame->GetComputedTemplateRows();
+ }
+
+ return GetGridTemplateColumnsRows(StylePosition()->mGridTemplateRows, info);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetGridLine(const nsStyleGridLine& aGridLine)
+{
+ if (aGridLine.IsAuto()) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_auto);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ if (aGridLine.mHasSpan) {
+ RefPtr<nsROCSSPrimitiveValue> span = new nsROCSSPrimitiveValue;
+ span->SetIdent(eCSSKeyword_span);
+ valueList->AppendCSSValue(span.forget());
+ }
+
+ if (aGridLine.mInteger != 0) {
+ RefPtr<nsROCSSPrimitiveValue> integer = new nsROCSSPrimitiveValue;
+ integer->SetNumber(aGridLine.mInteger);
+ valueList->AppendCSSValue(integer.forget());
+ }
+
+ if (!aGridLine.mLineName.IsEmpty()) {
+ RefPtr<nsROCSSPrimitiveValue> lineName = new nsROCSSPrimitiveValue;
+ nsString escapedLineName;
+ nsStyleUtil::AppendEscapedCSSIdent(aGridLine.mLineName, escapedLineName);
+ lineName->SetString(escapedLineName);
+ valueList->AppendCSSValue(lineName.forget());
+ }
+
+ NS_ASSERTION(valueList->Length() > 0,
+ "Should have appended at least one value");
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridColumnStart()
+{
+ return GetGridLine(StylePosition()->mGridColumnStart);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridColumnEnd()
+{
+ return GetGridLine(StylePosition()->mGridColumnEnd);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridRowStart()
+{
+ return GetGridLine(StylePosition()->mGridRowStart);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridRowEnd()
+{
+ return GetGridLine(StylePosition()->mGridRowEnd);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridColumnGap()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StylePosition()->mGridColumnGap, true);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetGridRowGap()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StylePosition()->mGridRowGap, true);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPaddingTop()
+{
+ return GetPaddingWidthFor(NS_SIDE_TOP);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPaddingBottom()
+{
+ return GetPaddingWidthFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPaddingLeft()
+{
+ return GetPaddingWidthFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPaddingRight()
+{
+ return GetPaddingWidthFor(NS_SIDE_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderCollapse()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleTableBorder()->mBorderCollapse,
+ nsCSSProps::kBorderCollapseKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderSpacing()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ RefPtr<nsROCSSPrimitiveValue> xSpacing = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> ySpacing = new nsROCSSPrimitiveValue;
+
+ const nsStyleTableBorder *border = StyleTableBorder();
+ xSpacing->SetAppUnits(border->mBorderSpacingCol);
+ ySpacing->SetAppUnits(border->mBorderSpacingRow);
+
+ valueList->AppendCSSValue(xSpacing.forget());
+ valueList->AppendCSSValue(ySpacing.forget());
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetCaptionSide()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleTableBorder()->mCaptionSide,
+ nsCSSProps::kCaptionSideKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetEmptyCells()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleTableBorder()->mEmptyCells,
+ nsCSSProps::kEmptyCellsKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTableLayout()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleTable()->mLayoutStrategy,
+ nsCSSProps::kTableLayoutKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderTopStyle()
+{
+ return GetBorderStyleFor(NS_SIDE_TOP);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderBottomStyle()
+{
+ return GetBorderStyleFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderLeftStyle()
+{
+ return GetBorderStyleFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderRightStyle()
+{
+ return GetBorderStyleFor(NS_SIDE_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderBottomColors()
+{
+ return GetBorderColorsFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderLeftColors()
+{
+ return GetBorderColorsFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderRightColors()
+{
+ return GetBorderColorsFor(NS_SIDE_RIGHT);
+}
+
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderTopColors()
+{
+ return GetBorderColorsFor(NS_SIDE_TOP);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderBottomLeftRadius()
+{
+ return GetEllipseRadii(StyleBorder()->mBorderRadius,
+ NS_CORNER_BOTTOM_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderBottomRightRadius()
+{
+ return GetEllipseRadii(StyleBorder()->mBorderRadius,
+ NS_CORNER_BOTTOM_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderTopLeftRadius()
+{
+ return GetEllipseRadii(StyleBorder()->mBorderRadius,
+ NS_CORNER_TOP_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderTopRightRadius()
+{
+ return GetEllipseRadii(StyleBorder()->mBorderRadius,
+ NS_CORNER_TOP_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderTopWidth()
+{
+ return GetBorderWidthFor(NS_SIDE_TOP);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderBottomWidth()
+{
+ return GetBorderWidthFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderLeftWidth()
+{
+ return GetBorderWidthFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderRightWidth()
+{
+ return GetBorderWidthFor(NS_SIDE_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderTopColor()
+{
+ return GetBorderColorFor(NS_SIDE_TOP);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderBottomColor()
+{
+ return GetBorderColorFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderLeftColor()
+{
+ return GetBorderColorFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderRightColor()
+{
+ return GetBorderColorFor(NS_SIDE_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarginTopWidth()
+{
+ return GetMarginWidthFor(NS_SIDE_TOP);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarginBottomWidth()
+{
+ return GetMarginWidthFor(NS_SIDE_BOTTOM);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarginLeftWidth()
+{
+ return GetMarginWidthFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarginRightWidth()
+{
+ return GetMarginWidthFor(NS_SIDE_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOrient()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mOrient,
+ nsCSSProps::kOrientKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollBehavior()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mScrollBehavior,
+ nsCSSProps::kScrollBehaviorKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapType()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+ if (display->mScrollSnapTypeX != display->mScrollSnapTypeY) {
+ // No value to return. We can't express this combination of
+ // values as a shorthand.
+ return nullptr;
+ }
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mScrollSnapTypeX,
+ nsCSSProps::kScrollSnapTypeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapTypeX()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mScrollSnapTypeX,
+ nsCSSProps::kScrollSnapTypeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapTypeY()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mScrollSnapTypeY,
+ nsCSSProps::kScrollSnapTypeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetScrollSnapPoints(const nsStyleCoord& aCoord)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ if (aCoord.GetUnit() == eStyleUnit_None) {
+ val->SetIdent(eCSSKeyword_none);
+ } else {
+ nsAutoString argumentString;
+ SetCssTextToCoord(argumentString, aCoord);
+ nsAutoString tmp;
+ tmp.AppendLiteral("repeat(");
+ tmp.Append(argumentString);
+ tmp.Append(')');
+ val->SetString(tmp);
+ }
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapPointsX()
+{
+ return GetScrollSnapPoints(StyleDisplay()->mScrollSnapPointsX);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapPointsY()
+{
+ return GetScrollSnapPoints(StyleDisplay()->mScrollSnapPointsY);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapDestination()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ SetValueToPosition(StyleDisplay()->mScrollSnapDestination, valueList);
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetScrollSnapCoordinate()
+{
+ const nsStyleDisplay* sd = StyleDisplay();
+ if (sd->mScrollSnapCoordinate.IsEmpty()) {
+ // Having no snap coordinates is interpreted as "none"
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ } else {
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+ for (size_t i = 0, i_end = sd->mScrollSnapCoordinate.Length(); i < i_end; ++i) {
+ RefPtr<nsDOMCSSValueList> itemList = GetROCSSValueList(false);
+ SetValueToPosition(sd->mScrollSnapCoordinate[i], itemList);
+ valueList->AppendCSSValue(itemList.forget());
+ }
+ return valueList.forget();
+ }
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleOutline* outline = StyleOutline();
+
+ nscoord width;
+ if (outline->mOutlineStyle == NS_STYLE_BORDER_STYLE_NONE) {
+ NS_ASSERTION(outline->GetOutlineWidth() == 0, "unexpected width");
+ width = 0;
+ } else {
+ width = outline->GetOutlineWidth();
+ }
+ val->SetAppUnits(width);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineStyle()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleOutline()->mOutlineStyle,
+ nsCSSProps::kOutlineStyleKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineOffset()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(StyleOutline()->mOutlineOffset);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineRadiusBottomLeft()
+{
+ return GetEllipseRadii(StyleOutline()->mOutlineRadius,
+ NS_CORNER_BOTTOM_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineRadiusBottomRight()
+{
+ return GetEllipseRadii(StyleOutline()->mOutlineRadius,
+ NS_CORNER_BOTTOM_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineRadiusTopLeft()
+{
+ return GetEllipseRadii(StyleOutline()->mOutlineRadius,
+ NS_CORNER_TOP_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineRadiusTopRight()
+{
+ return GetEllipseRadii(StyleOutline()->mOutlineRadius,
+ NS_CORNER_TOP_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOutlineColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleOutline()->mOutlineColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetEllipseRadii(const nsStyleCorners& aRadius,
+ uint8_t aFullCorner)
+{
+ nsStyleCoord radiusX = aRadius.Get(NS_FULL_TO_HALF_CORNER(aFullCorner, false));
+ nsStyleCoord radiusY = aRadius.Get(NS_FULL_TO_HALF_CORNER(aFullCorner, true));
+
+ // for compatibility, return a single value if X and Y are equal
+ if (radiusX == radiusY) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, radiusX, true);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ RefPtr<nsROCSSPrimitiveValue> valX = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> valY = new nsROCSSPrimitiveValue;
+
+ SetValueToCoord(valX, radiusX, true);
+ SetValueToCoord(valY, radiusY, true);
+
+ valueList->AppendCSSValue(valX.forget());
+ valueList->AppendCSSValue(valY.forget());
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetCSSShadowArray(nsCSSShadowArray* aArray,
+ const nscolor& aDefaultColor,
+ bool aIsBoxShadow)
+{
+ if (!aArray) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ static nscoord nsCSSShadowItem::* const shadowValuesNoSpread[] = {
+ &nsCSSShadowItem::mXOffset,
+ &nsCSSShadowItem::mYOffset,
+ &nsCSSShadowItem::mRadius
+ };
+
+ static nscoord nsCSSShadowItem::* const shadowValuesWithSpread[] = {
+ &nsCSSShadowItem::mXOffset,
+ &nsCSSShadowItem::mYOffset,
+ &nsCSSShadowItem::mRadius,
+ &nsCSSShadowItem::mSpread
+ };
+
+ nscoord nsCSSShadowItem::* const * shadowValues;
+ uint32_t shadowValuesLength;
+ if (aIsBoxShadow) {
+ shadowValues = shadowValuesWithSpread;
+ shadowValuesLength = ArrayLength(shadowValuesWithSpread);
+ } else {
+ shadowValues = shadowValuesNoSpread;
+ shadowValuesLength = ArrayLength(shadowValuesNoSpread);
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ for (nsCSSShadowItem *item = aArray->ShadowAt(0),
+ *item_end = item + aArray->Length();
+ item < item_end; ++item) {
+ RefPtr<nsDOMCSSValueList> itemList = GetROCSSValueList(false);
+
+ // Color is either the specified shadow color or the foreground color
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nscolor shadowColor;
+ if (item->mHasColor) {
+ shadowColor = item->mColor;
+ } else {
+ shadowColor = aDefaultColor;
+ }
+ SetToRGBAColor(val, shadowColor);
+ itemList->AppendCSSValue(val.forget());
+
+ // Set the offsets, blur radius, and spread if available
+ for (uint32_t i = 0; i < shadowValuesLength; ++i) {
+ val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(item->*(shadowValues[i]));
+ itemList->AppendCSSValue(val.forget());
+ }
+
+ if (item->mInset && aIsBoxShadow) {
+ // This is an inset box-shadow
+ val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(
+ uint8_t(StyleBoxShadowType::Inset),
+ nsCSSProps::kBoxShadowTypeKTable));
+ itemList->AppendCSSValue(val.forget());
+ }
+ valueList->AppendCSSValue(itemList.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxDecorationBreak()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleBorder()->mBoxDecorationBreak,
+ nsCSSProps::kBoxDecorationBreakKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxShadow()
+{
+ return GetCSSShadowArray(StyleEffects()->mBoxShadow,
+ StyleColor()->mColor,
+ true);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetZIndex()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StylePosition()->mZIndex, false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetListStyleImage()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleList* list = StyleList();
+
+ // XXXheycam As in SetValueToStyleImage, we might want to use the
+ // URL stored in the nsStyleImageRequest's mImageValue if we
+ // failed to resolve the imgRequestProxy.
+
+ imgRequestProxy* image = list->GetListStyleImage();
+ if (!image) {
+ val->SetIdent(eCSSKeyword_none);
+ } else {
+ nsCOMPtr<nsIURI> uri;
+ image->GetURI(getter_AddRefs(uri));
+ val->SetURI(uri);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetListStylePosition()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleList()->mListStylePosition,
+ nsCSSProps::kListStylePositionKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetListStyleType()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ CounterStyle* style = StyleList()->GetCounterStyle();
+ AnonymousCounterStyle* anonymous = style->AsAnonymous();
+ nsAutoString tmp;
+ if (!anonymous) {
+ // want SetIdent
+ nsString type;
+ StyleList()->GetListStyleType(type);
+ nsStyleUtil::AppendEscapedCSSIdent(type, tmp);
+ } else if (anonymous->IsSingleString()) {
+ const nsTArray<nsString>& symbols = anonymous->GetSymbols();
+ MOZ_ASSERT(symbols.Length() == 1);
+ nsStyleUtil::AppendEscapedCSSString(symbols[0], tmp);
+ } else {
+ tmp.AppendLiteral("symbols(");
+
+ uint8_t system = anonymous->GetSystem();
+ NS_ASSERTION(system == NS_STYLE_COUNTER_SYSTEM_CYCLIC ||
+ system == NS_STYLE_COUNTER_SYSTEM_NUMERIC ||
+ system == NS_STYLE_COUNTER_SYSTEM_ALPHABETIC ||
+ system == NS_STYLE_COUNTER_SYSTEM_SYMBOLIC ||
+ system == NS_STYLE_COUNTER_SYSTEM_FIXED,
+ "Invalid system for anonymous counter style.");
+ if (system != NS_STYLE_COUNTER_SYSTEM_SYMBOLIC) {
+ AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(
+ system, nsCSSProps::kCounterSystemKTable), tmp);
+ tmp.Append(' ');
+ }
+
+ const nsTArray<nsString>& symbols = anonymous->GetSymbols();
+ NS_ASSERTION(symbols.Length() > 0,
+ "No symbols in the anonymous counter style");
+ for (size_t i = 0, iend = symbols.Length(); i < iend; i++) {
+ nsStyleUtil::AppendEscapedCSSString(symbols[i], tmp);
+ tmp.Append(' ');
+ }
+ tmp.Replace(tmp.Length() - 1, 1, char16_t(')'));
+ }
+ val->SetString(tmp);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageRegion()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleList* list = StyleList();
+
+ if (list->mImageRegion.width <= 0 || list->mImageRegion.height <= 0) {
+ val->SetIdent(eCSSKeyword_auto);
+ } else {
+ // create the cssvalues for the sides, stick them in the rect object
+ nsROCSSPrimitiveValue *topVal = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *rightVal = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *bottomVal = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *leftVal = new nsROCSSPrimitiveValue;
+ nsDOMCSSRect * domRect = new nsDOMCSSRect(topVal, rightVal,
+ bottomVal, leftVal);
+ topVal->SetAppUnits(list->mImageRegion.y);
+ rightVal->SetAppUnits(list->mImageRegion.width + list->mImageRegion.x);
+ bottomVal->SetAppUnits(list->mImageRegion.height + list->mImageRegion.y);
+ leftVal->SetAppUnits(list->mImageRegion.x);
+ val->SetRect(domRect);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetInitialLetter()
+{
+ const nsStyleTextReset* textReset = StyleTextReset();
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ if (textReset->mInitialLetterSink == 0) {
+ val->SetIdent(eCSSKeyword_normal);
+ return val.forget();
+ } else {
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ val->SetNumber(textReset->mInitialLetterSize);
+ valueList->AppendCSSValue(val.forget());
+ RefPtr<nsROCSSPrimitiveValue> second = new nsROCSSPrimitiveValue;
+ second->SetNumber(textReset->mInitialLetterSink);
+ valueList->AppendCSSValue(second.forget());
+ return valueList.forget();
+ }
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetLineHeight()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ nscoord lineHeight;
+ if (GetLineHeightCoord(lineHeight)) {
+ val->SetAppUnits(lineHeight);
+ } else {
+ SetValueToCoord(val, StyleText()->mLineHeight, true,
+ nullptr, nsCSSProps::kLineHeightKTable);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetRubyAlign()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(
+ StyleText()->mRubyAlign, nsCSSProps::kRubyAlignKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetRubyPosition()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(
+ StyleText()->mRubyPosition, nsCSSProps::kRubyPositionKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetVerticalAlign()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleDisplay()->mVerticalAlign, false,
+ nullptr, nsCSSProps::kVerticalAlignKTable);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::CreateTextAlignValue(uint8_t aAlign, bool aAlignTrue,
+ const KTableEntry aTable[])
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(aAlign, aTable));
+ if (!aAlignTrue) {
+ return val.forget();
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> first = new nsROCSSPrimitiveValue;
+ first->SetIdent(eCSSKeyword_unsafe);
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ valueList->AppendCSSValue(first.forget());
+ valueList->AppendCSSValue(val.forget());
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextAlign()
+{
+ const nsStyleText* style = StyleText();
+ return CreateTextAlignValue(style->mTextAlign, style->mTextAlignTrue,
+ nsCSSProps::kTextAlignKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextAlignLast()
+{
+ const nsStyleText* style = StyleText();
+ return CreateTextAlignValue(style->mTextAlignLast, style->mTextAlignLastTrue,
+ nsCSSProps::kTextAlignLastKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextCombineUpright()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ uint8_t tch = StyleText()->mTextCombineUpright;
+
+ if (tch <= NS_STYLE_TEXT_COMBINE_UPRIGHT_ALL) {
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(tch,
+ nsCSSProps::kTextCombineUprightKTable));
+ } else if (tch <= NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_2) {
+ val->SetString(NS_LITERAL_STRING("digits 2"));
+ } else if (tch <= NS_STYLE_TEXT_COMBINE_UPRIGHT_DIGITS_3) {
+ val->SetString(NS_LITERAL_STRING("digits 3"));
+ } else {
+ val->SetString(NS_LITERAL_STRING("digits 4"));
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextDecoration()
+{
+ const nsStyleTextReset* textReset = StyleTextReset();
+
+ bool isInitialStyle =
+ textReset->mTextDecorationStyle == NS_STYLE_TEXT_DECORATION_STYLE_SOLID;
+ StyleComplexColor color = textReset->mTextDecorationColor;
+
+ if (isInitialStyle && color.IsCurrentColor()) {
+ return DoGetTextDecorationLine();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ valueList->AppendCSSValue(DoGetTextDecorationLine());
+ if (!isInitialStyle) {
+ valueList->AppendCSSValue(DoGetTextDecorationStyle());
+ }
+ if (!color.IsCurrentColor()) {
+ valueList->AppendCSSValue(DoGetTextDecorationColor());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextDecorationColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleTextReset()->mTextDecorationColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextDecorationLine()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleTextReset()->mTextDecorationLine;
+
+ if (NS_STYLE_TEXT_DECORATION_LINE_NONE == intValue) {
+ val->SetIdent(eCSSKeyword_none);
+ } else {
+ nsAutoString decorationLineString;
+ // Clear the -moz-anchor-decoration bit and the OVERRIDE_ALL bits -- we
+ // don't want these to appear in the computed style.
+ intValue &= ~(NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS |
+ NS_STYLE_TEXT_DECORATION_LINE_OVERRIDE_ALL);
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_text_decoration_line,
+ intValue, NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE,
+ NS_STYLE_TEXT_DECORATION_LINE_BLINK, decorationLineString);
+ val->SetString(decorationLineString);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextDecorationStyle()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleTextReset()->mTextDecorationStyle,
+ nsCSSProps::kTextDecorationStyleKTable));
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextEmphasisColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleText()->mTextEmphasisColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextEmphasisPosition()
+{
+ auto position = StyleText()->mTextEmphasisPosition;
+
+ MOZ_ASSERT(!(position & NS_STYLE_TEXT_EMPHASIS_POSITION_OVER) !=
+ !(position & NS_STYLE_TEXT_EMPHASIS_POSITION_UNDER));
+ RefPtr<nsROCSSPrimitiveValue> first = new nsROCSSPrimitiveValue;
+ first->SetIdent((position & NS_STYLE_TEXT_EMPHASIS_POSITION_OVER) ?
+ eCSSKeyword_over : eCSSKeyword_under);
+
+ MOZ_ASSERT(!(position & NS_STYLE_TEXT_EMPHASIS_POSITION_LEFT) !=
+ !(position & NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT));
+ RefPtr<nsROCSSPrimitiveValue> second = new nsROCSSPrimitiveValue;
+ second->SetIdent((position & NS_STYLE_TEXT_EMPHASIS_POSITION_LEFT) ?
+ eCSSKeyword_left : eCSSKeyword_right);
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ valueList->AppendCSSValue(first.forget());
+ valueList->AppendCSSValue(second.forget());
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextEmphasisStyle()
+{
+ auto style = StyleText()->mTextEmphasisStyle;
+ if (style == NS_STYLE_TEXT_EMPHASIS_STYLE_NONE) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+ if (style == NS_STYLE_TEXT_EMPHASIS_STYLE_STRING) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString tmp;
+ nsStyleUtil::AppendEscapedCSSString(
+ StyleText()->mTextEmphasisStyleString, tmp);
+ val->SetString(tmp);
+ return val.forget();
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> fillVal = new nsROCSSPrimitiveValue;
+ if ((style & NS_STYLE_TEXT_EMPHASIS_STYLE_FILL_MASK) ==
+ NS_STYLE_TEXT_EMPHASIS_STYLE_FILLED) {
+ fillVal->SetIdent(eCSSKeyword_filled);
+ } else {
+ MOZ_ASSERT((style & NS_STYLE_TEXT_EMPHASIS_STYLE_FILL_MASK) ==
+ NS_STYLE_TEXT_EMPHASIS_STYLE_OPEN);
+ fillVal->SetIdent(eCSSKeyword_open);
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> shapeVal = new nsROCSSPrimitiveValue;
+ shapeVal->SetIdent(nsCSSProps::ValueToKeywordEnum(
+ style & NS_STYLE_TEXT_EMPHASIS_STYLE_SHAPE_MASK,
+ nsCSSProps::kTextEmphasisStyleShapeKTable));
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ valueList->AppendCSSValue(fillVal.forget());
+ valueList->AppendCSSValue(shapeVal.forget());
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextIndent()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleText()->mTextIndent, false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextOrientation()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleVisibility()->mTextOrientation,
+ nsCSSProps::kTextOrientationKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextOverflow()
+{
+ const nsStyleTextReset *style = StyleTextReset();
+ RefPtr<nsROCSSPrimitiveValue> first = new nsROCSSPrimitiveValue;
+ const nsStyleTextOverflowSide *side = style->mTextOverflow.GetFirstValue();
+ if (side->mType == NS_STYLE_TEXT_OVERFLOW_STRING) {
+ nsAutoString str;
+ nsStyleUtil::AppendEscapedCSSString(side->mString, str);
+ first->SetString(str);
+ } else {
+ first->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(side->mType,
+ nsCSSProps::kTextOverflowKTable));
+ }
+ side = style->mTextOverflow.GetSecondValue();
+ if (!side) {
+ return first.forget();
+ }
+ RefPtr<nsROCSSPrimitiveValue> second = new nsROCSSPrimitiveValue;
+ if (side->mType == NS_STYLE_TEXT_OVERFLOW_STRING) {
+ nsAutoString str;
+ nsStyleUtil::AppendEscapedCSSString(side->mString, str);
+ second->SetString(str);
+ } else {
+ second->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(side->mType,
+ nsCSSProps::kTextOverflowKTable));
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ valueList->AppendCSSValue(first.forget());
+ valueList->AppendCSSValue(second.forget());
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextShadow()
+{
+ return GetCSSShadowArray(StyleText()->mTextShadow,
+ StyleColor()->mColor,
+ false);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextTransform()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleText()->mTextTransform,
+ nsCSSProps::kTextTransformKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTabSize()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleText()->mTabSize);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetLetterSpacing()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleText()->mLetterSpacing, false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWordSpacing()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleText()->mWordSpacing, false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWhiteSpace()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleText()->mWhiteSpace,
+ nsCSSProps::kWhitespaceKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWindowDragging()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUIReset()->mWindowDragging,
+ nsCSSProps::kWindowDraggingKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWindowShadow()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUIReset()->mWindowShadow,
+ nsCSSProps::kWindowShadowKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWordBreak()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleText()->mWordBreak,
+ nsCSSProps::kWordBreakKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOverflowWrap()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleText()->mOverflowWrap,
+ nsCSSProps::kOverflowWrapKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetHyphens()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleText()->mHyphens,
+ nsCSSProps::kHyphensKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextSizeAdjust()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ switch (StyleText()->mTextSizeAdjust) {
+ default:
+ NS_NOTREACHED("unexpected value");
+ MOZ_FALLTHROUGH;
+ case NS_STYLE_TEXT_SIZE_ADJUST_AUTO:
+ val->SetIdent(eCSSKeyword_auto);
+ break;
+ case NS_STYLE_TEXT_SIZE_ADJUST_NONE:
+ val->SetIdent(eCSSKeyword_none);
+ break;
+ }
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWebkitTextFillColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleText()->mWebkitTextFillColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWebkitTextStrokeColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleText()->mWebkitTextStrokeColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWebkitTextStrokeWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(StyleText()->mWebkitTextStrokeWidth.GetCoordValue());
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPointerEvents()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUserInterface()->mPointerEvents,
+ nsCSSProps::kPointerEventsKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetVisibility()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleVisibility()->mVisible,
+ nsCSSProps::kVisibilityKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWritingMode()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleVisibility()->mWritingMode,
+ nsCSSProps::kWritingModeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetDirection()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleVisibility()->mDirection,
+ nsCSSProps::kDirectionKTable));
+ return val.forget();
+}
+
+static_assert(NS_STYLE_UNICODE_BIDI_NORMAL == 0,
+ "unicode-bidi style constants not as expected");
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetUnicodeBidi()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleTextReset()->mUnicodeBidi,
+ nsCSSProps::kUnicodeBidiKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetCursor()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ const nsStyleUserInterface *ui = StyleUserInterface();
+
+ for (const nsCursorImage& item : ui->mCursorImages) {
+ RefPtr<nsDOMCSSValueList> itemList = GetROCSSValueList(false);
+
+ nsCOMPtr<nsIURI> uri;
+ item.GetImage()->GetURI(getter_AddRefs(uri));
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetURI(uri);
+ itemList->AppendCSSValue(val.forget());
+
+ if (item.mHaveHotspot) {
+ RefPtr<nsROCSSPrimitiveValue> valX = new nsROCSSPrimitiveValue;
+ RefPtr<nsROCSSPrimitiveValue> valY = new nsROCSSPrimitiveValue;
+
+ valX->SetNumber(item.mHotspotX);
+ valY->SetNumber(item.mHotspotY);
+
+ itemList->AppendCSSValue(valX.forget());
+ itemList->AppendCSSValue(valY.forget());
+ }
+ valueList->AppendCSSValue(itemList.forget());
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(ui->mCursor,
+ nsCSSProps::kCursorKTable));
+ valueList->AppendCSSValue(val.forget());
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAppearance()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mAppearance,
+ nsCSSProps::kAppearanceKTable));
+ return val.forget();
+}
+
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxAlign()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleXUL()->mBoxAlign,
+ nsCSSProps::kBoxAlignKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxDirection()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleXUL()->mBoxDirection,
+ nsCSSProps::kBoxDirectionKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxFlex()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleXUL()->mBoxFlex);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxOrdinalGroup()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleXUL()->mBoxOrdinal);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxOrient()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleXUL()->mBoxOrient,
+ nsCSSProps::kBoxOrientKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxPack()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleXUL()->mBoxPack,
+ nsCSSProps::kBoxPackKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBoxSizing()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StylePosition()->mBoxSizing,
+ nsCSSProps::kBoxSizingKTable));
+ return val.forget();
+}
+
+/* Border image properties */
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderImageSource()
+{
+ const nsStyleBorder* border = StyleBorder();
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ const nsStyleImage& image = border->mBorderImageSource;
+ SetValueToStyleImage(image, val);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderImageSlice()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ const nsStyleBorder* border = StyleBorder();
+ // Four slice numbers.
+ NS_FOR_CSS_SIDES (side) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, border->mBorderImageSlice.Get(side), true, nullptr);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ // Fill keyword.
+ if (NS_STYLE_BORDER_IMAGE_SLICE_FILL == border->mBorderImageFill) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_fill);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderImageWidth()
+{
+ const nsStyleBorder* border = StyleBorder();
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ NS_FOR_CSS_SIDES (side) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, border->mBorderImageWidth.Get(side),
+ true, nullptr);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderImageOutset()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ const nsStyleBorder* border = StyleBorder();
+ // four slice numbers
+ NS_FOR_CSS_SIDES (side) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, border->mBorderImageOutset.Get(side),
+ true, nullptr);
+ valueList->AppendCSSValue(val.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetBorderImageRepeat()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ const nsStyleBorder* border = StyleBorder();
+
+ // horizontal repeat
+ RefPtr<nsROCSSPrimitiveValue> valX = new nsROCSSPrimitiveValue;
+ valX->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(border->mBorderImageRepeatH,
+ nsCSSProps::kBorderImageRepeatKTable));
+ valueList->AppendCSSValue(valX.forget());
+
+ // vertical repeat
+ RefPtr<nsROCSSPrimitiveValue> valY = new nsROCSSPrimitiveValue;
+ valY->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(border->mBorderImageRepeatV,
+ nsCSSProps::kBorderImageRepeatKTable));
+ valueList->AppendCSSValue(valY.forget());
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFlexBasis()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ // XXXdholbert We could make this more automagic and resolve percentages
+ // if we wanted, by passing in a PercentageBaseGetter instead of nullptr
+ // below. Logic would go like this:
+ // if (i'm a flex item) {
+ // if (my flex container is horizontal) {
+ // percentageBaseGetter = &nsComputedDOMStyle::GetCBContentWidth;
+ // } else {
+ // percentageBaseGetter = &nsComputedDOMStyle::GetCBContentHeight;
+ // }
+ // }
+
+ SetValueToCoord(val, StylePosition()->mFlexBasis, true,
+ nullptr, nsCSSProps::kWidthKTable);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFlexDirection()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StylePosition()->mFlexDirection,
+ nsCSSProps::kFlexDirectionKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFlexGrow()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StylePosition()->mFlexGrow);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFlexShrink()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StylePosition()->mFlexShrink);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFlexWrap()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StylePosition()->mFlexWrap,
+ nsCSSProps::kFlexWrapKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOrder()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StylePosition()->mOrder);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAlignContent()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString str;
+ auto align = StylePosition()->mAlignContent;
+ nsCSSValue::AppendAlignJustifyValueToString(align & NS_STYLE_ALIGN_ALL_BITS, str);
+ auto fallback = align >> NS_STYLE_ALIGN_ALL_SHIFT;
+ if (fallback) {
+ str.Append(' ');
+ nsCSSValue::AppendAlignJustifyValueToString(fallback, str);
+ }
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAlignItems()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString str;
+ auto align = StylePosition()->mAlignItems;
+ nsCSSValue::AppendAlignJustifyValueToString(align, str);
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAlignSelf()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString str;
+ auto align = StylePosition()->mAlignSelf;
+ nsCSSValue::AppendAlignJustifyValueToString(align, str);
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetJustifyContent()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString str;
+ auto justify = StylePosition()->mJustifyContent;
+ nsCSSValue::AppendAlignJustifyValueToString(justify & NS_STYLE_JUSTIFY_ALL_BITS, str);
+ auto fallback = justify >> NS_STYLE_JUSTIFY_ALL_SHIFT;
+ if (fallback) {
+ MOZ_ASSERT(nsCSSProps::ValueToKeywordEnum(fallback & ~NS_STYLE_JUSTIFY_FLAG_BITS,
+ nsCSSProps::kAlignSelfPosition)
+ != eCSSKeyword_UNKNOWN, "unknown fallback value");
+ str.Append(' ');
+ nsCSSValue::AppendAlignJustifyValueToString(fallback, str);
+ }
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetJustifyItems()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString str;
+ auto justify =
+ StylePosition()->ComputedJustifyItems(mStyleContext->GetParent());
+ nsCSSValue::AppendAlignJustifyValueToString(justify, str);
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetJustifySelf()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString str;
+ auto justify = StylePosition()->mJustifySelf;
+ nsCSSValue::AppendAlignJustifyValueToString(justify, str);
+ val->SetString(str);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFloatEdge()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(uint8_t(StyleBorder()->mFloatEdge),
+ nsCSSProps::kFloatEdgeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetForceBrokenImageIcon()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleUIReset()->mForceBrokenImageIcon);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageOrientation()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString string;
+ nsStyleImageOrientation orientation = StyleVisibility()->mImageOrientation;
+
+ if (orientation.IsFromImage()) {
+ string.AppendLiteral("from-image");
+ } else {
+ nsStyleUtil::AppendAngleValue(orientation.AngleAsCoord(), string);
+
+ if (orientation.IsFlipped()) {
+ string.AppendLiteral(" flip");
+ }
+ }
+
+ val->SetString(string);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetIMEMode()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUIReset()->mIMEMode,
+ nsCSSProps::kIMEModeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetUserFocus()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(uint8_t(StyleUserInterface()->mUserFocus),
+ nsCSSProps::kUserFocusKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetUserInput()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUserInterface()->mUserInput,
+ nsCSSProps::kUserInputKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetUserModify()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUserInterface()->mUserModify,
+ nsCSSProps::kUserModifyKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetUserSelect()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleUIReset()->mUserSelect,
+ nsCSSProps::kUserSelectKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetDisplay()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mDisplay,
+ nsCSSProps::kDisplayKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetContain()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t mask = StyleDisplay()->mContain;
+
+ if (mask == 0) {
+ val->SetIdent(eCSSKeyword_none);
+ } else if (mask & NS_STYLE_CONTAIN_STRICT) {
+ NS_ASSERTION(mask == (NS_STYLE_CONTAIN_STRICT | NS_STYLE_CONTAIN_ALL_BITS),
+ "contain: strict should imply contain: layout style paint");
+ val->SetIdent(eCSSKeyword_strict);
+ } else {
+ nsAutoString valueStr;
+
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_contain,
+ mask, NS_STYLE_CONTAIN_LAYOUT,
+ NS_STYLE_CONTAIN_PAINT, valueStr);
+ val->SetString(valueStr);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPosition()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mPosition,
+ nsCSSProps::kPositionKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetClip()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleEffects* effects = StyleEffects();
+
+ if (effects->mClipFlags == NS_STYLE_CLIP_AUTO) {
+ val->SetIdent(eCSSKeyword_auto);
+ } else {
+ // create the cssvalues for the sides, stick them in the rect object
+ nsROCSSPrimitiveValue *topVal = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *rightVal = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *bottomVal = new nsROCSSPrimitiveValue;
+ nsROCSSPrimitiveValue *leftVal = new nsROCSSPrimitiveValue;
+ nsDOMCSSRect * domRect = new nsDOMCSSRect(topVal, rightVal,
+ bottomVal, leftVal);
+ if (effects->mClipFlags & NS_STYLE_CLIP_TOP_AUTO) {
+ topVal->SetIdent(eCSSKeyword_auto);
+ } else {
+ topVal->SetAppUnits(effects->mClip.y);
+ }
+
+ if (effects->mClipFlags & NS_STYLE_CLIP_RIGHT_AUTO) {
+ rightVal->SetIdent(eCSSKeyword_auto);
+ } else {
+ rightVal->SetAppUnits(effects->mClip.width + effects->mClip.x);
+ }
+
+ if (effects->mClipFlags & NS_STYLE_CLIP_BOTTOM_AUTO) {
+ bottomVal->SetIdent(eCSSKeyword_auto);
+ } else {
+ bottomVal->SetAppUnits(effects->mClip.height + effects->mClip.y);
+ }
+
+ if (effects->mClipFlags & NS_STYLE_CLIP_LEFT_AUTO) {
+ leftVal->SetIdent(eCSSKeyword_auto);
+ } else {
+ leftVal->SetAppUnits(effects->mClip.x);
+ }
+ val->SetRect(domRect);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWillChange()
+{
+ const nsTArray<nsString>& willChange = StyleDisplay()->mWillChange;
+
+ if (willChange.IsEmpty()) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_auto);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+ for (size_t i = 0; i < willChange.Length(); i++) {
+ const nsString& willChangeIdentifier = willChange[i];
+ RefPtr<nsROCSSPrimitiveValue> property = new nsROCSSPrimitiveValue;
+ property->SetString(willChangeIdentifier);
+ valueList->AppendCSSValue(property.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOverflow()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ if (display->mOverflowX != display->mOverflowY) {
+ // No value to return. We can't express this combination of
+ // values as a shorthand.
+ return nullptr;
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(display->mOverflowX,
+ nsCSSProps::kOverflowKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOverflowX()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mOverflowX,
+ nsCSSProps::kOverflowSubKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOverflowY()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mOverflowY,
+ nsCSSProps::kOverflowSubKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetOverflowClipBox()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mOverflowClipBox,
+ nsCSSProps::kOverflowClipBoxKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetResize()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mResize,
+ nsCSSProps::kResizeKTable));
+ return val.forget();
+}
+
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPageBreakAfter()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleDisplay *display = StyleDisplay();
+
+ if (display->mBreakAfter) {
+ val->SetIdent(eCSSKeyword_always);
+ } else {
+ val->SetIdent(eCSSKeyword_auto);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPageBreakBefore()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleDisplay *display = StyleDisplay();
+
+ if (display->mBreakBefore) {
+ val->SetIdent(eCSSKeyword_always);
+ } else {
+ val->SetIdent(eCSSKeyword_auto);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPageBreakInside()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mBreakInside,
+ nsCSSProps::kPageBreakInsideKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTouchAction()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ int32_t intValue = StyleDisplay()->mTouchAction;
+
+ // None and Auto and Manipulation values aren't allowed
+ // to be in conjunction with other values.
+ // But there are all checks in CSSParserImpl::ParseTouchAction
+ nsAutoString valueStr;
+ nsStyleUtil::AppendBitmaskCSSValue(eCSSProperty_touch_action, intValue,
+ NS_STYLE_TOUCH_ACTION_NONE, NS_STYLE_TOUCH_ACTION_MANIPULATION,
+ valueStr);
+ val->SetString(valueStr);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetHeight()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ bool calcHeight = false;
+
+ if (mInnerFrame) {
+ calcHeight = true;
+
+ const nsStyleDisplay* displayData = StyleDisplay();
+ if (displayData->mDisplay == mozilla::StyleDisplay::Inline &&
+ !(mInnerFrame->IsFrameOfType(nsIFrame::eReplaced)) &&
+ // An outer SVG frame should behave the same as eReplaced in this case
+ mInnerFrame->GetType() != nsGkAtoms::svgOuterSVGFrame) {
+
+ calcHeight = false;
+ }
+ }
+
+ if (calcHeight) {
+ AssertFlushedPendingReflows();
+ nsMargin adjustedValues = GetAdjustedValuesForBoxSizing();
+ val->SetAppUnits(mInnerFrame->GetContentRect().height +
+ adjustedValues.TopBottom());
+ } else {
+ const nsStylePosition *positionData = StylePosition();
+
+ nscoord minHeight =
+ StyleCoordToNSCoord(positionData->mMinHeight,
+ &nsComputedDOMStyle::GetCBContentHeight, 0, true);
+
+ nscoord maxHeight =
+ StyleCoordToNSCoord(positionData->mMaxHeight,
+ &nsComputedDOMStyle::GetCBContentHeight,
+ nscoord_MAX, true);
+
+ SetValueToCoord(val, positionData->mHeight, true, nullptr,
+ nsCSSProps::kWidthKTable, minHeight, maxHeight);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ bool calcWidth = false;
+
+ if (mInnerFrame) {
+ calcWidth = true;
+
+ const nsStyleDisplay *displayData = StyleDisplay();
+ if (displayData->mDisplay == mozilla::StyleDisplay::Inline &&
+ !(mInnerFrame->IsFrameOfType(nsIFrame::eReplaced)) &&
+ // An outer SVG frame should behave the same as eReplaced in this case
+ mInnerFrame->GetType() != nsGkAtoms::svgOuterSVGFrame) {
+
+ calcWidth = false;
+ }
+ }
+
+ if (calcWidth) {
+ AssertFlushedPendingReflows();
+ nsMargin adjustedValues = GetAdjustedValuesForBoxSizing();
+ val->SetAppUnits(mInnerFrame->GetContentRect().width +
+ adjustedValues.LeftRight());
+ } else {
+ const nsStylePosition *positionData = StylePosition();
+
+ nscoord minWidth =
+ StyleCoordToNSCoord(positionData->mMinWidth,
+ &nsComputedDOMStyle::GetCBContentWidth, 0, true);
+
+ nscoord maxWidth =
+ StyleCoordToNSCoord(positionData->mMaxWidth,
+ &nsComputedDOMStyle::GetCBContentWidth,
+ nscoord_MAX, true);
+
+ SetValueToCoord(val, positionData->mWidth, true, nullptr,
+ nsCSSProps::kWidthKTable, minWidth, maxWidth);
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaxHeight()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StylePosition()->mMaxHeight, true,
+ nullptr, nsCSSProps::kWidthKTable);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaxWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StylePosition()->mMaxWidth, true,
+ nullptr, nsCSSProps::kWidthKTable);
+ return val.forget();
+}
+
+bool
+nsComputedDOMStyle::ShouldHonorMinSizeAutoInAxis(PhysicalAxis aAxis)
+{
+ // A {flex,grid} item's min-{width|height} "auto" value gets special
+ // treatment in getComputedStyle().
+ // https://drafts.csswg.org/css-flexbox-1/#valdef-min-width-auto
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ // In most cases, "min-{width|height}: auto" is mapped to "0px", unless
+ // we're a flex item (and the min-size is in the flex container's main
+ // axis), or we're a grid item, AND we also have overflow:visible.
+
+ // Note: We only need to bother checking one "overflow" subproperty for
+ // "visible", because a non-"visible" value in either axis would force the
+ // other axis to also be non-"visible" as well.
+
+ if (mOuterFrame) {
+ nsIFrame* containerFrame = mOuterFrame->GetParent();
+ if (containerFrame &&
+ StyleDisplay()->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE) {
+ auto containerType = containerFrame->GetType();
+ if (containerType == nsGkAtoms::flexContainerFrame &&
+ (static_cast<nsFlexContainerFrame*>(containerFrame)->IsHorizontal() ==
+ (aAxis == eAxisHorizontal))) {
+ return true;
+ }
+ if (containerType == nsGkAtoms::gridContainerFrame) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMinHeight()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsStyleCoord minHeight = StylePosition()->mMinHeight;
+
+ if (eStyleUnit_Auto == minHeight.GetUnit() &&
+ !ShouldHonorMinSizeAutoInAxis(eAxisVertical)) {
+ minHeight.SetCoordValue(0);
+ }
+
+ SetValueToCoord(val, minHeight, true, nullptr, nsCSSProps::kWidthKTable);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMinWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ nsStyleCoord minWidth = StylePosition()->mMinWidth;
+
+ if (eStyleUnit_Auto == minWidth.GetUnit() &&
+ !ShouldHonorMinSizeAutoInAxis(eAxisHorizontal)) {
+ minWidth.SetCoordValue(0);
+ }
+
+ SetValueToCoord(val, minWidth, true, nullptr, nsCSSProps::kWidthKTable);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMixBlendMode()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleEffects()->mMixBlendMode,
+ nsCSSProps::kBlendModeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetIsolation()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleDisplay()->mIsolation,
+ nsCSSProps::kIsolationKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetObjectFit()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StylePosition()->mObjectFit,
+ nsCSSProps::kObjectFitKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetObjectPosition()
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ SetValueToPosition(StylePosition()->mObjectPosition, valueList);
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetLeft()
+{
+ return GetOffsetWidthFor(NS_SIDE_LEFT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetRight()
+{
+ return GetOffsetWidthFor(NS_SIDE_RIGHT);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTop()
+{
+ return GetOffsetWidthFor(NS_SIDE_TOP);
+}
+
+nsDOMCSSValueList*
+nsComputedDOMStyle::GetROCSSValueList(bool aCommaDelimited)
+{
+ return new nsDOMCSSValueList(aCommaDelimited, true);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetOffsetWidthFor(mozilla::css::Side aSide)
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ AssertFlushedPendingReflows();
+
+ uint8_t position = display->mPosition;
+ if (!mOuterFrame) {
+ // GetRelativeOffset and GetAbsoluteOffset don't handle elements
+ // without frames in any sensible way. GetStaticOffset, however,
+ // is perfect for that case.
+ position = NS_STYLE_POSITION_STATIC;
+ }
+
+ switch (position) {
+ case NS_STYLE_POSITION_STATIC:
+ return GetStaticOffset(aSide);
+ case NS_STYLE_POSITION_RELATIVE:
+ return GetRelativeOffset(aSide);
+ case NS_STYLE_POSITION_STICKY:
+ return GetStickyOffset(aSide);
+ case NS_STYLE_POSITION_ABSOLUTE:
+ case NS_STYLE_POSITION_FIXED:
+ return GetAbsoluteOffset(aSide);
+ default:
+ NS_ERROR("Invalid position");
+ return nullptr;
+ }
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetAbsoluteOffset(mozilla::css::Side aSide)
+{
+ MOZ_ASSERT(mOuterFrame, "need a frame, so we can call GetContainingBlock()");
+
+ nsIFrame* container = mOuterFrame->GetContainingBlock();
+ nsMargin margin = mOuterFrame->GetUsedMargin();
+ nsMargin border = container->GetUsedBorder();
+ nsMargin scrollbarSizes(0, 0, 0, 0);
+ nsRect rect = mOuterFrame->GetRect();
+ nsRect containerRect = container->GetRect();
+
+ if (container->GetType() == nsGkAtoms::viewportFrame) {
+ // For absolutely positioned frames scrollbars are taken into
+ // account by virtue of getting a containing block that does
+ // _not_ include the scrollbars. For fixed positioned frames,
+ // the containing block is the viewport, which _does_ include
+ // scrollbars. We have to do some extra work.
+ // the first child in the default frame list is what we want
+ nsIFrame* scrollingChild = container->PrincipalChildList().FirstChild();
+ nsIScrollableFrame *scrollFrame = do_QueryFrame(scrollingChild);
+ if (scrollFrame) {
+ scrollbarSizes = scrollFrame->GetActualScrollbarSizes();
+ }
+ }
+
+ nscoord offset = 0;
+ switch (aSide) {
+ case NS_SIDE_TOP:
+ offset = rect.y - margin.top - border.top - scrollbarSizes.top;
+
+ break;
+ case NS_SIDE_RIGHT:
+ offset = containerRect.width - rect.width -
+ rect.x - margin.right - border.right - scrollbarSizes.right;
+
+ break;
+ case NS_SIDE_BOTTOM:
+ offset = containerRect.height - rect.height -
+ rect.y - margin.bottom - border.bottom - scrollbarSizes.bottom;
+
+ break;
+ case NS_SIDE_LEFT:
+ offset = rect.x - margin.left - border.left - scrollbarSizes.left;
+
+ break;
+ default:
+ NS_ERROR("Invalid side");
+ break;
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetAppUnits(offset);
+ return val.forget();
+}
+
+static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
+ NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
+ "box side constants not as expected for NS_OPPOSITE_SIDE");
+#define NS_OPPOSITE_SIDE(s_) mozilla::css::Side(((s_) + 2) & 3)
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetRelativeOffset(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStylePosition* positionData = StylePosition();
+ int32_t sign = 1;
+ nsStyleCoord coord = positionData->mOffset.Get(aSide);
+
+ NS_ASSERTION(coord.GetUnit() == eStyleUnit_Coord ||
+ coord.GetUnit() == eStyleUnit_Percent ||
+ coord.GetUnit() == eStyleUnit_Auto ||
+ coord.IsCalcUnit(),
+ "Unexpected unit");
+
+ if (coord.GetUnit() == eStyleUnit_Auto) {
+ coord = positionData->mOffset.Get(NS_OPPOSITE_SIDE(aSide));
+ sign = -1;
+ }
+ PercentageBaseGetter baseGetter;
+ if (aSide == NS_SIDE_LEFT || aSide == NS_SIDE_RIGHT) {
+ baseGetter = &nsComputedDOMStyle::GetCBContentWidth;
+ } else {
+ baseGetter = &nsComputedDOMStyle::GetCBContentHeight;
+ }
+
+ val->SetAppUnits(sign * StyleCoordToNSCoord(coord, baseGetter, 0, false));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetStickyOffset(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStylePosition* positionData = StylePosition();
+ nsStyleCoord coord = positionData->mOffset.Get(aSide);
+
+ NS_ASSERTION(coord.GetUnit() == eStyleUnit_Coord ||
+ coord.GetUnit() == eStyleUnit_Percent ||
+ coord.GetUnit() == eStyleUnit_Auto ||
+ coord.IsCalcUnit(),
+ "Unexpected unit");
+
+ if (coord.GetUnit() == eStyleUnit_Auto) {
+ val->SetIdent(eCSSKeyword_auto);
+ return val.forget();
+ }
+ PercentageBaseGetter baseGetter;
+ if (aSide == NS_SIDE_LEFT || aSide == NS_SIDE_RIGHT) {
+ baseGetter = &nsComputedDOMStyle::GetScrollFrameContentWidth;
+ } else {
+ baseGetter = &nsComputedDOMStyle::GetScrollFrameContentHeight;
+ }
+
+ val->SetAppUnits(StyleCoordToNSCoord(coord, baseGetter, 0, false));
+ return val.forget();
+}
+
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetStaticOffset(mozilla::css::Side aSide)
+
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StylePosition()->mOffset.Get(aSide), false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetPaddingWidthFor(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ if (!mInnerFrame) {
+ SetValueToCoord(val, StylePadding()->mPadding.Get(aSide), true);
+ } else {
+ AssertFlushedPendingReflows();
+
+ val->SetAppUnits(mInnerFrame->GetUsedPadding().Side(aSide));
+ }
+
+ return val.forget();
+}
+
+bool
+nsComputedDOMStyle::GetLineHeightCoord(nscoord& aCoord)
+{
+ AssertFlushedPendingReflows();
+
+ nscoord blockHeight = NS_AUTOHEIGHT;
+ if (StyleText()->mLineHeight.GetUnit() == eStyleUnit_Enumerated) {
+ if (!mInnerFrame)
+ return false;
+
+ if (nsLayoutUtils::IsNonWrapperBlock(mInnerFrame)) {
+ blockHeight = mInnerFrame->GetContentRect().height;
+ } else {
+ GetCBContentHeight(blockHeight);
+ }
+ }
+
+ // lie about font size inflation since we lie about font size (since
+ // the inflation only applies to text)
+ aCoord = ReflowInput::CalcLineHeight(mContent, mStyleContext,
+ blockHeight, 1.0f);
+
+ // CalcLineHeight uses font->mFont.size, but we want to use
+ // font->mSize as the font size. Adjust for that. Also adjust for
+ // the text zoom, if any.
+ const nsStyleFont* font = StyleFont();
+ float fCoord = float(aCoord);
+ if (font->mAllowZoom) {
+ fCoord /= mPresShell->GetPresContext()->TextZoom();
+ }
+ if (font->mFont.size != font->mSize) {
+ fCoord = fCoord * (float(font->mSize) / float(font->mFont.size));
+ }
+ aCoord = NSToCoordRound(fCoord);
+
+ return true;
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetBorderColorsFor(mozilla::css::Side aSide)
+{
+ const nsStyleBorder *border = StyleBorder();
+
+ if (border->mBorderColors) {
+ nsBorderColors* borderColors = border->mBorderColors[aSide];
+ if (borderColors) {
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+
+ do {
+ RefPtr<nsROCSSPrimitiveValue> primitive = new nsROCSSPrimitiveValue;
+
+ SetToRGBAColor(primitive, borderColors->mColor);
+
+ valueList->AppendCSSValue(primitive.forget());
+ borderColors = borderColors->mNext;
+ } while (borderColors);
+
+ return valueList.forget();
+ }
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetBorderWidthFor(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ nscoord width;
+ if (mInnerFrame) {
+ AssertFlushedPendingReflows();
+ width = mInnerFrame->GetUsedBorder().Side(aSide);
+ } else {
+ width = StyleBorder()->GetComputedBorderWidth(aSide);
+ }
+ val->SetAppUnits(width);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetBorderColorFor(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueFromComplexColor(val, StyleBorder()->mBorderColor[aSide]);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetMarginWidthFor(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ if (!mInnerFrame) {
+ SetValueToCoord(val, StyleMargin()->mMargin.Get(aSide), false);
+ } else {
+ AssertFlushedPendingReflows();
+
+ // For tables, GetUsedMargin always returns an empty margin, so we
+ // should read the margin from the table wrapper frame instead.
+ val->SetAppUnits(mOuterFrame->GetUsedMargin().Side(aSide));
+ NS_ASSERTION(mOuterFrame == mInnerFrame ||
+ mInnerFrame->GetUsedMargin() == nsMargin(0, 0, 0, 0),
+ "Inner tables must have zero margins");
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetBorderStyleFor(mozilla::css::Side aSide)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleBorder()->GetBorderStyle(aSide),
+ nsCSSProps::kBorderStyleKTable));
+ return val.forget();
+}
+
+void
+nsComputedDOMStyle::SetValueToCoord(nsROCSSPrimitiveValue* aValue,
+ const nsStyleCoord& aCoord,
+ bool aClampNegativeCalc,
+ PercentageBaseGetter aPercentageBaseGetter,
+ const KTableEntry aTable[],
+ nscoord aMinAppUnits,
+ nscoord aMaxAppUnits)
+{
+ NS_PRECONDITION(aValue, "Must have a value to work with");
+
+ switch (aCoord.GetUnit()) {
+ case eStyleUnit_Normal:
+ aValue->SetIdent(eCSSKeyword_normal);
+ break;
+
+ case eStyleUnit_Auto:
+ aValue->SetIdent(eCSSKeyword_auto);
+ break;
+
+ case eStyleUnit_Percent:
+ {
+ nscoord percentageBase;
+ if (aPercentageBaseGetter &&
+ (this->*aPercentageBaseGetter)(percentageBase)) {
+ nscoord val = NSCoordSaturatingMultiply(percentageBase,
+ aCoord.GetPercentValue());
+ aValue->SetAppUnits(std::max(aMinAppUnits, std::min(val, aMaxAppUnits)));
+ } else {
+ aValue->SetPercent(aCoord.GetPercentValue());
+ }
+ }
+ break;
+
+ case eStyleUnit_Factor:
+ aValue->SetNumber(aCoord.GetFactorValue());
+ break;
+
+ case eStyleUnit_Coord:
+ {
+ nscoord val = aCoord.GetCoordValue();
+ aValue->SetAppUnits(std::max(aMinAppUnits, std::min(val, aMaxAppUnits)));
+ }
+ break;
+
+ case eStyleUnit_Integer:
+ aValue->SetNumber(aCoord.GetIntValue());
+ break;
+
+ case eStyleUnit_Enumerated:
+ NS_ASSERTION(aTable, "Must have table to handle this case");
+ aValue->SetIdent(nsCSSProps::ValueToKeywordEnum(aCoord.GetIntValue(),
+ aTable));
+ break;
+
+ case eStyleUnit_None:
+ aValue->SetIdent(eCSSKeyword_none);
+ break;
+
+ case eStyleUnit_Calc:
+ nscoord percentageBase;
+ if (!aCoord.CalcHasPercent()) {
+ nscoord val = nsRuleNode::ComputeCoordPercentCalc(aCoord, 0);
+ if (aClampNegativeCalc && val < 0) {
+ MOZ_ASSERT(aCoord.IsCalcUnit(),
+ "parser should have rejected value");
+ val = 0;
+ }
+ aValue->SetAppUnits(std::max(aMinAppUnits, std::min(val, aMaxAppUnits)));
+ } else if (aPercentageBaseGetter &&
+ (this->*aPercentageBaseGetter)(percentageBase)) {
+ nscoord val =
+ nsRuleNode::ComputeCoordPercentCalc(aCoord, percentageBase);
+ if (aClampNegativeCalc && val < 0) {
+ MOZ_ASSERT(aCoord.IsCalcUnit(),
+ "parser should have rejected value");
+ val = 0;
+ }
+ aValue->SetAppUnits(std::max(aMinAppUnits, std::min(val, aMaxAppUnits)));
+ } else {
+ nsStyleCoord::Calc *calc = aCoord.GetCalcValue();
+ SetValueToCalc(calc, aValue);
+ }
+ break;
+
+ case eStyleUnit_Degree:
+ aValue->SetDegree(aCoord.GetAngleValue());
+ break;
+
+ case eStyleUnit_Grad:
+ aValue->SetGrad(aCoord.GetAngleValue());
+ break;
+
+ case eStyleUnit_Radian:
+ aValue->SetRadian(aCoord.GetAngleValue());
+ break;
+
+ case eStyleUnit_Turn:
+ aValue->SetTurn(aCoord.GetAngleValue());
+ break;
+
+ case eStyleUnit_FlexFraction: {
+ nsAutoString tmpStr;
+ nsStyleUtil::AppendCSSNumber(aCoord.GetFlexFractionValue(), tmpStr);
+ tmpStr.AppendLiteral("fr");
+ aValue->SetString(tmpStr);
+ break;
+ }
+
+ default:
+ NS_ERROR("Can't handle this unit");
+ break;
+ }
+}
+
+nscoord
+nsComputedDOMStyle::StyleCoordToNSCoord(const nsStyleCoord& aCoord,
+ PercentageBaseGetter aPercentageBaseGetter,
+ nscoord aDefaultValue,
+ bool aClampNegativeCalc)
+{
+ NS_PRECONDITION(aPercentageBaseGetter, "Must have a percentage base getter");
+ if (aCoord.GetUnit() == eStyleUnit_Coord) {
+ return aCoord.GetCoordValue();
+ }
+ if (aCoord.GetUnit() == eStyleUnit_Percent || aCoord.IsCalcUnit()) {
+ nscoord percentageBase;
+ if ((this->*aPercentageBaseGetter)(percentageBase)) {
+ nscoord result =
+ nsRuleNode::ComputeCoordPercentCalc(aCoord, percentageBase);
+ if (aClampNegativeCalc && result < 0) {
+ // It's expected that we can get a negative value here with calc().
+ // We can also get a negative value with a percentage value if
+ // percentageBase is negative; this isn't expected, but can happen
+ // when large length values overflow.
+ NS_WARNING_ASSERTION(
+ percentageBase >= 0,
+ "percentage base value overflowed to become negative for a property "
+ "that disallows negative values");
+ MOZ_ASSERT(aCoord.IsCalcUnit() ||
+ (aCoord.HasPercent() && percentageBase < 0),
+ "parser should have rejected value");
+ result = 0;
+ }
+ return result;
+ }
+ // Fall through to returning aDefaultValue if we have no percentage base.
+ }
+
+ return aDefaultValue;
+}
+
+bool
+nsComputedDOMStyle::GetCBContentWidth(nscoord& aWidth)
+{
+ if (!mOuterFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ nsIFrame* container = mOuterFrame->GetContainingBlock();
+ aWidth = container->GetContentRect().width;
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetCBContentHeight(nscoord& aHeight)
+{
+ if (!mOuterFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ nsIFrame* container = mOuterFrame->GetContainingBlock();
+ aHeight = container->GetContentRect().height;
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetScrollFrameContentWidth(nscoord& aWidth)
+{
+ if (!mOuterFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ nsIScrollableFrame* scrollableFrame =
+ nsLayoutUtils::GetNearestScrollableFrame(mOuterFrame->GetParent(),
+ nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+
+ if (!scrollableFrame) {
+ return false;
+ }
+ aWidth =
+ scrollableFrame->GetScrolledFrame()->GetContentRectRelativeToSelf().width;
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetScrollFrameContentHeight(nscoord& aHeight)
+{
+ if (!mOuterFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ nsIScrollableFrame* scrollableFrame =
+ nsLayoutUtils::GetNearestScrollableFrame(mOuterFrame->GetParent(),
+ nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+
+ if (!scrollableFrame) {
+ return false;
+ }
+ aHeight =
+ scrollableFrame->GetScrolledFrame()->GetContentRectRelativeToSelf().height;
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetFrameBorderRectWidth(nscoord& aWidth)
+{
+ if (!mInnerFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ aWidth = mInnerFrame->GetSize().width;
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetFrameBorderRectHeight(nscoord& aHeight)
+{
+ if (!mInnerFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ aHeight = mInnerFrame->GetSize().height;
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetFrameBoundsWidthForTransform(nscoord& aWidth)
+{
+ // We need a frame to work with.
+ if (!mInnerFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ aWidth = nsStyleTransformMatrix::TransformReferenceBox(mInnerFrame).Width();
+ return true;
+}
+
+bool
+nsComputedDOMStyle::GetFrameBoundsHeightForTransform(nscoord& aHeight)
+{
+ // We need a frame to work with.
+ if (!mInnerFrame) {
+ return false;
+ }
+
+ AssertFlushedPendingReflows();
+
+ aHeight = nsStyleTransformMatrix::TransformReferenceBox(mInnerFrame).Height();
+ return true;
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetSVGPaintFor(bool aFill)
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ const nsStyleSVG* svg = StyleSVG();
+ const nsStyleSVGPaint* paint = nullptr;
+
+ if (aFill)
+ paint = &svg->mFill;
+ else
+ paint = &svg->mStroke;
+
+ nsAutoString paintString;
+
+ switch (paint->Type()) {
+ case eStyleSVGPaintType_None:
+ val->SetIdent(eCSSKeyword_none);
+ break;
+ case eStyleSVGPaintType_Color:
+ SetToRGBAColor(val, paint->GetColor());
+ break;
+ case eStyleSVGPaintType_Server: {
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ RefPtr<nsROCSSPrimitiveValue> fallback = new nsROCSSPrimitiveValue;
+ SetValueToURLValue(paint->GetPaintServer(), val);
+ SetToRGBAColor(fallback, paint->GetFallbackColor());
+
+ valueList->AppendCSSValue(val.forget());
+ valueList->AppendCSSValue(fallback.forget());
+ return valueList.forget();
+ }
+ case eStyleSVGPaintType_ContextFill:
+ val->SetIdent(eCSSKeyword_context_fill);
+ // XXXheycam context-fill and context-stroke can have fallback colors,
+ // so they should be serialized here too
+ break;
+ case eStyleSVGPaintType_ContextStroke:
+ val->SetIdent(eCSSKeyword_context_stroke);
+ break;
+ }
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFill()
+{
+ return GetSVGPaintFor(true);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStroke()
+{
+ return GetSVGPaintFor(false);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarkerEnd()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToURLValue(StyleSVG()->mMarkerEnd, val);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarkerMid()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToURLValue(StyleSVG()->mMarkerMid, val);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMarkerStart()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToURLValue(StyleSVG()->mMarkerStart, val);
+
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeDasharray()
+{
+ const nsStyleSVG* svg = StyleSVG();
+
+ if (svg->mStrokeDasharray.IsEmpty()) {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ for (uint32_t i = 0; i < svg->mStrokeDasharray.Length(); i++) {
+ RefPtr<nsROCSSPrimitiveValue> dash = new nsROCSSPrimitiveValue;
+ SetValueToCoord(dash, svg->mStrokeDasharray[i], true);
+ valueList->AppendCSSValue(dash.forget());
+ }
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeDashoffset()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleSVG()->mStrokeDashoffset, false);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeWidth()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToCoord(val, StyleSVG()->mStrokeWidth, true);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetVectorEffect()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(StyleSVGReset()->mVectorEffect,
+ nsCSSProps::kVectorEffectKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFillOpacity()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleSVG()->mFillOpacity);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFloodOpacity()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleSVGReset()->mFloodOpacity);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStopOpacity()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleSVGReset()->mStopOpacity);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeMiterlimit()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleSVG()->mStrokeMiterlimit);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeOpacity()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetNumber(StyleSVG()->mStrokeOpacity);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetClipRule()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(
+ StyleSVG()->mClipRule, nsCSSProps::kFillRuleKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFillRule()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(
+ StyleSVG()->mFillRule, nsCSSProps::kFillRuleKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeLinecap()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVG()->mStrokeLinecap,
+ nsCSSProps::kStrokeLinecapKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStrokeLinejoin()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVG()->mStrokeLinejoin,
+ nsCSSProps::kStrokeLinejoinKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextAnchor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVG()->mTextAnchor,
+ nsCSSProps::kTextAnchorKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColorInterpolation()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVG()->mColorInterpolation,
+ nsCSSProps::kColorInterpolationKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetColorInterpolationFilters()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVG()->mColorInterpolationFilters,
+ nsCSSProps::kColorInterpolationKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetDominantBaseline()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVGReset()->mDominantBaseline,
+ nsCSSProps::kDominantBaselineKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetImageRendering()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleVisibility()->mImageRendering,
+ nsCSSProps::kImageRenderingKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetShapeRendering()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVG()->mShapeRendering,
+ nsCSSProps::kShapeRenderingKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTextRendering()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleText()->mTextRendering,
+ nsCSSProps::kTextRenderingKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFloodColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetToRGBAColor(val, StyleSVGReset()->mFloodColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetLightingColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetToRGBAColor(val, StyleSVGReset()->mLightingColor);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetStopColor()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetToRGBAColor(val, StyleSVGReset()->mStopColor);
+ return val.forget();
+}
+
+void
+nsComputedDOMStyle::BoxValuesToString(nsAString& aString,
+ const nsTArray<nsStyleCoord>& aBoxValues)
+{
+ MOZ_ASSERT(aBoxValues.Length() == 4, "wrong number of box values");
+ nsAutoString value1, value2, value3, value4;
+ SetCssTextToCoord(value1, aBoxValues[0]);
+ SetCssTextToCoord(value2, aBoxValues[1]);
+ SetCssTextToCoord(value3, aBoxValues[2]);
+ SetCssTextToCoord(value4, aBoxValues[3]);
+
+ // nsROCSSPrimitiveValue do not have binary comparison operators.
+ // Compare string results instead.
+ aString.Append(value1);
+ if (value1 != value2 || value1 != value3 || value1 != value4) {
+ aString.Append(' ');
+ aString.Append(value2);
+ if (value1 != value3 || value2 != value4) {
+ aString.Append(' ');
+ aString.Append(value3);
+ if (value2 != value4) {
+ aString.Append(' ');
+ aString.Append(value4);
+ }
+ }
+ }
+}
+
+void
+nsComputedDOMStyle::BasicShapeRadiiToString(nsAString& aCssText,
+ const nsStyleCorners& aCorners)
+{
+ nsTArray<nsStyleCoord> horizontal, vertical;
+ nsAutoString horizontalString, verticalString;
+ NS_FOR_CSS_FULL_CORNERS(corner) {
+ horizontal.AppendElement(
+ aCorners.Get(NS_FULL_TO_HALF_CORNER(corner, false)));
+ vertical.AppendElement(
+ aCorners.Get(NS_FULL_TO_HALF_CORNER(corner, true)));
+ }
+ BoxValuesToString(horizontalString, horizontal);
+ BoxValuesToString(verticalString, vertical);
+ aCssText.Append(horizontalString);
+ if (horizontalString == verticalString) {
+ return;
+ }
+ aCssText.AppendLiteral(" / ");
+ aCssText.Append(verticalString);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::CreatePrimitiveValueForBasicShape(
+ const StyleBasicShape* aStyleBasicShape)
+{
+ MOZ_ASSERT(aStyleBasicShape, "Expect a valid basic shape pointer!");
+
+ StyleBasicShapeType type = aStyleBasicShape->GetShapeType();
+ // Shape function name and opening parenthesis.
+ nsAutoString shapeFunctionString;
+ AppendASCIItoUTF16(nsCSSKeywords::GetStringValue(
+ aStyleBasicShape->GetShapeTypeName()),
+ shapeFunctionString);
+ shapeFunctionString.Append('(');
+ switch (type) {
+ case StyleBasicShapeType::Polygon: {
+ bool hasEvenOdd = aStyleBasicShape->GetFillRule() ==
+ StyleFillRule::Evenodd;
+ if (hasEvenOdd) {
+ shapeFunctionString.AppendLiteral("evenodd");
+ }
+ for (size_t i = 0;
+ i < aStyleBasicShape->Coordinates().Length(); i += 2) {
+ nsAutoString coordString;
+ if (i > 0 || hasEvenOdd) {
+ shapeFunctionString.AppendLiteral(", ");
+ }
+ SetCssTextToCoord(coordString,
+ aStyleBasicShape->Coordinates()[i]);
+ shapeFunctionString.Append(coordString);
+ shapeFunctionString.Append(' ');
+ SetCssTextToCoord(coordString,
+ aStyleBasicShape->Coordinates()[i + 1]);
+ shapeFunctionString.Append(coordString);
+ }
+ break;
+ }
+ case StyleBasicShapeType::Circle:
+ case StyleBasicShapeType::Ellipse: {
+ const nsTArray<nsStyleCoord>& radii = aStyleBasicShape->Coordinates();
+ MOZ_ASSERT(radii.Length() ==
+ (type == StyleBasicShapeType::Circle ? 1 : 2),
+ "wrong number of radii");
+ for (size_t i = 0; i < radii.Length(); ++i) {
+ nsAutoString radius;
+ RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
+ bool clampNegativeCalc = true;
+ SetValueToCoord(value, radii[i], clampNegativeCalc, nullptr,
+ nsCSSProps::kShapeRadiusKTable);
+ value->GetCssText(radius);
+ shapeFunctionString.Append(radius);
+ shapeFunctionString.Append(' ');
+ }
+ shapeFunctionString.AppendLiteral("at ");
+
+ RefPtr<nsDOMCSSValueList> position = GetROCSSValueList(false);
+ nsAutoString positionString;
+ SetValueToPosition(aStyleBasicShape->GetPosition(), position);
+ position->GetCssText(positionString);
+ shapeFunctionString.Append(positionString);
+ break;
+ }
+ case StyleBasicShapeType::Inset: {
+ BoxValuesToString(shapeFunctionString, aStyleBasicShape->Coordinates());
+ if (aStyleBasicShape->HasRadius()) {
+ shapeFunctionString.AppendLiteral(" round ");
+ nsAutoString radiiString;
+ BasicShapeRadiiToString(radiiString, aStyleBasicShape->GetRadius());
+ shapeFunctionString.Append(radiiString);
+ }
+ break;
+ }
+ default:
+ NS_NOTREACHED("unexpected type");
+ }
+ shapeFunctionString.Append(')');
+ RefPtr<nsROCSSPrimitiveValue> functionValue = new nsROCSSPrimitiveValue;
+ functionValue->SetString(shapeFunctionString);
+ return functionValue.forget();
+}
+
+template<typename ReferenceBox>
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::CreatePrimitiveValueForShapeSource(
+ const StyleBasicShape* aStyleBasicShape,
+ ReferenceBox aReferenceBox,
+ const KTableEntry aBoxKeywordTable[])
+{
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ if (aStyleBasicShape) {
+ valueList->AppendCSSValue(
+ CreatePrimitiveValueForBasicShape(aStyleBasicShape));
+ }
+
+ if (aReferenceBox == ReferenceBox::NoBox) {
+ return valueList.forget();
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(nsCSSProps::ValueToKeywordEnum(aReferenceBox, aBoxKeywordTable));
+ valueList->AppendCSSValue(val.forget());
+
+ return valueList.forget();
+}
+
+template<typename ReferenceBox>
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::GetShapeSource(
+ const StyleShapeSource<ReferenceBox>& aShapeSource,
+ const KTableEntry aBoxKeywordTable[])
+{
+ switch (aShapeSource.GetType()) {
+ case StyleShapeSourceType::Shape:
+ return CreatePrimitiveValueForShapeSource(aShapeSource.GetBasicShape(),
+ aShapeSource.GetReferenceBox(),
+ aBoxKeywordTable);
+ case StyleShapeSourceType::Box:
+ return CreatePrimitiveValueForShapeSource(nullptr,
+ aShapeSource.GetReferenceBox(),
+ aBoxKeywordTable);
+ case StyleShapeSourceType::URL: {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ SetValueToURLValue(aShapeSource.GetURL(), val);
+ return val.forget();
+ }
+ case StyleShapeSourceType::None: {
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(eCSSKeyword_none);
+ return val.forget();
+ }
+ default:
+ NS_NOTREACHED("unexpected type");
+ }
+ return nullptr;
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetClipPath()
+{
+ return GetShapeSource(StyleSVGReset()->mClipPath,
+ nsCSSProps::kClipPathGeometryBoxKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetShapeOutside()
+{
+ return GetShapeSource(StyleDisplay()->mShapeOutside,
+ nsCSSProps::kShapeOutsideShapeBoxKTable);
+}
+
+void
+nsComputedDOMStyle::SetCssTextToCoord(nsAString& aCssText,
+ const nsStyleCoord& aCoord)
+{
+ RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
+ bool clampNegativeCalc = true;
+ SetValueToCoord(value, aCoord, clampNegativeCalc);
+ value->GetCssText(aCssText);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::CreatePrimitiveValueForStyleFilter(
+ const nsStyleFilter& aStyleFilter)
+{
+ RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
+ // Handle url().
+ if (aStyleFilter.GetType() == NS_STYLE_FILTER_URL) {
+ MOZ_ASSERT(aStyleFilter.GetURL() &&
+ aStyleFilter.GetURL()->GetURI());
+ SetValueToURLValue(aStyleFilter.GetURL(), value);
+ return value.forget();
+ }
+
+ // Filter function name and opening parenthesis.
+ nsAutoString filterFunctionString;
+ AppendASCIItoUTF16(
+ nsCSSProps::ValueToKeyword(aStyleFilter.GetType(),
+ nsCSSProps::kFilterFunctionKTable),
+ filterFunctionString);
+ filterFunctionString.Append('(');
+
+ nsAutoString argumentString;
+ if (aStyleFilter.GetType() == NS_STYLE_FILTER_DROP_SHADOW) {
+ // Handle drop-shadow()
+ RefPtr<CSSValue> shadowValue =
+ GetCSSShadowArray(aStyleFilter.GetDropShadow(),
+ StyleColor()->mColor,
+ false);
+ ErrorResult dummy;
+ shadowValue->GetCssText(argumentString, dummy);
+ } else {
+ // Filter function argument.
+ SetCssTextToCoord(argumentString, aStyleFilter.GetFilterParameter());
+ }
+ filterFunctionString.Append(argumentString);
+
+ // Filter function closing parenthesis.
+ filterFunctionString.Append(')');
+
+ value->SetString(filterFunctionString);
+ return value.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetFilter()
+{
+ const nsTArray<nsStyleFilter>& filters = StyleEffects()->mFilters;
+
+ if (filters.IsEmpty()) {
+ RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
+ value->SetIdent(eCSSKeyword_none);
+ return value.forget();
+ }
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(false);
+ for(uint32_t i = 0; i < filters.Length(); i++) {
+ RefPtr<CSSValue> value = CreatePrimitiveValueForStyleFilter(filters[i]);
+ valueList->AppendCSSValue(value.forget());
+ }
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMask()
+{
+ const nsStyleSVGReset* svg = StyleSVGReset();
+ const nsStyleImageLayers::Layer& firstLayer = svg->mMask.mLayers[0];
+
+ // Mask is now a shorthand, but it used to be a longhand, so that we
+ // need to support computed style for the cases where it used to be
+ // a longhand.
+ if (svg->mMask.mImageCount > 1 ||
+ firstLayer.mClip != NS_STYLE_IMAGELAYER_CLIP_BORDER ||
+ firstLayer.mOrigin != NS_STYLE_IMAGELAYER_ORIGIN_BORDER ||
+ firstLayer.mComposite != NS_STYLE_MASK_COMPOSITE_ADD ||
+ firstLayer.mMaskMode != NS_STYLE_MASK_MODE_MATCH_SOURCE ||
+ !nsStyleImageLayers::IsInitialPositionForLayerType(
+ firstLayer.mPosition, nsStyleImageLayers::LayerType::Mask) ||
+ !firstLayer.mRepeat.IsInitialValue() ||
+ !firstLayer.mSize.IsInitialValue() ||
+ !(firstLayer.mImage.GetType() == eStyleImageType_Null ||
+ firstLayer.mImage.GetType() == eStyleImageType_Image)) {
+ return nullptr;
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+
+ SetValueToURLValue(firstLayer.mSourceURI, val);
+
+ return val.forget();
+}
+
+#ifdef MOZ_ENABLE_MASK_AS_SHORTHAND
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskClip()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mClip,
+ &nsStyleImageLayers::mClipCount,
+ StyleSVGReset()->mMask,
+ nsCSSProps::kImageLayerOriginKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskComposite()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mComposite,
+ &nsStyleImageLayers::mCompositeCount,
+ StyleSVGReset()->mMask,
+ nsCSSProps::kImageLayerCompositeKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskImage()
+{
+ const nsStyleImageLayers& layers = StyleSVGReset()->mMask;
+ return DoGetImageLayerImage(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskMode()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mMaskMode,
+ &nsStyleImageLayers::mMaskModeCount,
+ StyleSVGReset()->mMask,
+ nsCSSProps::kImageLayerModeKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskOrigin()
+{
+ return GetBackgroundList(&nsStyleImageLayers::Layer::mOrigin,
+ &nsStyleImageLayers::mOriginCount,
+ StyleSVGReset()->mMask,
+ nsCSSProps::kImageLayerOriginKTable);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskPosition()
+{
+ const nsStyleImageLayers& layers = StyleSVGReset()->mMask;
+ return DoGetImageLayerPosition(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskPositionX()
+{
+ const nsStyleImageLayers& layers = StyleSVGReset()->mMask;
+ return DoGetImageLayerPositionX(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskPositionY()
+{
+ const nsStyleImageLayers& layers = StyleSVGReset()->mMask;
+ return DoGetImageLayerPositionY(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskRepeat()
+{
+ const nsStyleImageLayers& layers = StyleSVGReset()->mMask;
+ return DoGetImageLayerRepeat(layers);
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskSize()
+{
+ const nsStyleImageLayers& layers = StyleSVGReset()->mMask;
+ return DoGetImageLayerSize(layers);
+}
+#endif
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetMaskType()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(StyleSVGReset()->mMaskType,
+ nsCSSProps::kMaskTypeKTable));
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetPaintOrder()
+{
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ nsAutoString string;
+ uint8_t paintOrder = StyleSVG()->mPaintOrder;
+ nsStyleUtil::AppendPaintOrderValue(paintOrder, string);
+ val->SetString(string);
+ return val.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransitionDelay()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mTransitionDelayCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleTransition *transition = &display->mTransitions[i];
+ RefPtr<nsROCSSPrimitiveValue> delay = new nsROCSSPrimitiveValue;
+ delay->SetTime((float)transition->GetDelay() / (float)PR_MSEC_PER_SEC);
+ valueList->AppendCSSValue(delay.forget());
+ } while (++i < display->mTransitionDelayCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransitionDuration()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mTransitionDurationCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleTransition *transition = &display->mTransitions[i];
+ RefPtr<nsROCSSPrimitiveValue> duration = new nsROCSSPrimitiveValue;
+
+ duration->SetTime((float)transition->GetDuration() / (float)PR_MSEC_PER_SEC);
+ valueList->AppendCSSValue(duration.forget());
+ } while (++i < display->mTransitionDurationCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransitionProperty()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mTransitionPropertyCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleTransition *transition = &display->mTransitions[i];
+ RefPtr<nsROCSSPrimitiveValue> property = new nsROCSSPrimitiveValue;
+ nsCSSPropertyID cssprop = transition->GetProperty();
+ if (cssprop == eCSSPropertyExtra_all_properties)
+ property->SetIdent(eCSSKeyword_all);
+ else if (cssprop == eCSSPropertyExtra_no_properties)
+ property->SetIdent(eCSSKeyword_none);
+ else if (cssprop == eCSSProperty_UNKNOWN ||
+ cssprop == eCSSPropertyExtra_variable)
+ {
+ nsAutoString escaped;
+ nsStyleUtil::AppendEscapedCSSIdent(
+ nsDependentAtomString(transition->GetUnknownProperty()), escaped);
+ property->SetString(escaped); // really want SetIdent
+ }
+ else
+ property->SetString(nsCSSProps::GetStringValue(cssprop));
+
+ valueList->AppendCSSValue(property.forget());
+ } while (++i < display->mTransitionPropertyCount);
+
+ return valueList.forget();
+}
+
+void
+nsComputedDOMStyle::AppendTimingFunction(nsDOMCSSValueList *aValueList,
+ const nsTimingFunction& aTimingFunction)
+{
+ RefPtr<nsROCSSPrimitiveValue> timingFunction = new nsROCSSPrimitiveValue;
+
+ nsAutoString tmp;
+ switch (aTimingFunction.mType) {
+ case nsTimingFunction::Type::CubicBezier:
+ nsStyleUtil::AppendCubicBezierTimingFunction(aTimingFunction.mFunc.mX1,
+ aTimingFunction.mFunc.mY1,
+ aTimingFunction.mFunc.mX2,
+ aTimingFunction.mFunc.mY2,
+ tmp);
+ break;
+ case nsTimingFunction::Type::StepStart:
+ case nsTimingFunction::Type::StepEnd:
+ nsStyleUtil::AppendStepsTimingFunction(aTimingFunction.mType,
+ aTimingFunction.mSteps,
+ tmp);
+ break;
+ default:
+ nsStyleUtil::AppendCubicBezierKeywordTimingFunction(aTimingFunction.mType,
+ tmp);
+ break;
+ }
+ timingFunction->SetString(tmp);
+ aValueList->AppendCSSValue(timingFunction.forget());
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetTransitionTimingFunction()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mTransitionTimingFunctionCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ AppendTimingFunction(valueList,
+ display->mTransitions[i].GetTimingFunction());
+ } while (++i < display->mTransitionTimingFunctionCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationName()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationNameCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> property = new nsROCSSPrimitiveValue;
+
+ const nsString& name = animation->GetName();
+ if (name.IsEmpty()) {
+ property->SetIdent(eCSSKeyword_none);
+ } else {
+ nsAutoString escaped;
+ nsStyleUtil::AppendEscapedCSSIdent(animation->GetName(), escaped);
+ property->SetString(escaped); // really want SetIdent
+ }
+ valueList->AppendCSSValue(property.forget());
+ } while (++i < display->mAnimationNameCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationDelay()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationDelayCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> delay = new nsROCSSPrimitiveValue;
+ delay->SetTime((float)animation->GetDelay() / (float)PR_MSEC_PER_SEC);
+ valueList->AppendCSSValue(delay.forget());
+ } while (++i < display->mAnimationDelayCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationDuration()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationDurationCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> duration = new nsROCSSPrimitiveValue;
+
+ duration->SetTime((float)animation->GetDuration() / (float)PR_MSEC_PER_SEC);
+ valueList->AppendCSSValue(duration.forget());
+ } while (++i < display->mAnimationDurationCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationTimingFunction()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationTimingFunctionCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ AppendTimingFunction(valueList,
+ display->mAnimations[i].GetTimingFunction());
+ } while (++i < display->mAnimationTimingFunctionCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationDirection()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationDirectionCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> direction = new nsROCSSPrimitiveValue;
+ direction->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(
+ static_cast<int32_t>(animation->GetDirection()),
+ nsCSSProps::kAnimationDirectionKTable));
+
+ valueList->AppendCSSValue(direction.forget());
+ } while (++i < display->mAnimationDirectionCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationFillMode()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationFillModeCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> fillMode = new nsROCSSPrimitiveValue;
+ fillMode->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(
+ static_cast<int32_t>(animation->GetFillMode()),
+ nsCSSProps::kAnimationFillModeKTable));
+
+ valueList->AppendCSSValue(fillMode.forget());
+ } while (++i < display->mAnimationFillModeCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationIterationCount()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationIterationCountCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> iterationCount = new nsROCSSPrimitiveValue;
+
+ float f = animation->GetIterationCount();
+ /* Need a nasty hack here to work around an optimizer bug in gcc
+ 4.2 on Mac, which somehow gets confused when directly comparing
+ a float to the return value of NS_IEEEPositiveInfinity when
+ building 32-bit builds. */
+#ifdef XP_MACOSX
+ volatile
+#endif
+ float inf = NS_IEEEPositiveInfinity();
+ if (f == inf) {
+ iterationCount->SetIdent(eCSSKeyword_infinite);
+ } else {
+ iterationCount->SetNumber(f);
+ }
+ valueList->AppendCSSValue(iterationCount.forget());
+ } while (++i < display->mAnimationIterationCountCount);
+
+ return valueList.forget();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetAnimationPlayState()
+{
+ const nsStyleDisplay* display = StyleDisplay();
+
+ RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
+
+ MOZ_ASSERT(display->mAnimationPlayStateCount > 0,
+ "first item must be explicit");
+ uint32_t i = 0;
+ do {
+ const StyleAnimation *animation = &display->mAnimations[i];
+ RefPtr<nsROCSSPrimitiveValue> playState = new nsROCSSPrimitiveValue;
+ playState->SetIdent(
+ nsCSSProps::ValueToKeywordEnum(animation->GetPlayState(),
+ nsCSSProps::kAnimationPlayStateKTable));
+ valueList->AppendCSSValue(playState.forget());
+ } while (++i < display->mAnimationPlayStateCount);
+
+ return valueList.forget();
+}
+
+static void
+MarkComputedStyleMapDirty(const char* aPref, void* aData)
+{
+ static_cast<nsComputedStyleMap*>(aData)->MarkDirty();
+}
+
+already_AddRefed<CSSValue>
+nsComputedDOMStyle::DoGetCustomProperty(const nsAString& aPropertyName)
+{
+ MOZ_ASSERT(nsCSSProps::IsCustomPropertyName(aPropertyName));
+
+ const nsStyleVariables* variables = StyleVariables();
+
+ nsString variableValue;
+ const nsAString& name = Substring(aPropertyName,
+ CSS_CUSTOM_NAME_PREFIX_LENGTH);
+ if (!variables->mVariables.Get(name, variableValue)) {
+ return nullptr;
+ }
+
+ RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
+ val->SetString(variableValue);
+
+ return val.forget();
+}
+
+void
+nsComputedDOMStyle::ParentChainChanged(nsIContent* aContent)
+{
+ NS_ASSERTION(mContent == aContent, "didn't we register mContent?");
+ NS_ASSERTION(mResolvedStyleContext,
+ "should have only registered an observer when "
+ "mResolvedStyleContext is true");
+
+ ClearStyleContext();
+}
+
+/* static */ nsComputedStyleMap*
+nsComputedDOMStyle::GetComputedStyleMap()
+{
+ static nsComputedStyleMap map = {
+ {
+#define COMPUTED_STYLE_PROP(prop_, method_) \
+ { eCSSProperty_##prop_, &nsComputedDOMStyle::DoGet##method_ },
+#include "nsComputedDOMStylePropertyList.h"
+#undef COMPUTED_STYLE_PROP
+ }
+ };
+ return &map;
+}
+
+/* static */ void
+nsComputedDOMStyle::RegisterPrefChangeCallbacks()
+{
+ // Note that this will register callbacks for all properties with prefs, not
+ // just those that are implemented on computed style objects, as it's not
+ // easy to grab specific property data from nsCSSPropList.h based on the
+ // entries iterated in nsComputedDOMStylePropertyList.h.
+ nsComputedStyleMap* data = GetComputedStyleMap();
+#define REGISTER_CALLBACK(pref_) \
+ if (pref_[0]) { \
+ Preferences::RegisterCallback(MarkComputedStyleMapDirty, pref_, data); \
+ }
+#define CSS_PROP(prop_, id_, method_, flags_, pref_, parsevariant_, \
+ kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+ REGISTER_CALLBACK(pref_)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+#undef REGISTER_CALLBACK
+}
+
+/* static */ void
+nsComputedDOMStyle::UnregisterPrefChangeCallbacks()
+{
+ nsComputedStyleMap* data = GetComputedStyleMap();
+#define UNREGISTER_CALLBACK(pref_) \
+ if (pref_[0]) { \
+ Preferences::UnregisterCallback(MarkComputedStyleMapDirty, pref_, data); \
+ }
+#define CSS_PROP(prop_, id_, method_, flags_, pref_, parsevariant_, \
+ kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+ UNREGISTER_CALLBACK(pref_)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP
+#undef UNREGISTER_CALLBACK
+}