Attachment #8822397 for bug #1298588

Attachment #8822397: part 10. Pass through useful default styles to apply_declarations() for bug #1298588

View | Details | Raw Unified | Return to bug 1298588
Collapse All | Expand All





SERVO_BINDING_FUNC(Servo_ParseProperty,
                   RawServoDeclarationBlockStrong,
                   const nsACString* property, const nsACString* value,
                   const nsACString* base_url, ThreadSafeURIHolder* base,
                   ThreadSafeURIHolder* referrer,
                   ThreadSafePrincipalHolder* principal)
SERVO_BINDING_FUNC(Servo_RestyleWithAddedDeclaration,
                   ServoComputedValuesStrong,
                   RawServoStyleSetBorrowed set,
                   RawServoDeclarationBlockBorrowed declarations,
                   ServoComputedValuesBorrowed previous_style)

// Style attribute
SERVO_BINDING_FUNC(Servo_ParseStyleAttribute, RawServoDeclarationBlockStrong,
                   const nsACString* data)
SERVO_BINDING_FUNC(Servo_DeclarationBlock_CreateEmpty,
                   RawServoDeclarationBlockStrong)





}
#endif

void
ServoStyleSet::RecomputeDefaultComputedStyles()
{
  Servo_StyleSet_RecomputeDefaultStyles(mRawSet.get(), mPresContext);
}

ServoComputedValuesStrong
ServoStyleSet::RestyleWithAddedDeclaration(RawServoDeclarationBlock* aDeclarations,
                                           const ServoComputedValues* aPreviousStyle)
{
  return Servo_RestyleWithAddedDeclaration(mRawSet.get(), aDeclarations,
                                           aPreviousStyle);
}






#endif

  /**
   * Recompute our default computed styles.  This will eagerly create a new set
   * of default computed style structs.
   */
  void RecomputeDefaultComputedStyles();

  /**
   * Restyle with added declaration, for use in animations.
   */
  ServoComputedValuesStrong RestyleWithAddedDeclaration(
    RawServoDeclarationBlock* aDeclarations,
    const ServoComputedValues* aPreviousStyle);
private:
  already_AddRefed<nsStyleContext> GetContext(already_AddRefed<ServoComputedValues>,
                                              nsStyleContext* aParentContext,
                                              nsIAtom* aPseudoTag,
                                              CSSPseudoElementType aPseudoType);

  already_AddRefed<nsStyleContext> GetContext(nsIContent* aContent,
                                              nsStyleContext* aParentContext,






  const ServoComputedValues* previousStyle =
    aStyleContext->StyleSource().AsServoComputedValues();

  // FIXME: Servo bindings don't yet represent const-ness so we just
  // cast it away for now.
  auto declarations = const_cast<RawServoDeclarationBlock*>(&aDeclarations);
  RefPtr<ServoComputedValues> computedValues =
    aStyleContext->PresContext()->StyleSet()->AsServo()->
      RestyleWithAddedDeclaration(declarations, previousStyle).Consume();
  if (!computedValues) {
    return false;
  }

  RefPtr<nsStyleContext> tmpStyleContext =
    NS_NewStyleContext(aStyleContext, aStyleContext->PresContext(),
                       aStyleContext->GetPseudo(),
                       aStyleContext->GetPseudoType(),





                guard.declarations.iter().rev().map(|&(ref decl, _importance)| decl)
            };

            let computed =
                properties::apply_declarations(context.viewport_size,
                                               /* is_root = */ false,
                                               iter,
                                               previous_style,
                                               &context.default_computed_values,
                                               /* cascade_info = */ None,
                                               context.error_reporter.clone(),
                                               /* Metrics provider */ None,
                                               CascadeFlags::empty());
            computed
        }
    }
}





                               value: *const nsACString_internal,
                               base_url: *const nsACString_internal,
                               base: *mut ThreadSafeURIHolder,
                               referrer: *mut ThreadSafeURIHolder,
                               principal: *mut ThreadSafePrincipalHolder)
     -> RawServoDeclarationBlockStrong;
}
extern "C" {
    pub fn Servo_RestyleWithAddedDeclaration(set: RawServoStyleSetBorrowed,
                                             declarations:
                                                 RawServoDeclarationBlockBorrowed,
                                             previous_style:
                                                 ServoComputedValuesBorrowed)
     -> ServoComputedValuesStrong;
}
extern "C" {
    pub fn Servo_ParseStyleAttribute(data: *const nsACString_internal)
     -> RawServoDeclarationBlockStrong;





                }
            })
        })
    };
    apply_declarations(viewport_size,
                       is_root_element,
                       iter_declarations,
                       inherited_style,
                       default_style,
                       cascade_info,
                       error_reporter,
                       None,
                       flags)
}

/// NOTE: This function expects the declaration with more priority to appear
/// first.
pub fn apply_declarations<'a, F, I>(viewport_size: Size2D<Au>,
                                    is_root_element: bool,
                                    iter_declarations: F,
                                    inherited_style: &ComputedValues,
                                    default_style: &Arc<ComputedValues>,
                                    mut cascade_info: Option<<&mut CascadeInfo>,
                                    mut error_reporter: StdBox<ParseErrorReporter + Send>,
                                    font_metrics_provider: Option<<&FontMetricsProvider>,
                                    flags: CascadeFlags)
                                    -> ComputedValues
    where F: Fn() -> I, I: Iterator<Item = &'a PropertyDeclaration>
{
    let inherited_custom_properties = inherited_style.custom_properties();

            _ => {}
        }
    }

    let custom_properties =
        ::custom_properties::finish_cascade(
            custom_properties, &inherited_custom_properties);

    let initial_values = ComputedValues::initial_values();

    let starting_style = if !flags.contains(INHERIT_ALL) {
        ComputedValues::new(custom_properties,
                            flags.contains(SHAREABLE),
                            WritingMode::empty(),
                            inherited_style.root_font_size(),
                            % for style_struct in data.active_style_structs():
                                % if style_struct.inherited:
                                    inherited_style.clone_${style_struct.name_lower}(),
                                % else:
                                    default_style.clone_${style_struct.name_lower}(),
                                % endif
                            % endfor
                            )
    } else {
        ComputedValues::new(custom_properties,
                            flags.contains(SHAREABLE),
                            WritingMode::empty(),
                            inherited_style.root_font_size(),





                                        behavior: structs::TraversalRootBehavior) -> () {
    let element = GeckoElement(root);
    debug!("Servo_TraverseSubtree: {:?}", element);
    traverse_subtree(element, raw_data,
                     behavior == structs::TraversalRootBehavior::UnstyledChildrenOnly);
}

#[no_mangle]
pub extern "C" fn Servo_RestyleWithAddedDeclaration(raw_data: RawServoStyleSetBorrowed,
                                                    declarations: RawServoDeclarationBlockBorrowed,
                                                    previous_style: ServoComputedValuesBorrowed)
  -> ServoComputedValuesStrong
{
    let previous_style = ComputedValues::as_arc(&previous_style);
    let declarations = RwLock::<PropertyDeclarationBlock>::as_arc(&declarations);

    let guard = declarations.read();

    let declarations = || {
        guard.declarations.iter().rev().map(|&(ref decl, _importance)| decl)
    };

    let data = PerDocumentStyleData::from_ffi(raw_data).borrow();

    // FIXME (bug 1303229): Use the actual viewport size here
    let computed = apply_declarations(Size2D::new(Au(0), Au(0)),
                                      /* is_root_element = */ false,
                                      declarations,
                                      previous_style,
                                      &data.default_computed_values,
                                      None,
                                      Box::new(StdoutErrorReporter),
                                      None,
                                      CascadeFlags::empty());
    Arc::new(computed).into_strong()
}

#[no_mangle]

Return to bug 1298588