Bug 1382017 part 4 Gecko piece - Rename ServoComputedValues -> ServoComputedData; r=heycam
authorManish Goregaokar <manishearth@gmail.com>
Thu, 20 Jul 2017 21:44:02 -0700
changeset 418962 cea58fa7bd2254ba70c05f382dc090600a1675f4
parent 418961 959eb43f301e89def3b535659f60ec6e2b3ba451
child 418963 792565abca9edb164dde13096cde4cf34717a0cb
push id7566
push usermtabara@mozilla.com
push dateWed, 02 Aug 2017 08:25:16 +0000
treeherdermozilla-beta@86913f512c3c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersheycam
bugs1382017
milestone56.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1382017 part 4 Gecko piece - Rename ServoComputedValues -> ServoComputedData; r=heycam ServoComputedValues is confusing because ComputedValues is actually ServoStyleContext on the C++ side. MozReview-Commit-ID: IQNVdfREAMt
dom/canvas/CanvasRenderingContext2D.cpp
layout/base/ServoRestyleManager.cpp
layout/style/ServoBindingList.h
layout/style/ServoBindingTypes.h
layout/style/ServoBindings.cpp
layout/style/ServoBindings.h
layout/style/ServoBindings.toml
layout/style/ServoStyleContext.cpp
layout/style/ServoStyleContext.h
layout/style/ServoStyleContextInlines.h
layout/style/ServoStyleSet.cpp
layout/style/ServoTypes.h
layout/style/nsAnimationManager.cpp
layout/style/nsAnimationManager.h
layout/style/nsStyleContext.cpp
layout/style/nsStyleContext.h
layout/style/nsStyleContextInlines.h
layout/style/nsTransitionManager.cpp
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -3048,17 +3048,17 @@ CanvasRenderingContext2D::ParseFilter(co
     ResolveFilterStyleForServo(aString,
                                parentStyle,
                                presShell,
                                aError);
   if (!computedValues) {
      return false;
   }
 
-  const nsStyleEffects* effects = computedValues->ComputedValues()->GetStyleEffects();
+  const nsStyleEffects* effects = computedValues->ComputedData()->GetStyleEffects();
   // XXX: This mFilters is a one shot object, we probably could avoid copying.
   aFilterChain = effects->mFilters;
   return true;
 }
 
 void
 CanvasRenderingContext2D::SetFilter(const nsAString& aFilter, ErrorResult& aError)
 {
@@ -3968,17 +3968,17 @@ CanvasRenderingContext2D::SetFontInterna
     computedValues = GetFontStyleForServo(mCanvasElement,
                                           aFont,
                                           presShell,
                                           usedFont,
                                           aError);
     if (!computedValues) {
       return false;
     }
-    fontStyle = computedValues->ComputedValues()->GetStyleFont();
+    fontStyle = computedValues->ComputedData()->GetStyleFont();
   } else {
     sc = GetFontStyleContext(mCanvasElement,
                              aFont,
                              presShell,
                              usedFont,
                              aError);
     if (!sc) {
       return false;
--- a/layout/base/ServoRestyleManager.cpp
+++ b/layout/base/ServoRestyleManager.cpp
@@ -600,17 +600,17 @@ ServoRestyleManager::ProcessPostTraversa
   ServoRestyleState& childrenRestyleState =
     thisFrameRestyleState ? *thisFrameRestyleState : aRestyleState;
 
   RefPtr<ServoStyleContext> newContext = nullptr;
   if (wasRestyled && oldStyleContext) {
     MOZ_ASSERT(styleFrame || displayContentsNode);
     RefPtr<ServoStyleContext> currentContext =
       aRestyleState.StyleSet().ResolveServoStyle(aElement, aRestyleBehavior);
-    MOZ_ASSERT(oldStyleContext->ComputedValues() != currentContext->ComputedValues());
+    MOZ_ASSERT(oldStyleContext->ComputedData() != currentContext->ComputedData());
 
     newContext = currentContext;
     newContext->UpdateWithElementState(aElement);
 
     newContext->ResolveSameStructsAs(oldStyleContext);
 
     // We want to walk all the continuations here, even the ones with different
     // styles.  In practice, the only reason we get continuations with different
--- a/layout/style/ServoBindingList.h
+++ b/layout/style/ServoBindingList.h
@@ -469,18 +469,18 @@ SERVO_BINDING_FUNC(Servo_ComputedValues_
 SERVO_BINDING_FUNC(Servo_ComputedValues_Inherit, ServoStyleContextStrong,
                    RawServoStyleSetBorrowed set,
                    nsIAtom* pseudo_tag,
                    ServoStyleContextBorrowedOrNull parent_style,
                    mozilla::InheritTarget target)
 SERVO_BINDING_FUNC(Servo_ComputedValues_GetStyleBits, uint64_t,
                    ServoStyleContextBorrowed values)
 SERVO_BINDING_FUNC(Servo_ComputedValues_EqualCustomProperties, bool,
-                   ServoComputedValuesBorrowed first,
-                   ServoComputedValuesBorrowed second)
+                   ServoComputedDataBorrowed first,
+                   ServoComputedDataBorrowed second)
 // Gets the source style rules for the computed values. This returns
 // the result via rules, which would include a list of unowned pointers
 // to RawServoStyleRule.
 SERVO_BINDING_FUNC(Servo_ComputedValues_GetStyleRuleList, void,
                    ServoStyleContextBorrowed values,
                    RawGeckoServoStyleRuleListBorrowedMut rules)
 
 // Initialize Servo components. Should be called exactly once at startup.
--- a/layout/style/ServoBindingTypes.h
+++ b/layout/style/ServoBindingTypes.h
@@ -102,17 +102,17 @@ typedef mozilla::dom::StyleChildrenItera
     type_* mPtr;                             \
     already_AddRefed<type_> Consume();       \
   };
 #include "mozilla/ServoArcTypeList.h"
 #undef SERVO_ARC_TYPE
 
 typedef mozilla::ServoStyleContext const* ServoStyleContextBorrowed;
 typedef mozilla::ServoStyleContext const* ServoStyleContextBorrowedOrNull;
-typedef ServoComputedValues const* ServoComputedValuesBorrowed;
+typedef ServoComputedData const* ServoComputedDataBorrowed;
 
 struct MOZ_MUST_USE_TYPE ServoStyleContextStrong
 {
   mozilla::ServoStyleContext* mPtr;
   already_AddRefed<mozilla::ServoStyleContext> Consume();
 };
 
 #define DECL_OWNED_REF_TYPE_FOR(type_)    \
--- a/layout/style/ServoBindings.cpp
+++ b/layout/style/ServoBindings.cpp
@@ -208,37 +208,38 @@ Gecko_DestroyAnonymousContentList(nsTArr
   delete aAnonContent;
 }
 
 void
 Gecko_ServoStyleContext_Init(
     ServoStyleContext* aContext,
     const ServoStyleContext* aParentContext,
     RawGeckoPresContextBorrowed aPresContext,
-    const ServoComputedValues* aValues,
+    const ServoComputedData* aValues,
     mozilla::CSSPseudoElementType aPseudoType,
     nsIAtom* aPseudoTag)
 {
   // because it is within an Arc it is unsafe for the Rust side to ever
   // carry around a mutable non opaque reference to the context, so we
   // cast it here.
   auto parent = const_cast<ServoStyleContext*>(aParentContext);
   auto presContext = const_cast<nsPresContext*>(aPresContext);
   new (KnownNotNull, aContext) ServoStyleContext(
       parent, presContext, aPseudoTag, aPseudoType,
-      ServoComputedValuesForgotten(aValues));
+      ServoComputedDataForgotten(aValues));
 }
 
-ServoComputedValues::ServoComputedValues(
-    const ServoComputedValuesForgotten aValue)
+ServoComputedData::ServoComputedData(
+    const ServoComputedDataForgotten aValue)
 {
   PodAssign(this, aValue.mPtr);
 }
 
-const nsStyleVariables* ServoComputedValues::GetStyleVariables() const
+const nsStyleVariables*
+ServoComputedData::GetStyleVariables() const
 {
   return Servo_GetEmptyVariables();
 }
 
 void
 Gecko_ServoStyleContext_Destroy(ServoStyleContext* aContext)
 {
   aContext->~ServoStyleContext();
@@ -393,18 +394,18 @@ Gecko_GetStyleContext(RawGeckoElementBor
 
 CSSPseudoElementType
 Gecko_GetImplementedPseudo(RawGeckoElementBorrowed aElement)
 {
   return aElement->GetPseudoElementType();
 }
 
 nsChangeHint
-Gecko_CalcStyleDifference(const ServoStyleContext* aOldStyle,
-                          const ServoStyleContext* aNewStyle,
+Gecko_CalcStyleDifference(ServoStyleContextBorrowed aOldStyle,
+                          ServoStyleContextBorrowed aNewStyle,
                           uint64_t aOldStyleBits,
                           bool* aAnyStyleChanged)
 {
   MOZ_ASSERT(aOldStyle);
   MOZ_ASSERT(aNewStyle);
 
   uint32_t relevantStructs = aOldStyleBits & NS_STYLE_INHERIT_MASK;
 
@@ -642,18 +643,18 @@ bool
 Gecko_StyleAnimationsEquals(RawGeckoStyleAnimationListBorrowed aA,
                             RawGeckoStyleAnimationListBorrowed aB)
 {
   return *aA == *aB;
 }
 
 void
 Gecko_UpdateAnimations(RawGeckoElementBorrowed aElement,
-                       ServoStyleContextBorrowedOrNull aOldComputedValues,
-                       ServoStyleContextBorrowedOrNull aComputedValues,
+                       ServoStyleContextBorrowedOrNull aOldComputedData,
+                       ServoStyleContextBorrowedOrNull aComputedData,
                        UpdateAnimationsTasks aTasks)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aElement);
 
   if (!aElement->IsInComposedDoc()) {
     return;
   }
@@ -664,40 +665,40 @@ Gecko_UpdateAnimations(RawGeckoElementBo
   }
 
   CSSPseudoElementType pseudoType =
     GetPseudoTypeFromElementForAnimation(aElement);
 
   if (aTasks & UpdateAnimationsTasks::CSSAnimations) {
     presContext->AnimationManager()->
       UpdateAnimations(const_cast<dom::Element*>(aElement), pseudoType,
-                       aComputedValues);
+                       aComputedData);
   }
 
-  // aComputedValues might be nullptr if the target element is now in a
+  // aComputedData might be nullptr if the target element is now in a
   // display:none subtree. We still call Gecko_UpdateAnimations in this case
   // because we need to stop CSS animations in the display:none subtree.
   // However, we don't need to update transitions since they are stopped by
   // RestyleManager::AnimationsWithDestroyedFrame so we just return early
   // here.
-  if (!aComputedValues) {
+  if (!aComputedData) {
     return;
   }
 
   if (aTasks & UpdateAnimationsTasks::CSSTransitions) {
-    MOZ_ASSERT(aOldComputedValues);
+    MOZ_ASSERT(aOldComputedData);
     presContext->TransitionManager()->
       UpdateTransitions(const_cast<dom::Element*>(aElement), pseudoType,
-                        aOldComputedValues,
-                        aComputedValues);
+                        aOldComputedData,
+                        aComputedData);
   }
 
   if (aTasks & UpdateAnimationsTasks::EffectProperties) {
     presContext->EffectCompositor()->UpdateEffectProperties(
-      aComputedValues, const_cast<dom::Element*>(aElement), pseudoType);
+      aComputedData, const_cast<dom::Element*>(aElement), pseudoType);
   }
 
   if (aTasks & UpdateAnimationsTasks::CascadeResults) {
     // This task will be scheduled if we detected any changes to !important
     // rules. We post a restyle here so that we can update the cascade
     // results in the pre-traversal of the next restyle.
     presContext->EffectCompositor()
                ->RequestRestyle(const_cast<Element*>(aElement),
--- a/layout/style/ServoBindings.h
+++ b/layout/style/ServoBindings.h
@@ -70,17 +70,17 @@ class nsXBLBinding;
 
 namespace mozilla {
   #define STYLE_STRUCT(name_, checkdata_cb_) struct Gecko##name_ {nsStyle##name_ gecko;};
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT
 }
 
 #define STYLE_STRUCT(name_, checkdata_cb_) \
-  const nsStyle##name_* ServoComputedValues::GetStyle##name_() const { return &name_.mPtr->gecko; }
+  const nsStyle##name_* ServoComputedData::GetStyle##name_() const { return &name_.mPtr->gecko; }
 #define STYLE_STRUCT_LIST_IGNORE_VARIABLES
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES
 
 #define NS_DECL_THREADSAFE_FFI_REFCOUNTING(class_, name_)                     \
   void Gecko_AddRef##name_##ArbitraryThread(class_* aPtr);                    \
   void Gecko_Release##name_##ArbitraryThread(class_* aPtr);
@@ -145,17 +145,17 @@ bool Gecko_IsSignificantChild(RawGeckoNo
 RawGeckoNodeBorrowedOrNull Gecko_GetLastChild(RawGeckoNodeBorrowed node);
 RawGeckoNodeBorrowedOrNull Gecko_GetFlattenedTreeParentNode(RawGeckoNodeBorrowed node);
 RawGeckoElementBorrowedOrNull Gecko_GetBeforeOrAfterPseudo(RawGeckoElementBorrowed element, bool is_before);
 nsTArray<nsIContent*>* Gecko_GetAnonymousContentForElement(RawGeckoElementBorrowed element);
 void Gecko_DestroyAnonymousContentList(nsTArray<nsIContent*>* anon_content);
 
 void Gecko_ServoStyleContext_Init(mozilla::ServoStyleContext* context,
                                   ServoStyleContextBorrowedOrNull parent_context,
-                                  RawGeckoPresContextBorrowed pres_context, ServoComputedValuesBorrowed values,
+                                  RawGeckoPresContextBorrowed pres_context, ServoComputedDataBorrowed values,
                                   mozilla::CSSPseudoElementType pseudo_type, nsIAtom* pseudo_tag);
 void Gecko_ServoStyleContext_Destroy(mozilla::ServoStyleContext* context);
 
 // By default, Servo walks the DOM by traversing the siblings of the DOM-view
 // first child. This generally works, but misses anonymous children, which we
 // want to traverse during styling. To support these cases, we create an
 // optional stack-allocated iterator in aIterator for nodes that need it.
 void Gecko_ConstructStyleChildrenIterator(RawGeckoElementBorrowed aElement,
@@ -373,18 +373,18 @@ void Gecko_UnsetNodeFlags(RawGeckoNodeBo
 void Gecko_SetOwnerDocumentNeedsStyleFlush(RawGeckoElementBorrowed element);
 
 // Incremental restyle.
 // Also, we might want a ComputedValues to ComputedValues API for animations?
 // Not if we do them in Gecko...
 nsStyleContext* Gecko_GetStyleContext(RawGeckoElementBorrowed element,
                                       nsIAtom* aPseudoTagOrNull);
 mozilla::CSSPseudoElementType Gecko_GetImplementedPseudo(RawGeckoElementBorrowed element);
-nsChangeHint Gecko_CalcStyleDifference(const mozilla::ServoStyleContext* old_style,
-                                       const mozilla::ServoStyleContext* new_style,
+nsChangeHint Gecko_CalcStyleDifference(ServoStyleContextBorrowed old_style,
+                                       ServoStyleContextBorrowed new_style,
                                        uint64_t old_style_bits,
                                        bool* any_style_changed);
 nsChangeHint Gecko_HintsHandledForDescendants(nsChangeHint aHint);
 
 // Get an element snapshot for a given element from the table.
 const ServoElementSnapshot*
 Gecko_GetElementSnapshot(const mozilla::ServoElementSnapshotTable* table,
                          RawGeckoElementBorrowed element);
--- a/layout/style/ServoBindings.toml
+++ b/layout/style/ServoBindings.toml
@@ -242,18 +242,18 @@ whitelist-types = [
     "nsStyleXUL",
     "nsTArray",
     "nsTArrayHeader",
     "Position",
     "PropertyValuePair",
     "Runnable",
     "ServoAttrSnapshot",
     "ServoBundledURI",
-    "ServoComputedValues",
-    "ServoComputedValuesBorrowed",
+    "ServoComputedData",
+    "ServoComputedDataBorrowed",
     "ServoElementSnapshot",
     "ServoStyleContextStrong",
     "ServoStyleContextBorrowed",
     "ServoStyleContextBorrowedOrNull",
     "SheetParsingMode",
     "StaticRefPtr",
     "StyleAnimation",
     "StyleBasicShape",
@@ -341,17 +341,17 @@ hide-types = [
 raw-lines = [
     "pub use nsstring::{nsACString, nsAString, nsString, nsStringRepr};",
     "use gecko_bindings::structs::nsStyleTransformMatrix;",
     "use gecko_bindings::structs::nsTArray;",
     "type nsACString_internal = nsACString;",
     "type nsAString_internal = nsAString;",
     "pub type ServoStyleContextBorrowed<'a> = &'a ::properties::ComputedValues;",
     "pub type ServoStyleContextBorrowedOrNull<'a> = Option<&'a ::properties::ComputedValues>;",
-    "pub type ServoComputedValuesBorrowed<'a> = &'a ServoComputedValues;",
+    "pub type ServoComputedDataBorrowed<'a> = &'a ServoComputedData;",
 ]
 whitelist-functions = ["Servo_.*", "Gecko_.*"]
 structs-types = [
     "mozilla::css::GridTemplateAreasValue",
     "mozilla::css::ErrorReporter",
     "mozilla::css::ImageValue",
     "mozilla::css::URLValue",
     "mozilla::css::URLValueData",
@@ -469,17 +469,17 @@ structs-types = [
     "nsStyleXUL",
     "nsTimingFunction",
     "nscolor",
     "nscoord",
     "nsresult",
     "Loader",
     "LoaderReusableStyleSheets",
     "ServoStyleSheet",
-    "ServoComputedValues",
+    "ServoComputedData",
     "ServoStyleContext",
     "ServoStyleContextStrong",
     "EffectCompositor_CascadeLevel",
     "UpdateAnimationsTasks",
     "ParsingMode",
     "InheritTarget",
     "URLMatchingFunction",
     "StyleRuleInclusion",
--- a/layout/style/ServoStyleContext.cpp
+++ b/layout/style/ServoStyleContext.cpp
@@ -15,27 +15,27 @@
 
 namespace mozilla {
 
 ServoStyleContext::ServoStyleContext(
     nsStyleContext* aParent,
     nsPresContext* aPresContext,
     nsIAtom* aPseudoTag,
     CSSPseudoElementType aPseudoType,
-    ServoComputedValuesForgotten aComputedValues)
+    ServoComputedDataForgotten aComputedValues)
   : nsStyleContext(aParent, aPseudoTag, aPseudoType)
   , mSource(aComputedValues)
 {
   mPresContext = aPresContext;
   AddStyleBit(Servo_ComputedValues_GetStyleBits(this));
 
   FinishConstruction();
 
   // No need to call ApplyStyleFixups here, since fixups are handled by Servo when
-  // producing the ServoComputedValues.
+  // producing the ServoComputedData.
 }
 
 void
 ServoStyleContext::UpdateWithElementState(Element* aElementForAnimation)
 {
   bool isLink = false;
   bool isVisitedLink = false;
   // If we need visited styles for callers where `aElementForAnimation` is null,
--- a/layout/style/ServoStyleContext.h
+++ b/layout/style/ServoStyleContext.h
@@ -17,39 +17,39 @@ class Element;
 
 class ServoStyleContext final : public nsStyleContext
 {
 public:
   ServoStyleContext(nsStyleContext* aParent,
                     nsPresContext* aPresContext,
                     nsIAtom* aPseudoTag,
                     CSSPseudoElementType aPseudoType,
-                    ServoComputedValuesForgotten aComputedValues);
+                    ServoComputedDataForgotten aComputedValues);
 
   nsPresContext* PresContext() const { return mPresContext; }
-  const ServoComputedValues* ComputedValues() const { return &mSource; }
+  const ServoComputedData* ComputedData() const { return &mSource; }
 
   void AddRef() { Servo_StyleContext_AddRef(this); }
   void Release() { Servo_StyleContext_Release(this); }
 
   ServoStyleContext* GetStyleIfVisited() const
   {
-    return ComputedValues()->visited_style.mPtr;
+    return ComputedData()->visited_style.mPtr;
   }
 
   // Update visited state for a given element, and set the prescontext's
   // body text color if applicable.
   void UpdateWithElementState(dom::Element* aElement);
 
   /**
    * Makes this context match |aOther| in terms of which style structs have
    * been resolved.
    */
   inline void ResolveSameStructsAs(const ServoStyleContext* aOther);
 
 private:
   nsPresContext* mPresContext;
-  ServoComputedValues mSource;
+  ServoComputedData mSource;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_ServoStyleContext_h
--- a/layout/style/ServoStyleContextInlines.h
+++ b/layout/style/ServoStyleContextInlines.h
@@ -19,17 +19,17 @@ ServoStyleContext::ResolveSameStructsAs(
 {
   // Only resolve structs that are not already resolved in this struct.
   uint64_t ourBits = mBits & NS_STYLE_INHERIT_MASK;
   uint64_t otherBits = aOther->mBits & NS_STYLE_INHERIT_MASK;
   uint64_t newBits = otherBits & ~ourBits & NS_STYLE_INHERIT_MASK;
 
 #define STYLE_STRUCT(name_, checkdata_cb)                                           \
   if (nsStyle##name_::kHasFinishStyle && newBits & NS_STYLE_INHERIT_BIT(name_)) {   \
-    const nsStyle##name_* data = ComputedValues()->GetStyle##name_();               \
+    const nsStyle##name_* data = ComputedData()->GetStyle##name_();               \
     const_cast<nsStyle##name_*>(data)->FinishStyle(mPresContext);                   \
   }
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 
   mBits |= newBits;
 }
 
--- a/layout/style/ServoStyleSet.cpp
+++ b/layout/style/ServoStyleSet.cpp
@@ -777,18 +777,18 @@ ServoStyleSet::ProbePseudoElementStyle(E
   }
 
   // For :before and :after pseudo-elements, having display: none or no
   // 'content' property is equivalent to not having the pseudo-element
   // at all.
   bool isBeforeOrAfter = aType == CSSPseudoElementType::before ||
                          aType == CSSPseudoElementType::after;
   if (isBeforeOrAfter) {
-    const nsStyleDisplay* display = computedValues->ComputedValues()->GetStyleDisplay();
-    const nsStyleContent* content = computedValues->ComputedValues()->GetStyleContent();
+    const nsStyleDisplay* display = computedValues->ComputedData()->GetStyleDisplay();
+    const nsStyleContent* content = computedValues->ComputedData()->GetStyleContent();
     // XXXldb What is contentCount for |content: ""|?
     if (display->mDisplay == StyleDisplay::None ||
         content->ContentCount() == 0) {
       return nullptr;
     }
   }
 
   computedValues->UpdateWithElementState(isBeforeOrAfter ? aOriginatingElement : nullptr);
--- a/layout/style/ServoTypes.h
+++ b/layout/style/ServoTypes.h
@@ -171,17 +171,17 @@ struct ServoRuleNode {
   uintptr_t mPtr;
 };
 
 
 class ServoStyleContext;
 
 struct ServoVisitedStyle {
   // This is actually a strong reference
-  // but ServoComputedValues' destructor is
+  // but ServoComputedData's destructor is
   // managed by the Rust code so we just use a
   // regular pointer
   ServoStyleContext* mPtr;
 };
 
 template <typename T>
 struct ServoRawOffsetArc {
   // Again, a strong reference, but
@@ -196,38 +196,38 @@ struct ServoComputedValueFlags {
 #define STYLE_STRUCT(name_, checkdata_cb_) struct Gecko##name_;
 #define STYLE_STRUCT_LIST_IGNORE_VARIABLES
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES
 
 } // namespace mozilla
 
-class ServoComputedValues;
+class ServoComputedData;
 
-struct ServoComputedValuesForgotten
+struct ServoComputedDataForgotten
 {
-  // Make sure you manually mem::forget the backing ServoComputedValues
+  // Make sure you manually mem::forget the backing ServoComputedData
   // after calling this
-  explicit ServoComputedValuesForgotten(const ServoComputedValues* aValue) : mPtr(aValue) {}
-  const ServoComputedValues* mPtr;
+  explicit ServoComputedDataForgotten(const ServoComputedData* aValue) : mPtr(aValue) {}
+  const ServoComputedData* mPtr;
 };
 
 /**
  * We want C++ to be able to read the style struct fields of ComputedValues
  * so we define this type on the C++ side and use the bindgenned version
  * on the Rust side.
  */
-class ServoComputedValues
+class ServoComputedData
 {
   friend class mozilla::ServoStyleContext;
 
 public:
   // Constructs via memcpy.  Will not move out of aValue.
-  explicit ServoComputedValues(const ServoComputedValuesForgotten aValue);
+  explicit ServoComputedData(const ServoComputedDataForgotten aValue);
 
 #define STYLE_STRUCT(name_, checkdata_cb_)                 \
   mozilla::ServoRawOffsetArc<mozilla::Gecko##name_> name_; \
   inline const nsStyle##name_* GetStyle##name_() const;
   #define STYLE_STRUCT_LIST_IGNORE_VARIABLES
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
 #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES
@@ -256,15 +256,15 @@ private:
 
   // C++ just sees this struct as a bucket of bits, and will
   // do the wrong thing if we let it use the default copy ctor/assignment
   // operator. Remove them so that there is no footgun.
   //
   // We remove the move ctor/assignment operator as well, because
   // moves in C++ don't prevent destructors from being called,
   // which will lead to double frees.
-  ServoComputedValues& operator=(const ServoComputedValues&) = delete;
-  ServoComputedValues(const ServoComputedValues&) = delete;
-  ServoComputedValues&& operator=(const ServoComputedValues&&) = delete;
-  ServoComputedValues(const ServoComputedValues&&) = delete;
+  ServoComputedData& operator=(const ServoComputedData&) = delete;
+  ServoComputedData(const ServoComputedData&) = delete;
+  ServoComputedData&& operator=(const ServoComputedData&&) = delete;
+  ServoComputedData(const ServoComputedData&&) = delete;
 };
 
 #endif // mozilla_ServoTypes_h
--- a/layout/style/nsAnimationManager.cpp
+++ b/layout/style/nsAnimationManager.cpp
@@ -1030,17 +1030,17 @@ nsAnimationManager::UpdateAnimations(
     StopAnimationsForElement(aElement, aPseudoType);
     return;
   }
 
   NonOwningAnimationTarget target(aElement, aPseudoType);
   ServoCSSAnimationBuilder builder(aStyleContext);
 
   const nsStyleDisplay *disp =
-      aStyleContext->ComputedValues()->GetStyleDisplay();
+      aStyleContext->ComputedData()->GetStyleDisplay();
   DoUpdateAnimations(target, *disp, builder);
 }
 
 template<class BuilderType>
 void
 nsAnimationManager::DoUpdateAnimations(
   const NonOwningAnimationTarget& aTarget,
   const nsStyleDisplay& aStyleDisplay,
--- a/layout/style/nsAnimationManager.h
+++ b/layout/style/nsAnimationManager.h
@@ -12,17 +12,17 @@
 #include "mozilla/dom/Animation.h"
 #include "mozilla/Keyframe.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/TimeStamp.h"
 #include "nsRFPService.h"
 
 class nsIGlobalObject;
 class nsStyleContext;
-class ServoComputedValues;
+class ServoComputedData;
 struct nsStyleDisplay;
 
 namespace mozilla {
 namespace css {
 class Declaration;
 } /* namespace css */
 namespace dom {
 class KeyframeEffectReadOnly;
--- a/layout/style/nsStyleContext.cpp
+++ b/layout/style/nsStyleContext.cpp
@@ -111,17 +111,17 @@ nsStyleContext::FinishConstruction()
   // more natural way it wouldn't fail even when it needed to.
   static_assert((UINT64_MAX >> NS_STYLE_CONTEXT_TYPE_SHIFT) >=
                  static_cast<CSSPseudoElementTypeBase>(
                    CSSPseudoElementType::MAX),
                 "pseudo element bits no longer fit in a uint64_t");
 
 #ifdef DEBUG
   if (auto servo = GetAsServo()) {
-    MOZ_ASSERT(servo->ComputedValues());
+    MOZ_ASSERT(servo->ComputedData());
   } else {
     MOZ_ASSERT(RuleNode());
   }
 
   static_assert(MOZ_ARRAY_LENGTH(nsStyleContext::sDependencyTable)
                   == nsStyleStructID_Length,
                 "Number of items in dependency table doesn't match IDs");
 #endif
@@ -229,18 +229,18 @@ nsStyleContext::CalcStyleDifference(nsSt
       if (thisVariables->mVariables == otherVariables->mVariables) {
         *aEqualStructs |= NS_STYLE_INHERIT_BIT(Variables);
       }
     } else {
       *aEqualStructs |= NS_STYLE_INHERIT_BIT(Variables);
     }
   } else {
     if (Servo_ComputedValues_EqualCustomProperties(
-          AsServo()->ComputedValues(),
-          aNewContext->ComputedValues())) {
+          AsServo()->ComputedData(),
+          aNewContext->ComputedData())) {
       *aEqualStructs |= NS_STYLE_INHERIT_BIT(Variables);
     }
   }
 
   DebugOnly<int> styleStructCount = 1;  // count Variables already
 
   // Servo's optimization to stop the cascade when there are no style changes
   // that children need to be recascade for relies on comparing all of the
@@ -252,30 +252,30 @@ nsStyleContext::CalcStyleDifference(nsSt
   // For Gecko structs, we just defer to PeekStyleXXX.  But for Servo structs,
   // we need to use the aRelevantStructs bitfield passed in to determine
   // whether to return a struct or not, since this->mBits might not yet
   // be correct (due to not calling ResolveSameStructsAs on it yet).
 #define PEEK(struct_)                                                         \
   (IsGecko()                                                                  \
    ? PeekStyle##struct_()                                                     \
    : ((aRelevantStructs & NS_STYLE_INHERIT_BIT(struct_))                      \
-      ? AsServo()->ComputedValues()->GetStyle##struct_()                      \
+      ? AsServo()->ComputedData()->GetStyle##struct_()                      \
       : nullptr))
 
 #define EXPAND(...) __VA_ARGS__
 #define DO_STRUCT_DIFFERENCE_WITH_ARGS(struct_, extra_args_)                  \
   PR_BEGIN_MACRO                                                              \
     const nsStyle##struct_* this##struct_ = PEEK(struct_);                    \
     bool unrequestedStruct;                                                   \
     if (this##struct_) {                                                      \
       unrequestedStruct = false;                                              \
       structsFound |= NS_STYLE_INHERIT_BIT(struct_);                          \
     } else if (checkUnrequestedServoStructs) {                                \
       this##struct_ =                                                         \
-        AsServo()->ComputedValues()->GetStyle##struct_();                     \
+        AsServo()->ComputedData()->GetStyle##struct_();                     \
       unrequestedStruct = true;                                               \
     } else {                                                                  \
       unrequestedStruct = false;                                              \
     }                                                                         \
     if (this##struct_) {                                                      \
       const nsStyle##struct_* other##struct_ =                                \
         aNewContext->ThreadsafeStyle##struct_();                              \
       if (this##struct_ == other##struct_) {                                  \
@@ -482,17 +482,17 @@ void nsStyleContext::List(FILE* out, int
   if (mPseudoTag) {
     nsAutoString  buffer;
     mPseudoTag->ToString(buffer);
     AppendUTF16toUTF8(buffer, str);
     str.Append(' ');
   }
 
   if (IsServo()) {
-    fprintf_stderr(out, "%s{ServoComputedValues}\n", str.get());
+    fprintf_stderr(out, "%s{ServoComputedData}\n", str.get());
   } else if (nsRuleNode* ruleNode = AsGecko()->RuleNode()) {
     fprintf_stderr(out, "%s{\n", str.get());
     str.Truncate();
     while (ruleNode) {
       nsIStyleRule *styleRule = ruleNode->GetRule();
       if (styleRule) {
         styleRule->List(out, aIndent + 1);
       }
--- a/layout/style/nsStyleContext.h
+++ b/layout/style/nsStyleContext.h
@@ -207,17 +207,17 @@ public:
    * happen because it was inherited from the parent style context, or
    * because it was stored conditionally on the rule node.
    */
   bool HasCachedDependentStyleData(nsStyleStructID aSID) {
     return mBits & nsCachedStyleData::GetBitForSID(aSID);
   }
 
   inline nsRuleNode* RuleNode();
-  inline const ServoComputedValues* ComputedValues();
+  inline const ServoComputedData* ComputedData();
 
   void AddStyleBit(const uint64_t& aBit) { mBits |= aBit; }
 
   /**
    * Define typesafe getter functions for each style struct by
    * preprocessing the list of style structs.  These functions are the
    * preferred way to get style data.  The macro creates functions like:
    *   const nsStyleBorder* StyleBorder();
--- a/layout/style/nsStyleContextInlines.h
+++ b/layout/style/nsStyleContextInlines.h
@@ -26,21 +26,21 @@ MOZ_DEFINE_STYLO_METHODS(nsStyleContext,
 
 nsRuleNode*
 nsStyleContext::RuleNode()
 {
     MOZ_RELEASE_ASSERT(IsGecko());
     return AsGecko()->RuleNode();
 }
 
-const ServoComputedValues*
-nsStyleContext::ComputedValues()
+const ServoComputedData*
+nsStyleContext::ComputedData()
 {
     MOZ_RELEASE_ASSERT(IsServo());
-    return AsServo()->ComputedValues();
+    return AsServo()->ComputedData();
 }
 
 void
 nsStyleContext::AddRef()
 {
   MOZ_STYLO_FORWARD(AddRef, ())
 }
 
@@ -53,17 +53,17 @@ nsStyleContext::Release()
 #define STYLE_STRUCT(name_, checkdata_cb_)                      \
 const nsStyle##name_ *                                          \
 nsStyleContext::Style##name_() {                                \
   return DoGetStyle##name_<true>();                             \
 }                                                               \
 const nsStyle##name_ *                                          \
 nsStyleContext::ThreadsafeStyle##name_() {                      \
   if (mozilla::ServoStyleSet::IsInServoTraversal()) {           \
-    return AsServo()->ComputedValues()->GetStyle##name_();      \
+    return AsServo()->ComputedData()->GetStyle##name_();      \
   }                                                             \
   return Style##name_();                                        \
 }                                                               \
 const nsStyle##name_ * nsStyleContext::PeekStyle##name_() {     \
   return DoGetStyle##name_<false>();                            \
 }
 #include "nsStyleStructList.h"
 #undef STYLE_STRUCT
@@ -126,17 +126,17 @@ const nsStyle##name_ * nsStyleContext::D
   }                                                                 \
                                                                     \
   const bool needToCompute = !(mBits & NS_STYLE_INHERIT_BIT(name_));\
   if (!aComputeData && needToCompute) {                             \
     return nullptr;                                                 \
   }                                                                 \
                                                                     \
   const nsStyle##name_* data =                                      \
-    servo->ComputedValues()->GetStyle##name_();                     \
+    servo->ComputedData()->GetStyle##name_();                     \
   /* perform any remaining main thread work on the struct */        \
   if (needToCompute) {                                              \
     MOZ_ASSERT(NS_IsMainThread());                                  \
     MOZ_ASSERT(!mozilla::ServoStyleSet::IsInServoTraversal());      \
     const_cast<nsStyle##name_*>(data)->FinishStyle(PresContext());  \
     /* the ServoStyleContext owns the struct */                     \
     AddStyleBit(NS_STYLE_INHERIT_BIT(name_));                       \
   }                                                                 \
@@ -159,17 +159,17 @@ const nsStyle##name_ * nsStyleContext::D
     return gecko->RuleNode()->GetStyle##name_<aComputeData>(this->AsGecko()); \
   }                                                                           \
   auto servo = AsServo();                                                     \
   const bool needToCompute = !(mBits & NS_STYLE_INHERIT_BIT(name_));          \
   if (!aComputeData && needToCompute) {                                       \
     return nullptr;                                                           \
   }                                                                           \
   const nsStyle##name_* data =                                                \
-    servo->ComputedValues()->GetStyle##name_();                               \
+    servo->ComputedData()->GetStyle##name_();                               \
   /* perform any remaining main thread work on the struct */                  \
   if (needToCompute) {                                                        \
     const_cast<nsStyle##name_*>(data)->FinishStyle(PresContext());            \
     /* the ServoStyleContext owns the struct */                               \
     AddStyleBit(NS_STYLE_INHERIT_BIT(name_));                                 \
   }                                                                           \
   return data;                                                                \
 }
--- a/layout/style/nsTransitionManager.cpp
+++ b/layout/style/nsTransitionManager.cpp
@@ -630,17 +630,17 @@ nsTransitionManager::UpdateTransitions(
   if (!mPresContext->IsDynamic()) {
     // For print or print preview, ignore transitions.
     return false;
   }
 
   CSSTransitionCollection* collection =
     CSSTransitionCollection::GetAnimationCollection(aElement, aPseudoType);
   const nsStyleDisplay *disp =
-      aNewStyle->ComputedValues()->GetStyleDisplay();
+      aNewStyle->ComputedData()->GetStyleDisplay();
   return DoUpdateTransitions(disp,
                              aElement, aPseudoType,
                              collection,
                              aOldStyle, aNewStyle);
 }
 
 template<typename StyleType>
 bool