summaryrefslogtreecommitdiffstats
path: root/layout/style/nsCSSParser.h
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/nsCSSParser.h
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/nsCSSParser.h')
-rw-r--r--layout/style/nsCSSParser.h346
1 files changed, 346 insertions, 0 deletions
diff --git a/layout/style/nsCSSParser.h b/layout/style/nsCSSParser.h
new file mode 100644
index 000000000..37cd325f2
--- /dev/null
+++ b/layout/style/nsCSSParser.h
@@ -0,0 +1,346 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/* parsing of CSS stylesheets, based on a token stream from the CSS scanner */
+
+#ifndef nsCSSParser_h___
+#define nsCSSParser_h___
+
+#include "mozilla/Attributes.h"
+#include "mozilla/css/Loader.h"
+
+#include "nsCSSPropertyID.h"
+#include "nsCSSScanner.h"
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsStringFwd.h"
+#include "nsTArrayForwardDeclare.h"
+
+class nsIPrincipal;
+class nsIURI;
+struct nsCSSSelectorList;
+class nsMediaList;
+class nsMediaQuery;
+class nsCSSKeyframeRule;
+class nsCSSValue;
+struct nsRuleData;
+
+namespace mozilla {
+class CSSStyleSheet;
+class CSSVariableValues;
+namespace css {
+class Rule;
+class Declaration;
+class StyleRule;
+} // namespace css
+} // namespace mozilla
+
+// Interface to the css parser.
+
+class MOZ_STACK_CLASS nsCSSParser {
+public:
+ explicit nsCSSParser(mozilla::css::Loader* aLoader = nullptr,
+ mozilla::CSSStyleSheet* aSheet = nullptr);
+ ~nsCSSParser();
+
+ static void Startup();
+ static void Shutdown();
+
+private:
+ nsCSSParser(nsCSSParser const&) = delete;
+ nsCSSParser& operator=(nsCSSParser const&) = delete;
+
+public:
+ /**
+ * Parse aInput into the stylesheet that was previously passed to the
+ * constructor. Calling this method on an nsCSSParser that had nullptr
+ * passed in as the style sheet is an error.
+ *
+ * @param aInput the data to parse
+ * @param aSheetURL the URI to use as the sheet URI (for error reporting).
+ * This must match the URI of the sheet passed to
+ * the constructor.
+ * @param aBaseURI the URI to use for relative URI resolution
+ * @param aSheetPrincipal the principal of the stylesheet. This must match
+ * the principal of the sheet passed to the
+ * constructor.
+ * @param aLineNumber the line number of the first line of the sheet.
+ * @param aReusableSheets style sheets that can be reused by an @import.
+ * This can be nullptr.
+ */
+ nsresult ParseSheet(const nsAString& aInput,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURI,
+ nsIPrincipal* aSheetPrincipal,
+ uint32_t aLineNumber,
+ mozilla::css::LoaderReusableStyleSheets* aReusableSheets =
+ nullptr);
+
+ // Parse HTML style attribute or its equivalent in other markup
+ // languages. aBaseURL is the base url to use for relative links in
+ // the declaration.
+ already_AddRefed<mozilla::css::Declaration>
+ ParseStyleAttribute(const nsAString& aAttributeValue,
+ nsIURI* aDocURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aNodePrincipal);
+
+ // Parse the body of a declaration block. Very similar to
+ // ParseStyleAttribute, but used under different circumstances.
+ // The contents of aDeclaration will be erased and replaced with the
+ // results of parsing; aChanged will be set true if the aDeclaration
+ // argument was modified.
+ nsresult ParseDeclarations(const nsAString& aBuffer,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ mozilla::css::Declaration* aDeclaration,
+ bool* aChanged);
+
+ nsresult ParseRule(const nsAString& aRule,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ mozilla::css::Rule** aResult);
+
+ // Parse the value of a single CSS property, and add or replace that
+ // property in aDeclaration.
+ //
+ // SVG "mapped attributes" (which correspond directly to CSS
+ // properties) are parsed slightly differently from regular CSS; in
+ // particular, units may be omitted from <length>. The 'aIsSVGMode'
+ // argument controls this quirk. Note that this *only* applies to
+ // mapped attributes, not inline styles or full style sheets in SVG.
+ void ParseProperty(const nsCSSPropertyID aPropID,
+ const nsAString& aPropValue,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ mozilla::css::Declaration* aDeclaration,
+ bool* aChanged,
+ bool aIsImportant,
+ bool aIsSVGMode = false);
+
+ // Same as ParseProperty but returns an nsCSSValue in aResult
+ // rather than storing the property in a Declaration. aPropID
+ // must be a longhand property.
+ void ParseLonghandProperty(const nsCSSPropertyID aPropID,
+ const nsAString& aPropValue,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ nsCSSValue& aResult);
+
+ // Parse the value of a CSS transform property. Returns
+ // whether the value was successfully parsed. If
+ // aDisallowRelativeValues is true then this method will
+ // only successfully parse if all values are numbers or
+ // have non-relative dimensions.
+ bool ParseTransformProperty(const nsAString& aPropValue,
+ bool aDisallowRelativeValues,
+ nsCSSValue& aResult);
+
+ // The same as ParseProperty but for a variable.
+ void ParseVariable(const nsAString& aVariableName,
+ const nsAString& aPropValue,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ mozilla::css::Declaration* aDeclaration,
+ bool* aChanged,
+ bool aIsImportant);
+ /**
+ * Parse aBuffer into a media list |aMediaList|, which must be
+ * non-null, replacing its current contents. If aHTMLMode is true,
+ * parse according to HTML rules, with commas as the most important
+ * delimiter. Otherwise, parse according to CSS rules, with
+ * parentheses and strings more important than commas. |aURL| and
+ * |aLineNumber| are used for error reporting.
+ */
+ void ParseMediaList(const nsSubstring& aBuffer,
+ nsIURI* aURL,
+ uint32_t aLineNumber,
+ nsMediaList* aMediaList,
+ bool aHTMLMode);
+
+ /*
+ * Parse aBuffer into a list of media queries and their associated values,
+ * according to grammar:
+ * <source-size-list> = <source-size>#?
+ * <source-size> = <media-condition>? <length>
+ *
+ * Note that this grammar is top-level: The function expects to consume the
+ * entire input buffer.
+ *
+ * Output arrays overwritten (not appended) and are cleared in case of parse
+ * failure.
+ */
+ bool ParseSourceSizeList(const nsAString& aBuffer,
+ nsIURI* aURI, // for error reporting
+ uint32_t aLineNumber, // for error reporting
+ InfallibleTArray< nsAutoPtr<nsMediaQuery> >& aQueries,
+ InfallibleTArray<nsCSSValue>& aValues,
+ bool aHTMLMode);
+
+ /**
+ * Parse aBuffer into a nsCSSValue |aValue|. Will return false
+ * if aBuffer is not a valid font family list.
+ */
+ bool ParseFontFamilyListString(const nsSubstring& aBuffer,
+ nsIURI* aURL,
+ uint32_t aLineNumber,
+ nsCSSValue& aValue);
+
+ /**
+ * Parse aBuffer into a nsCSSValue |aValue|. Will return false
+ * if aBuffer is not a valid CSS color specification.
+ * One can use nsRuleNode::ComputeColor to compute an nscolor from
+ * the returned nsCSSValue.
+ */
+ bool ParseColorString(const nsSubstring& aBuffer,
+ nsIURI* aURL,
+ uint32_t aLineNumber,
+ nsCSSValue& aValue,
+ bool aSuppressErrors = false);
+
+ /**
+ * Parse aBuffer into a nsCSSValue |aValue|. Will return false
+ * if aBuffer is not a valid CSS margin specification.
+ * One can use nsRuleNode::GetRectValue to compute an nsCSSRect from
+ * the returned nsCSSValue.
+ */
+ bool ParseMarginString(const nsSubstring& aBuffer,
+ nsIURI* aURL,
+ uint32_t aLineNumber,
+ nsCSSValue& aValue,
+ bool aSuppressErrors = false);
+
+ /**
+ * Parse aBuffer into a selector list. On success, caller must
+ * delete *aSelectorList when done with it.
+ */
+ nsresult ParseSelectorString(const nsSubstring& aSelectorString,
+ nsIURI* aURL,
+ uint32_t aLineNumber,
+ nsCSSSelectorList** aSelectorList);
+
+ /*
+ * Parse a keyframe rule (which goes inside an @keyframes rule).
+ * Return it if the parse was successful.
+ */
+ already_AddRefed<nsCSSKeyframeRule>
+ ParseKeyframeRule(const nsSubstring& aBuffer,
+ nsIURI* aURL,
+ uint32_t aLineNumber);
+
+ /*
+ * Parse a selector list for a keyframe rule. Return whether
+ * the parse succeeded.
+ */
+ bool ParseKeyframeSelectorString(const nsSubstring& aSelectorString,
+ nsIURI* aURL,
+ uint32_t aLineNumber,
+ InfallibleTArray<float>& aSelectorList);
+
+ /**
+ * Parse a property and value and return whether the property/value pair
+ * is supported.
+ */
+ bool EvaluateSupportsDeclaration(const nsAString& aProperty,
+ const nsAString& aValue,
+ nsIURI* aDocURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aDocPrincipal);
+
+ /**
+ * Parse an @supports condition and returns the result of evaluating the
+ * condition.
+ */
+ bool EvaluateSupportsCondition(const nsAString& aCondition,
+ nsIURI* aDocURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aDocPrincipal);
+
+ typedef void (*VariableEnumFunc)(const nsAString&, void*);
+
+ /**
+ * Parses aPropertyValue as a property value and calls aFunc for each
+ * variable reference that is found. Returns false if there was
+ * a syntax error in the use of variable references.
+ */
+ bool EnumerateVariableReferences(const nsAString& aPropertyValue,
+ VariableEnumFunc aFunc,
+ void* aData);
+
+ /**
+ * Parses aPropertyValue as a property value and resolves variable references
+ * using the values in aVariables.
+ */
+ bool ResolveVariableValue(const nsAString& aPropertyValue,
+ const mozilla::CSSVariableValues* aVariables,
+ nsString& aResult,
+ nsCSSTokenSerializationType& aFirstToken,
+ nsCSSTokenSerializationType& aLastToken);
+
+ /**
+ * Parses a string as a CSS token stream value for particular property,
+ * resolving any variable references. The parsed property value is stored
+ * in the specified nsRuleData object. If aShorthandPropertyID has a value
+ * other than eCSSProperty_UNKNOWN, this is the property that will be parsed;
+ * otherwise, aPropertyID will be parsed. Either way, only aPropertyID,
+ * a longhand property, will be copied over to the rule data.
+ *
+ * If the property cannot be parsed, it will be treated as if 'initial' or
+ * 'inherit' were specified, for non-inherited and inherited properties
+ * respectively.
+ */
+ void ParsePropertyWithVariableReferences(
+ nsCSSPropertyID aPropertyID,
+ nsCSSPropertyID aShorthandPropertyID,
+ const nsAString& aValue,
+ const mozilla::CSSVariableValues* aVariables,
+ nsRuleData* aRuleData,
+ nsIURI* aDocURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aDocPrincipal,
+ mozilla::CSSStyleSheet* aSheet,
+ uint32_t aLineNumber,
+ uint32_t aLineOffset);
+
+ bool ParseCounterStyleName(const nsAString& aBuffer,
+ nsIURI* aURL,
+ nsAString& aName);
+
+ bool ParseCounterDescriptor(nsCSSCounterDesc aDescID,
+ const nsAString& aBuffer,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ nsCSSValue& aValue);
+
+ bool ParseFontFaceDescriptor(nsCSSFontDesc aDescID,
+ const nsAString& aBuffer,
+ nsIURI* aSheetURL,
+ nsIURI* aBaseURL,
+ nsIPrincipal* aSheetPrincipal,
+ nsCSSValue& aValue);
+
+ // Check whether a given value can be applied to a property.
+ bool IsValueValidForProperty(const nsCSSPropertyID aPropID,
+ const nsAString& aPropValue);
+
+ // Return the default value to be used for -moz-control-character-visibility,
+ // from preferences (cached by our Startup(), so that both nsStyleText and
+ // nsRuleNode can have fast access to it).
+ static uint8_t ControlCharVisibilityDefault();
+
+protected:
+ // This is a CSSParserImpl*, but if we expose that type name in this
+ // header, we can't put the type definition (in nsCSSParser.cpp) in
+ // the anonymous namespace.
+ void* mImpl;
+};
+
+#endif /* nsCSSParser_h___ */