From 07250a7d586744227233c3cc26af4e73bd53b18f Mon Sep 17 00:00:00 2001 From: Pu Xingyu Date: Sun, 11 Dec 2016 04:13:08 +0800 Subject: [PATCH] Remove unused replaced size calculation methods Remove some fields and methods from SpecificFragmentInfo and change some function signatures. --- components/layout/block.rs | 6 +- components/layout/construct.rs | 13 +- components/layout/fragment.rs | 281 +-------------------------------- components/layout/inline.rs | 4 +- components/layout/list_item.rs | 4 +- 5 files changed, 15 insertions(+), 293 deletions(-) diff --git a/components/layout/block.rs b/components/layout/block.rs index 45de87867781..9f1ffb5094e6 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -1271,7 +1271,7 @@ impl BlockFlow { // Calculate used value of block-size just like we do for inline replaced elements. // TODO: Pass in the containing block block-size when Fragment's // assign-block-size can handle it correctly. - self.fragment.assign_replaced_block_size_if_necessary(Some(containing_block_block_size)); + self.fragment.assign_replaced_block_size_if_necessary(); // TODO: Right now, this content block-size value includes the // margin because of erroneous block-size calculation in fragment. // Check this when that has been fixed. @@ -1901,9 +1901,7 @@ impl Flow for BlockFlow { self.base.debug_id()); // Assign block-size for fragment if it is an image fragment. - let containing_block_block_size = - self.base.block_container_explicit_block_size; - self.fragment.assign_replaced_block_size_if_necessary(containing_block_block_size); + self.fragment.assign_replaced_block_size_if_necessary(); if !self.base.flags.contains(IS_ABSOLUTELY_POSITIONED) { self.base.position.size.block = self.fragment.border_box.size.block; self.base.restyle_damage.remove(REFLOW_OUT_OF_FLOW | REFLOW); diff --git a/components/layout/construct.rs b/components/layout/construct.rs index f3309b97b757..b25923d19c21 100644 --- a/components/layout/construct.rs +++ b/components/layout/construct.rs @@ -346,14 +346,12 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode> SpecificFragmentInfo::Iframe(IframeFragmentInfo::new(node)) } Some(LayoutNodeType::Element(LayoutElementType::HTMLImageElement)) => { - let image_info = box ImageFragmentInfo::new(node, - node.image_url(), + let image_info = box ImageFragmentInfo::new(node.image_url(), &self.layout_context.shared); SpecificFragmentInfo::Image(image_info) } Some(LayoutNodeType::Element(LayoutElementType::HTMLObjectElement)) => { - let image_info = box ImageFragmentInfo::new(node, - node.object_data(), + let image_info = box ImageFragmentInfo::new(node.object_data(), &self.layout_context.shared); SpecificFragmentInfo::Image(image_info) } @@ -372,11 +370,11 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode> } Some(LayoutNodeType::Element(LayoutElementType::HTMLCanvasElement)) => { let data = node.canvas_data().unwrap(); - SpecificFragmentInfo::Canvas(box CanvasFragmentInfo::new(node, data, self.style_context())) + SpecificFragmentInfo::Canvas(box CanvasFragmentInfo::new(data)) } Some(LayoutNodeType::Element(LayoutElementType::SVGSVGElement)) => { let data = node.svg_data().unwrap(); - SpecificFragmentInfo::Svg(box SvgFragmentInfo::new(node, data, self.style_context())) + SpecificFragmentInfo::Svg(box SvgFragmentInfo::new(data)) } _ => { // This includes pseudo-elements. @@ -1207,8 +1205,7 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode> let flotation = FloatKind::from_property(flotation); let marker_fragments = match node.style(self.style_context()).get_list().list_style_image { Either::First(ref url_value) => { - let image_info = box ImageFragmentInfo::new(node, - url_value.url().map(|u| u.clone()), + let image_info = box ImageFragmentInfo::new(url_value.url().map(|u| u.clone()), &self.layout_context.shared); vec![Fragment::new(node, SpecificFragmentInfo::Image(image_info), self.layout_context)] } diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index 308f709f0fd8..cfa6c6824b2d 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -44,7 +44,6 @@ use style::computed_values::{border_collapse, box_sizing, clear, color, display, use style::computed_values::{overflow_wrap, overflow_x, position, text_decoration}; use style::computed_values::{transform_style, vertical_align, white_space, word_break, z_index}; use style::computed_values::content::ContentItem; -use style::context::SharedStyleContext; use style::logical_geometry::{Direction, LogicalMargin, LogicalRect, LogicalSize, WritingMode}; use style::properties::ServoComputedValues; use style::selector_parser::RestyleDamage; @@ -52,7 +51,6 @@ use style::servo::restyle_damage::RECONSTRUCT_FLOW; use style::str::char_is_whitespace; use style::values::Either; use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto}; -use style::values::computed::LengthOrPercentageOrNone; use text; use text::TextRunScanner; @@ -331,89 +329,41 @@ impl InlineAbsoluteFragmentInfo { #[derive(Clone)] pub struct CanvasFragmentInfo { - pub replaced_image_fragment_info: ReplacedImageFragmentInfo, pub ipc_renderer: Option>>>, pub dom_width: Au, pub dom_height: Au, } impl CanvasFragmentInfo { - pub fn new(node: &N, - data: HTMLCanvasData, - ctx: &SharedStyleContext) - -> CanvasFragmentInfo { + pub fn new(data: HTMLCanvasData) -> CanvasFragmentInfo { CanvasFragmentInfo { - replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node, ctx), ipc_renderer: data.ipc_renderer .map(|renderer| Arc::new(Mutex::new(renderer))), dom_width: Au::from_px(data.width as i32), dom_height: Au::from_px(data.height as i32), } } - - /// Returns the original inline-size of the canvas. - pub fn canvas_inline_size(&self) -> Au { - if self.replaced_image_fragment_info.writing_mode_is_vertical { - self.dom_height - } else { - self.dom_width - } - } - - /// Returns the original block-size of the canvas. - pub fn canvas_block_size(&self) -> Au { - if self.replaced_image_fragment_info.writing_mode_is_vertical { - self.dom_width - } else { - self.dom_height - } - } } #[derive(Clone)] pub struct SvgFragmentInfo { - pub replaced_image_fragment_info: ReplacedImageFragmentInfo, pub dom_width: Au, pub dom_height: Au, } impl SvgFragmentInfo { - pub fn new(node: &N, - data: SVGSVGData, - ctx: &SharedStyleContext) - -> SvgFragmentInfo { + pub fn new(data: SVGSVGData) -> SvgFragmentInfo { SvgFragmentInfo { - replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node, ctx), dom_width: Au::from_px(data.width as i32), dom_height: Au::from_px(data.height as i32), } } - - /// Returns the original inline-size of the SVG element. - pub fn svg_inline_size(&self) -> Au { - if self.replaced_image_fragment_info.writing_mode_is_vertical { - self.dom_height - } else { - self.dom_width - } - } - - /// Returns the original block-size of the SVG element. - pub fn svg_block_size(&self) -> Au { - if self.replaced_image_fragment_info.writing_mode_is_vertical { - self.dom_width - } else { - self.dom_height - } - } } /// A fragment that represents a replaced content image and its accompanying borders, shadows, etc. #[derive(Clone)] pub struct ImageFragmentInfo { - /// The image held within this fragment. - pub replaced_image_fragment_info: ReplacedImageFragmentInfo, pub image: Option>, pub metadata: Option, } @@ -423,9 +373,9 @@ impl ImageFragmentInfo { /// /// FIXME(pcwalton): The fact that image fragments store the cache in the fragment makes little /// sense to me. - pub fn new(node: &N, url: Option, - shared_layout_context: &SharedLayoutContext) - -> ImageFragmentInfo { + pub fn new(url: Option, + shared_layout_context: &SharedLayoutContext) + -> ImageFragmentInfo { let image_or_metadata = url.and_then(|url| { shared_layout_context.get_or_request_image_or_meta(url, UsePlaceholder::Yes) }); @@ -443,40 +393,11 @@ impl ImageFragmentInfo { }; ImageFragmentInfo { - replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node, &shared_layout_context.style_context), image: image, metadata: metadata, } } - /// Returns the original inline-size of the image. - pub fn image_inline_size(&mut self) -> Au { - match self.metadata { - Some(ref metadata) => { - Au::from_px(if self.replaced_image_fragment_info.writing_mode_is_vertical { - metadata.height - } else { - metadata.width - } as i32) - } - None => Au(0) - } - } - - /// Returns the original block-size of the image. - pub fn image_block_size(&mut self) -> Au { - match self.metadata { - Some(ref metadata) => { - Au::from_px(if self.replaced_image_fragment_info.writing_mode_is_vertical { - metadata.width - } else { - metadata.height - } as i32) - } - None => Au(0) - } - } - pub fn tile_image_round(position: &mut Au, size: &mut Au, absolute_anchor_origin: Au, @@ -549,149 +470,6 @@ impl ImageFragmentInfo { } } -#[derive(Clone)] -pub struct ReplacedImageFragmentInfo { - pub computed_inline_size: Option, - pub computed_block_size: Option, - pub writing_mode_is_vertical: bool, -} - -impl ReplacedImageFragmentInfo { - pub fn new(node: &N, ctx: &SharedStyleContext) -> ReplacedImageFragmentInfo - where N: ThreadSafeLayoutNode { - let is_vertical = node.style(ctx).writing_mode.is_vertical(); - ReplacedImageFragmentInfo { - computed_inline_size: None, - computed_block_size: None, - writing_mode_is_vertical: is_vertical, - } - } - - /// Returns the calculated inline-size of the image, accounting for the inline-size attribute. - pub fn computed_inline_size(&self) -> Au { - self.computed_inline_size.expect("image inline_size is not computed yet!") - } - - /// Returns the calculated block-size of the image, accounting for the block-size attribute. - pub fn computed_block_size(&self) -> Au { - self.computed_block_size.expect("image block_size is not computed yet!") - } - - // Return used value for inline-size or block-size. - // - // `dom_length`: inline-size or block-size as specified in the `img` tag. - // `style_length`: inline-size as given in the CSS - pub fn style_length(style_length: LengthOrPercentageOrAuto, - container_size: Option) -> MaybeAuto { - match (style_length, container_size) { - (LengthOrPercentageOrAuto::Length(length), _) => MaybeAuto::Specified(length), - (LengthOrPercentageOrAuto::Percentage(pc), Some(container_size)) => { - MaybeAuto::Specified(container_size.scale_by(pc)) - } - (LengthOrPercentageOrAuto::Percentage(_), None) => MaybeAuto::Auto, - (LengthOrPercentageOrAuto::Calc(calc), Some(container_size)) => { - MaybeAuto::Specified(calc.length() + container_size.scale_by(calc.percentage())) - } - (LengthOrPercentageOrAuto::Calc(_), None) => MaybeAuto::Auto, - (LengthOrPercentageOrAuto::Auto, _) => MaybeAuto::Auto, - } - } - - pub fn calculate_replaced_inline_size(&mut self, - style: &ServoComputedValues, - noncontent_inline_size: Au, - container_inline_size: Au, - container_block_size: Option, - fragment_inline_size: Au, - fragment_block_size: Au) - -> Au { - let style_inline_size = style.content_inline_size(); - let style_block_size = style.content_block_size(); - let style_min_inline_size = style.min_inline_size(); - let style_max_inline_size = style.max_inline_size(); - let style_min_block_size = style.min_block_size(); - let style_max_block_size = style.max_block_size(); - - // TODO(ksh8281): compute border,margin - let inline_size = ReplacedImageFragmentInfo::style_length( - style_inline_size, - Some(container_inline_size)); - - let inline_size = match inline_size { - MaybeAuto::Auto => { - let intrinsic_width = fragment_inline_size; - let intrinsic_height = fragment_block_size; - if intrinsic_height == Au(0) { - intrinsic_width - } else { - let ratio = intrinsic_width.to_f32_px() / - intrinsic_height.to_f32_px(); - - let specified_height = ReplacedImageFragmentInfo::style_length( - style_block_size, - container_block_size); - let specified_height = match specified_height { - MaybeAuto::Auto => intrinsic_height, - MaybeAuto::Specified(h) => h, - }; - let specified_height = clamp_size(specified_height, - style_min_block_size, - style_max_block_size, - Au(0)); - Au::from_f32_px(specified_height.to_f32_px() * ratio) - } - }, - MaybeAuto::Specified(w) => w, - }; - - let inline_size = clamp_size(inline_size, - style_min_inline_size, - style_max_inline_size, - container_inline_size); - - self.computed_inline_size = Some(inline_size); - inline_size + noncontent_inline_size - } - - /// Here, `noncontent_block_size` represents the sum of border and padding, but not margin. - pub fn calculate_replaced_block_size(&mut self, - style: &ServoComputedValues, - noncontent_block_size: Au, - containing_block_block_size: Option, - fragment_inline_size: Au, - fragment_block_size: Au) - -> Au { - let style_block_size = style.content_block_size(); - let style_min_block_size = style.min_block_size(); - let style_max_block_size = style.max_block_size(); - - let inline_size = self.computed_inline_size(); - let block_size = ReplacedImageFragmentInfo::style_length( - style_block_size, - containing_block_block_size); - - let block_size = match block_size { - MaybeAuto::Auto => { - let intrinsic_width = fragment_inline_size; - let intrinsic_height = fragment_block_size; - let scale = intrinsic_width.to_f32_px() / inline_size.to_f32_px(); - Au::from_f32_px(intrinsic_height.to_f32_px() / scale) - }, - MaybeAuto::Specified(h) => { - h - } - }; - - let block_size = clamp_size(block_size, - style_min_block_size, - style_max_block_size, - Au(0)); - - self.computed_block_size = Some(block_size); - block_size + noncontent_block_size - } -} - /// A fragment that represents an inline frame (iframe). This stores the pipeline ID so that the /// size of this iframe can be communicated via the constellation to the iframe's own layout thread. #[derive(Clone)] @@ -708,52 +486,6 @@ impl IframeFragmentInfo { pipeline_id: pipeline_id, } } - - #[inline] - pub fn calculate_replaced_inline_size(&self, style: &ServoComputedValues, containing_size: Au) - -> Au { - // Calculate the replaced inline size (or default) as per CSS 2.1 § 10.3.2 - IframeFragmentInfo::calculate_replaced_size(style.content_inline_size(), - style.min_inline_size(), - style.max_inline_size(), - Some(containing_size), - Au::from_px(300)) - } - - #[inline] - pub fn calculate_replaced_block_size(&self, style: &ServoComputedValues, containing_size: Option) - -> Au { - // Calculate the replaced block size (or default) as per CSS 2.1 § 10.3.2 - IframeFragmentInfo::calculate_replaced_size(style.content_block_size(), - style.min_block_size(), - style.max_block_size(), - containing_size, - Au::from_px(150)) - - } - - fn calculate_replaced_size(content_size: LengthOrPercentageOrAuto, - style_min_size: LengthOrPercentage, - style_max_size: LengthOrPercentageOrNone, - containing_size: Option, - default_size: Au) -> Au { - let computed_size = match (content_size, containing_size) { - (LengthOrPercentageOrAuto::Length(length), _) => length, - (LengthOrPercentageOrAuto::Percentage(pc), Some(container_size)) => container_size.scale_by(pc), - (LengthOrPercentageOrAuto::Calc(calc), Some(container_size)) => { - container_size.scale_by(calc.percentage()) + calc.length() - }, - (LengthOrPercentageOrAuto::Calc(calc), None) => calc.length(), - (LengthOrPercentageOrAuto::Percentage(_), None) => default_size, - (LengthOrPercentageOrAuto::Auto, _) => default_size, - }; - - let containing_size = containing_size.unwrap_or(Au(0)); - clamp_size(computed_size, - style_min_size, - style_max_size, - containing_size) - } } /// A scanned text fragment represents a single run of text with a distinct style. A `TextFragment` @@ -1728,7 +1460,6 @@ impl Fragment { match self.specific { SpecificFragmentInfo::Generic | SpecificFragmentInfo::GeneratedContent(_) | - SpecificFragmentInfo::Iframe(_) | SpecificFragmentInfo::Table | SpecificFragmentInfo::TableCell | SpecificFragmentInfo::TableColumn(_) | @@ -2215,7 +1946,7 @@ impl Fragment { /// been assigned first. /// /// Ideally, this should follow CSS 2.1 § 10.6.2. - pub fn assign_replaced_block_size_if_necessary(&mut self, containing_block_block_size: Option) { + pub fn assign_replaced_block_size_if_necessary(&mut self) { match self.specific { SpecificFragmentInfo::Generic | SpecificFragmentInfo::GeneratedContent(_) | diff --git a/components/layout/inline.rs b/components/layout/inline.rs index 57eb16f1b841..cefb77bb5920 100644 --- a/components/layout/inline.rs +++ b/components/layout/inline.rs @@ -1394,11 +1394,9 @@ impl Flow for InlineFlow { debug!("assign_block_size_inline: floats in: {:?}", self.base.floats); // Assign the block-size and late-computed inline-sizes for the inline fragments. - let containing_block_block_size = - self.base.block_container_explicit_block_size; for fragment in &mut self.fragments.fragments { fragment.update_late_computed_replaced_inline_size_if_necessary(); - fragment.assign_replaced_block_size_if_necessary(containing_block_block_size); + fragment.assign_replaced_block_size_if_necessary(); } // Reset our state, so that we handle incremental reflow correctly. diff --git a/components/layout/list_item.rs b/components/layout/list_item.rs index b3f8df9752dc..20cc7bfa8505 100644 --- a/components/layout/list_item.rs +++ b/components/layout/list_item.rs @@ -111,9 +111,7 @@ impl Flow for ListItemFlow { &mut layout_context.font_context(), &*self.block_flow.fragment.style); for marker in &mut self.marker_fragments { - let containing_block_block_size = - self.block_flow.base.block_container_explicit_block_size; - marker.assign_replaced_block_size_if_necessary(containing_block_block_size); + marker.assign_replaced_block_size_if_necessary(); let marker_inline_metrics = marker.aligned_inline_metrics(layout_context, &marker_line_metrics, Some(&marker_line_metrics));