diff options
Diffstat (limited to 'layout/style/ServoStyleConstsForwards.h')
| -rw-r--r-- | layout/style/ServoStyleConstsForwards.h | 235 |
1 files changed, 235 insertions, 0 deletions
diff --git a/layout/style/ServoStyleConstsForwards.h b/layout/style/ServoStyleConstsForwards.h new file mode 100644 index 0000000000..88710db16b --- /dev/null +++ b/layout/style/ServoStyleConstsForwards.h @@ -0,0 +1,235 @@ +/* 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 https://mozilla.org/MPL/2.0/. */ + +/* + * This file contains forward declarations and typedefs for types that cbindgen + * cannot understand but renames / prefixes, and includes for some of the types + * it needs. + */ + +#ifndef mozilla_ServoStyleConsts_h +# error "This file is only meant to be included from ServoStyleConsts.h" +#endif + +#ifndef mozilla_ServoStyleConstsForwards_h +# define mozilla_ServoStyleConstsForwards_h + +# include "nsColor.h" +# include "nsCoord.h" +# include "mozilla/AtomArray.h" +# include "mozilla/IntegerRange.h" +# include "mozilla/Span.h" +# include "Units.h" +# include "mozilla/gfx/Types.h" +# include "mozilla/CORSMode.h" +# include "mozilla/MemoryReporting.h" +# include "mozilla/ServoTypes.h" +# include "mozilla/ServoBindingTypes.h" +# include "mozilla/Vector.h" +# include "nsCSSPropertyID.h" +# include "nsCompatibility.h" +# include "nsIURI.h" +# include "mozilla/image/Resolution.h" +# include <atomic> + +struct RawServoAnimationValueTable; + +class nsAtom; +class nsIFrame; +class nsINode; +class nsIContent; +class nsCSSPropertyIDSet; +class nsPresContext; +class nsSimpleContentList; +class imgRequestProxy; +struct nsCSSValueSharedList; + +class gfxFontFeatureValueSet; +struct gfxFontFeature; +namespace mozilla { +namespace gfx { +struct FontVariation; +} // namespace gfx +} // namespace mozilla +typedef mozilla::gfx::FontVariation gfxFontVariation; + +enum nsCSSUnit : uint32_t; +enum nsChangeHint : uint32_t; + +namespace nsStyleTransformMatrix { +enum class MatrixTransformOperator : uint8_t; +} + +template <typename T> +class nsMainThreadPtrHolder; + +namespace mozilla { + +class ComputedStyle; + +using Matrix4x4Components = float[16]; +using StyleMatrix4x4Components = Matrix4x4Components; + +// This is sound because std::num::NonZeroUsize is repr(transparent). +// +// It is just the case that cbindgen doesn't understand it natively. +using StyleNonZeroUsize = uintptr_t; + +struct Keyframe; +struct PropertyStyleAnimationValuePair; + +using ComputedKeyframeValues = nsTArray<PropertyStyleAnimationValuePair>; + +class ComputedStyle; +enum LogicalAxis : uint8_t; +class SeenPtrs; +class SharedFontList; +class StyleSheet; +class WritingMode; +class ServoElementSnapshotTable; + +template <typename T> +struct StyleForgottenArcSlicePtr; + +struct AnimationPropertySegment; +struct AspectRatio; +struct ComputedTiming; +struct URLExtraData; + +enum HalfCorner : uint8_t; +enum LogicalSide : uint8_t; +enum class PseudoStyleType : uint8_t; +enum class OriginFlags : uint8_t; +enum class UseBoxSizing : uint8_t; + +namespace css { +class Loader; +class LoaderReusableStyleSheets; +class SheetLoadData; +using SheetLoadDataHolder = nsMainThreadPtrHolder<SheetLoadData>; +enum SheetParsingMode : uint8_t; +} // namespace css + +namespace dom { +enum class IterationCompositeOperation : uint8_t; +enum class CallerType : uint32_t; + +class Element; +class Document; +class ImageTracker; + +} // namespace dom + +namespace ipc { +class ByteBuf; +} // namespace ipc + +// Replacement for a Rust Box<T> for a non-dynamically-sized-type. +// +// TODO(emilio): If this was some sort of nullable box then this could be made +// to work with moves, and also reduce memory layout size of stuff, potentially. +template <typename T> +struct StyleBox { + explicit StyleBox(UniquePtr<T> aPtr) : mRaw(aPtr.release()) { + MOZ_DIAGNOSTIC_ASSERT(mRaw); + } + + ~StyleBox() { + MOZ_DIAGNOSTIC_ASSERT(mRaw); + delete mRaw; + } + + StyleBox(const StyleBox& aOther) : StyleBox(MakeUnique<T>(*aOther)) {} + + StyleBox& operator=(const StyleBox& aOther) const { + delete mRaw; + mRaw = MakeUnique<T>(*aOther).release(); + return *this; + } + + const T* operator->() const { + MOZ_DIAGNOSTIC_ASSERT(mRaw); + return mRaw; + } + + const T& operator*() const { + MOZ_DIAGNOSTIC_ASSERT(mRaw); + return *mRaw; + } + + T* operator->() { + MOZ_DIAGNOSTIC_ASSERT(mRaw); + return mRaw; + } + + T& operator*() { + MOZ_DIAGNOSTIC_ASSERT(mRaw); + return *mRaw; + } + + bool operator==(const StyleBox& aOther) const { return *(*this) == *aOther; } + + bool operator!=(const StyleBox& aOther) const { return *(*this) != *aOther; } + + private: + T* mRaw; +}; + +// Work-around weird cbindgen renaming / avoiding moving stuff outside its +// namespace. + +using StyleImageTracker = dom::ImageTracker; +using StyleLoader = css::Loader; +using StyleLoaderReusableStyleSheets = css::LoaderReusableStyleSheets; +using StyleCallerType = dom::CallerType; +using StyleSheetParsingMode = css::SheetParsingMode; +using StyleSheetLoadData = css::SheetLoadData; +using StyleSheetLoadDataHolder = css::SheetLoadDataHolder; +using StyleGeckoMallocSizeOf = MallocSizeOf; +using StyleDomStyleSheet = StyleSheet; + +using StyleRawGeckoNode = nsINode; +using StyleRawGeckoElement = dom::Element; +using StyleDocument = dom::Document; +using StyleComputedValues = ComputedStyle; +using StyleIterationCompositeOperation = dom::IterationCompositeOperation; + +using StyleMatrixTransformOperator = + nsStyleTransformMatrix::MatrixTransformOperator; + +# define SERVO_LOCKED_ARC_TYPE(name_) struct StyleLocked##type_; +# include "mozilla/ServoLockedArcTypeList.h" +# undef SERVO_LOCKED_ARC_TYPE + +# define SERVO_BOXED_TYPE(name_, type_) struct Style##type_; +# include "mozilla/ServoBoxedTypeList.h" +# undef SERVO_BOXED_TYPE + +using StyleAtomicUsize = std::atomic<size_t>; + +# define SERVO_FIXED_POINT_HELPERS(T, RawT, FractionBits) \ + static constexpr RawT kPointFive = 1 << (FractionBits - 1); \ + static constexpr uint16_t kScale = 1 << FractionBits; \ + static constexpr float kInverseScale = 1.0f / kScale; \ + static T FromRaw(RawT aRaw) { return {{aRaw}}; } \ + static T FromFloat(float aFloat) { \ + return FromRaw(RawT(aFloat * kScale)); \ + } \ + static T FromInt(RawT aInt) { return FromRaw(RawT(aInt * kScale)); } \ + RawT Raw() const { return _0.value; } \ + uint16_t UnsignedRaw() const { return uint16_t(Raw()); } \ + float ToFloat() const { return Raw() * kInverseScale; } \ + RawT ToIntRounded() const { return (Raw() + kPointFive) >> FractionBits; } \ + bool IsNormal() const { return *this == NORMAL; } \ + inline void ToString(nsACString&) const; + +} // namespace mozilla + +# ifndef HAVE_64BIT_BUILD +static_assert(sizeof(void*) == 4, ""); +# define SERVO_32_BITS 1 +# endif +# define CBINDGEN_IS_GECKO + +#endif |