/usr/include/thunderbird/mozilla/css/Declaration.h is in thunderbird-dev 1:52.8.0-1~deb8u1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 | /* -*- 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/. */
/*
* representation of a declaration block (or style attribute) in a CSS
* stylesheet
*/
#ifndef mozilla_css_Declaration_h
#define mozilla_css_Declaration_h
// This header is in EXPORTS because it's used in several places in content/,
// but it's not really a public interface.
#ifndef MOZILLA_INTERNAL_API
#error "This file should only be included within libxul"
#endif
#include "mozilla/Attributes.h"
#include "mozilla/DeclarationBlock.h"
#include "mozilla/MemoryReporting.h"
#include "CSSVariableDeclarations.h"
#include "nsCSSDataBlock.h"
#include "nsCSSPropertyID.h"
#include "nsCSSProps.h"
#include "nsIStyleRule.h"
#include "nsStringFwd.h"
#include "nsTArray.h"
#include <stdio.h>
// feec07b8-3fe6-491e-90d5-cc93f853e048
#define NS_CSS_DECLARATION_IMPL_CID \
{ 0xfeec07b8, 0x3fe6, 0x491e, \
{ 0x90, 0xd5, 0xcc, 0x93, 0xf8, 0x53, 0xe0, 0x48 } }
class nsHTMLCSSStyleSheet;
namespace mozilla {
namespace css {
class Rule;
class Declaration;
/**
* ImportantStyleData is the implementation of nsIStyleRule (a source of
* style data) representing the style data coming from !important rules;
* the !important declarations need a separate nsIStyleRule object since
* they fit at a different point in the cascade.
*
* ImportantStyleData is allocated only as part of a Declaration object.
*/
class ImportantStyleData final : public nsIStyleRule
{
public:
NS_DECL_ISUPPORTS
inline ::mozilla::css::Declaration* Declaration();
// nsIStyleRule interface
virtual void MapRuleInfoInto(nsRuleData* aRuleData) override;
virtual bool MightMapInheritedStyleData() override;
virtual bool GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty,
nsCSSValue* aValue) override;
#ifdef DEBUG
virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
#endif
private:
ImportantStyleData() {}
~ImportantStyleData() {}
friend class ::mozilla::css::Declaration;
};
// Declaration objects have unusual lifetime rules. Every declaration
// begins life in an invalid state which ends when InitializeEmpty or
// CompressFrom is called upon it. After that, it can be attached to
// exactly one style rule, and will be destroyed when that style rule
// is destroyed. A declaration becomes immutable (via a SetImmutable
// call) when it is matched (put in the rule tree); after that, it must
// be copied before it can be modified, which is taken care of by
// |EnsureMutable|.
class Declaration final : public DeclarationBlock
, public nsIStyleRule
{
public:
/**
* Construct an |Declaration| that is in an invalid state (null
* |mData|) and cannot be used until its |CompressFrom| method or
* |InitializeEmpty| method is called.
*/
Declaration() : DeclarationBlock(StyleBackendType::Gecko) {}
Declaration(const Declaration& aCopy);
NS_DECLARE_STATIC_IID_ACCESSOR(NS_CSS_DECLARATION_IMPL_CID)
NS_DECL_ISUPPORTS
private:
~Declaration();
public:
// nsIStyleRule implementation
virtual void MapRuleInfoInto(nsRuleData *aRuleData) override;
virtual bool MightMapInheritedStyleData() override;
virtual bool GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty,
nsCSSValue* aValue) override;
#ifdef DEBUG
virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
#endif
/**
* |ValueAppended| must be called to maintain this declaration's
* |mOrder| whenever a property is parsed into an expanded data block
* for this declaration. aProperty must not be a shorthand.
*/
void ValueAppended(nsCSSPropertyID aProperty);
void GetPropertyValue(const nsAString& aProperty, nsAString& aValue) const;
void GetPropertyValueByID(nsCSSPropertyID aPropID, nsAString& aValue) const;
void GetAuthoredPropertyValue(const nsAString& aProperty,
nsAString& aValue) const;
bool GetPropertyIsImportant(const nsAString& aProperty) const;
void RemoveProperty(const nsAString& aProperty);
void RemovePropertyByID(nsCSSPropertyID aProperty);
bool HasProperty(nsCSSPropertyID aProperty) const;
bool HasImportantData() const {
return mImportantData || mImportantVariables;
}
/**
* Adds a custom property declaration to this object.
*
* @param aName The variable name (i.e., without the "--" prefix).
* @param aType The type of value the variable has.
* @param aValue The value of the variable, if aType is
* CSSVariableDeclarations::eTokenStream.
* @param aIsImportant Whether the declaration is !important.
* @param aOverrideImportant When aIsImportant is false, whether an
* existing !important declaration will be overridden.
*/
void AddVariable(const nsAString& aName,
CSSVariableDeclarations::Type aType,
const nsString& aValue,
bool aIsImportant,
bool aOverrideImportant);
/**
* Removes a custom property declaration from this object.
*
* @param aName The variable name (i.e., without the "--" prefix).
*/
void RemoveVariable(const nsAString& aName);
/**
* Gets the string value for a custom property declaration of a variable
* with a given name.
*
* @param aName The variable name (i.e., without the "--" prefix).
* @param aValue Out parameter into which the variable's value will be
* stored. If the value is 'initial' or 'inherit', that exact string
* will be stored in aValue.
*/
void GetVariableValue(const nsAString& aName, nsAString& aValue) const;
/**
* Returns whether the custom property declaration for a variable with
* the given name was !important.
*/
bool GetVariableIsImportant(const nsAString& aName) const;
uint32_t Count() const {
return mOrder.Length();
}
// Returns whether we actually had a property at aIndex
bool GetNthProperty(uint32_t aIndex, nsAString& aReturn) const;
void ToString(nsAString& aString) const;
nsCSSCompressedDataBlock* GetNormalBlock() const { return mData; }
nsCSSCompressedDataBlock* GetImportantBlock() const { return mImportantData; }
void AssertNotExpanded() const {
MOZ_ASSERT(mData, "should only be called when not expanded");
}
/**
* Initialize this declaration as holding no data. Cannot fail.
*/
void InitializeEmpty();
/**
* Transfer all of the state from |aExpandedData| into this declaration.
* After calling, |aExpandedData| should be in its initial state.
* Callers must make sure mOrder is updated as necessary.
*/
void CompressFrom(nsCSSExpandedDataBlock *aExpandedData) {
MOZ_ASSERT(!mData, "oops");
MOZ_ASSERT(!mImportantData, "oops");
aExpandedData->Compress(getter_Transfers(mData),
getter_Transfers(mImportantData),
mOrder);
aExpandedData->AssertInitialState();
}
/**
* Transfer all of the state from this declaration into
* |aExpandedData| and put this declaration temporarily into an
* invalid state (ended by |CompressFrom| or |InitializeEmpty|) that
* should last only during parsing. During this time only
* |ValueAppended| should be called.
*/
void ExpandTo(nsCSSExpandedDataBlock *aExpandedData) {
AssertMutable();
aExpandedData->AssertInitialState();
MOZ_ASSERT(mData, "oops");
aExpandedData->Expand(mData.forget(), mImportantData.forget());
}
void MapImportantRuleInfoInto(nsRuleData *aRuleData) const {
AssertNotExpanded();
MOZ_ASSERT(mImportantData || mImportantVariables,
"must have important data or variables");
if (mImportantData) {
mImportantData->MapRuleInfoInto(aRuleData);
}
if (mImportantVariables) {
mImportantVariables->MapRuleInfoInto(aRuleData);
}
}
bool MapsImportantInheritedStyleData() const;
/**
* Attempt to replace the value for |aProperty| stored in this
* declaration with the matching value from |aFromBlock|.
* This method may only be called on a mutable declaration.
* It will fail (returning false) if |aProperty| is shorthand,
* is not already in this declaration, or does not have the indicated
* importance level. If it returns true, it erases the value in
* |aFromBlock|. |aChanged| is set to true if the declaration
* changed as a result of the call, and to false otherwise.
*/
bool TryReplaceValue(nsCSSPropertyID aProperty, bool aIsImportant,
nsCSSExpandedDataBlock& aFromBlock,
bool* aChanged)
{
AssertMutable();
AssertNotExpanded();
if (nsCSSProps::IsShorthand(aProperty)) {
*aChanged = false;
return false;
}
nsCSSCompressedDataBlock *block = aIsImportant ? mImportantData : mData;
// mImportantData might be null
if (!block) {
*aChanged = false;
return false;
}
#ifdef DEBUG
{
nsCSSCompressedDataBlock *other = aIsImportant ? mData : mImportantData;
MOZ_ASSERT(!other || !other->ValueFor(aProperty) ||
!block->ValueFor(aProperty),
"Property both important and not?");
}
#endif
return block->TryReplaceValue(aProperty, aFromBlock, aChanged);
}
bool HasNonImportantValueFor(nsCSSPropertyID aProperty) const {
MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty), "must be longhand");
return !!mData->ValueFor(aProperty);
}
/**
* Clear the data, in preparation for its replacement with entirely
* new data by a call to |CompressFrom|.
*/
void ClearData() {
AssertMutable();
mData = nullptr;
mImportantData = nullptr;
mVariables = nullptr;
mImportantVariables = nullptr;
mOrder.Clear();
mVariableOrder.Clear();
}
ImportantStyleData* GetImportantStyleData() {
if (HasImportantData()) {
return &mImportantStyleData;
}
return nullptr;
}
private:
Declaration& operator=(const Declaration& aCopy) = delete;
bool operator==(const Declaration& aCopy) const = delete;
void GetPropertyValueInternal(nsCSSPropertyID aProperty, nsAString& aValue,
nsCSSValue::Serialization aValueSerialization)
const;
bool GetPropertyIsImportantByID(nsCSSPropertyID aProperty) const;
static void AppendImportanceToString(bool aIsImportant, nsAString& aString);
// return whether there was a value in |aValue| (i.e., it had a non-null unit)
bool AppendValueToString(nsCSSPropertyID aProperty, nsAString& aResult) const;
bool AppendValueToString(nsCSSPropertyID aProperty, nsAString& aResult,
nsCSSValue::Serialization aValueSerialization) const;
// Helper for ToString with strange semantics regarding aValue.
void AppendPropertyAndValueToString(nsCSSPropertyID aProperty,
nsAutoString& aValue,
nsAString& aResult) const;
// helper for ToString that serializes a custom property declaration for
// a variable with the specified name
void AppendVariableAndValueToString(const nsAString& aName,
nsAString& aResult) const;
void GetImageLayerValue(nsCSSCompressedDataBlock *data,
nsAString& aValue,
nsCSSValue::Serialization aSerialization,
const nsCSSPropertyID aTable[]) const;
void GetImageLayerPositionValue(nsCSSCompressedDataBlock *data,
nsAString& aValue,
nsCSSValue::Serialization aSerialization,
const nsCSSPropertyID aTable[]) const;
public:
/**
* Returns the property at the given index in the ordered list of
* declarations. For custom properties, eCSSPropertyExtra_variable
* is returned.
*/
nsCSSPropertyID GetPropertyAt(uint32_t aIndex) const {
uint32_t value = mOrder[aIndex];
if (value >= eCSSProperty_COUNT) {
return eCSSPropertyExtra_variable;
}
return nsCSSPropertyID(value);
}
/**
* Gets the name of the custom property at the given index in the ordered
* list of declarations.
*/
void GetCustomPropertyNameAt(uint32_t aIndex, nsAString& aResult) const {
MOZ_ASSERT(mOrder[aIndex] >= eCSSProperty_COUNT);
uint32_t variableIndex = mOrder[aIndex] - eCSSProperty_COUNT;
aResult.Truncate();
aResult.AppendLiteral("--");
aResult.Append(mVariableOrder[variableIndex]);
}
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
private:
// The order of properties in this declaration. Longhand properties are
// represented by their nsCSSPropertyID value, and each custom property (--*)
// is represented by a value that begins at eCSSProperty_COUNT.
//
// Subtracting eCSSProperty_COUNT from those values that represent custom
// properties results in an index into mVariableOrder, which identifies the
// specific variable the custom property declaration is for.
AutoTArray<uint32_t, 8> mOrder;
// variable names of custom properties found in mOrder
nsTArray<nsString> mVariableOrder;
// never null, except while expanded, or before the first call to
// InitializeEmpty or CompressFrom.
nsAutoPtr<nsCSSCompressedDataBlock> mData;
// may be null
nsAutoPtr<nsCSSCompressedDataBlock> mImportantData;
// may be null
nsAutoPtr<CSSVariableDeclarations> mVariables;
// may be null
nsAutoPtr<CSSVariableDeclarations> mImportantVariables;
friend class ImportantStyleData;
ImportantStyleData mImportantStyleData;
};
inline ::mozilla::css::Declaration*
ImportantStyleData::Declaration()
{
union {
char* ch; /* for pointer arithmetic */
::mozilla::css::Declaration* declaration;
ImportantStyleData* importantData;
} u;
u.importantData = this;
u.ch -= offsetof(::mozilla::css::Declaration, mImportantStyleData);
return u.declaration;
}
NS_DEFINE_STATIC_IID_ACCESSOR(Declaration, NS_CSS_DECLARATION_IMPL_CID)
} // namespace css
} // namespace mozilla
#endif /* mozilla_css_Declaration_h */
|