style: Derive debug for CascadeInputs.

It no longer has anything than rules.

components/layout_thread/dom_wrapper.rs

@@ -860,6 +860,7 @@ impl<'ln> NodeInfo for ServoThreadSafeLayoutNode<'ln> {
 impl<'ln> ThreadSafeLayoutNode for ServoThreadSafeLayoutNode<'ln> {
     type ConcreteNode = ServoLayoutNode<'ln>;
     type ConcreteThreadSafeLayoutElement = ServoThreadSafeLayoutElement<'ln>;
+    type ConcreteElement = ServoLayoutElement<'ln>;
     type ChildrenIterator = ThreadSafeLayoutNodeChildrenIterator<Self>;
 
     fn opaque(&self) -> OpaqueNode {
@@ -1084,6 +1085,7 @@ pub struct ServoThreadSafeLayoutElement<'le> {
 
 impl<'le> ThreadSafeLayoutElement for ServoThreadSafeLayoutElement<'le> {
     type ConcreteThreadSafeLayoutNode = ServoThreadSafeLayoutNode<'le>;
+    type ConcreteElement = ServoLayoutElement<'le>;
 
     fn as_node(&self) -> ServoThreadSafeLayoutNode<'le> {
         ServoThreadSafeLayoutNode {

components/layout_thread/lib.rs

@@ -1491,8 +1491,11 @@ impl LayoutThread {
                         self.profiler_metadata(),
                         self.time_profiler_chan.clone(),
                         || {
-                            animation::recalc_style_for_animations(
+                            animation::recalc_style_for_animations::<ServoLayoutElement>(
-                                &layout_context, FlowRef::deref_mut(&mut root_flow), &animations)
+                                &layout_context,
+                                FlowRef::deref_mut(&mut root_flow),
+                                &animations,
+                            )
                         });
             }
             self.perform_post_style_recalc_layout_passes(&mut root_flow,
@@ -1522,14 +1525,16 @@ impl LayoutThread {
                 .as_mut()
                 .map(|nodes| &mut **nodes);
             // Kick off animations if any were triggered, expire completed ones.
-            animation::update_animation_state(&self.constellation_chan,
+            animation::update_animation_state::<ServoLayoutElement>(
-                                              &self.script_chan,
+                &self.constellation_chan,
-                                              &mut *self.running_animations.write(),
+                &self.script_chan,
-                                              &mut *self.expired_animations.write(),
+                &mut *self.running_animations.write(),
-                                              newly_transitioning_nodes,
+                &mut *self.expired_animations.write(),
-                                              &self.new_animations_receiver,
+                newly_transitioning_nodes,
-                                              self.id,
+                &self.new_animations_receiver,
-                                              &self.timer);
+                self.id,
+                &self.timer,
+            );
         }
 
         profile(time::ProfilerCategory::LayoutRestyleDamagePropagation,

components/script_layout_interface/wrapper_traits.rs

@@ -148,7 +148,7 @@ impl<ConcreteNode> Iterator for TreeIterator<ConcreteNode>
 /// node does not allow any parents or siblings of nodes to be accessed, to avoid races.
 pub trait ThreadSafeLayoutNode: Clone + Copy + Debug + GetLayoutData + NodeInfo + PartialEq + Sized {
     type ConcreteNode: LayoutNode<ConcreteThreadSafeLayoutNode = Self>;
-    type ConcreteElement: TElement = <Self::ConcreteNode as TNode>::ConcreteElement;
+    type ConcreteElement: TElement;
 
     type ConcreteThreadSafeLayoutElement:
         ThreadSafeLayoutElement<ConcreteThreadSafeLayoutNode = Self>
@@ -293,9 +293,11 @@ pub trait ThreadSafeLayoutElement
 {
     type ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode<ConcreteThreadSafeLayoutElement = Self>;
 
-    /// This type alias is just a hack to avoid writing the monstrosity after it
+    /// This type alias is just a work-around to avoid writing
-    /// twice.
+    ///
-    type ConcreteElement: TElement = <Self::ConcreteThreadSafeLayoutNode as ThreadSafeLayoutNode>::ConcreteElement;
+    ///   <Self::ConcreteThreadSafeLayoutNode as ThreadSafeLayoutNode>::ConcreteElement
+    ///
+    type ConcreteElement: TElement;
 
     fn as_node(&self) -> Self::ConcreteThreadSafeLayoutNode;
 

components/style/context.rs

@@ -203,7 +203,7 @@ impl<'a> SharedStyleContext<'a> {
 /// within the `CurrentElementInfo`. At the end of the cascade, they are folded
 /// down into the main `ComputedValues` to reduce memory usage per element while
 /// still remaining accessible.
-#[derive(Clone, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CascadeInputs {
     /// The rule node representing the ordered list of rules matched for this
     /// node.
@@ -226,15 +226,6 @@ impl CascadeInputs {
     }
 }
 
-// We manually implement Debug for CascadeInputs so that we can avoid the
-// verbose stringification of ComputedValues for normal logging.
-impl fmt::Debug for CascadeInputs {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "CascadeInputs {{ rules: {:?}, visited_rules: {:?}, .. }}",
-               self.rules, self.visited_rules)
-    }
-}
-
 /// A list of cascade inputs for eagerly-cascaded pseudo-elements.
 /// The list is stored inline.
 #[derive(Debug)]