layout: text: Don't consider the REQUIRES_LINE_BREAK_AFTERWARD_IF_WRAPPING_ON_NEWLINES if the fragment can wrap text.

This was making us fall in a loop where the start split was empty, but we didn't
ignore it because the current fragment had this flag, but then we treated it
differently depending on the white_space property.

Not totally sure this is the proper fix, but it makes sense to me. In case it
is:

Fixes #12369.

components/layout/fragment.rs

@@ -1541,11 +1541,10 @@ impl Fragment {
     /// information are both optional due to the possibility of them being whitespace.
     pub fn calculate_split_position(&self, max_inline_size: Au, starts_line: bool)
                                     -> Option<SplitResult> {
-        let text_fragment_info =
-            if let SpecificFragmentInfo::ScannedText(ref text_fragment_info) = self.specific {
-                text_fragment_info
-            } else {
-                return None
+        let text_fragment_info = match self.specific {
+            SpecificFragmentInfo::ScannedText(ref text_fragment_info)
+                => text_fragment_info,
+            _   => return None,
         };
 
         let mut flags = SplitOptions::empty();
@@ -1618,11 +1617,10 @@ impl Fragment {
             flags: SplitOptions)
             -> Option<SplitResult>
             where I: Iterator<Item=TextRunSlice<'a>> {
-        let text_fragment_info =
-            if let SpecificFragmentInfo::ScannedText(ref text_fragment_info) = self.specific {
-                text_fragment_info
-            } else {
-                return None
+        let text_fragment_info = match self.specific {
+            SpecificFragmentInfo::ScannedText(ref text_fragment_info)
+                => text_fragment_info,
+            _   => return None,
         };
 
         let mut remaining_inline_size = max_inline_size;
@@ -1661,7 +1659,8 @@ impl Fragment {
             // see if we're going to overflow the line. If so, perform a best-effort split.
             let mut remaining_range = slice.text_run_range();
             let split_is_empty = inline_start_range.is_empty() &&
-                    !self.requires_line_break_afterward_if_wrapping_on_newlines();
+                    !(self.requires_line_break_afterward_if_wrapping_on_newlines() &&
+                      !self.white_space().allow_wrap());
             if split_is_empty {
                 // We're going to overflow the line.
                 overflowing = true;

components/layout/inline.rs

@@ -459,10 +459,12 @@ impl LineBreaker {
             kind: FloatKind::Left,
         });
 
+        let fragment_margin_box_inline_size = first_fragment.margin_box_inline_size();
+
         // Simple case: if the fragment fits, then we can stop here.
-        if line_bounds.size.inline > first_fragment.margin_box_inline_size() {
+        if line_bounds.size.inline > fragment_margin_box_inline_size {
             debug!("LineBreaker: fragment fits on line {}", self.lines.len());
-            return (line_bounds, first_fragment.margin_box_inline_size());
+            return (line_bounds, fragment_margin_box_inline_size);
         }
 
         // If not, but we can't split the fragment, then we'll place the line here and it will
@@ -471,7 +473,7 @@ impl LineBreaker {
             debug!("LineBreaker: line doesn't fit, but is unsplittable");
         }
 
-        (line_bounds, first_fragment.margin_box_inline_size())
+        (line_bounds, fragment_margin_box_inline_size)
     }
 
     /// Performs float collision avoidance. This is called when adding a fragment is going to

components/layout/text.rs

@@ -340,22 +340,21 @@ impl TextRunScanner {
                 let mut byte_range = Range::new(ByteIndex(mapping.byte_range.begin() as isize),
                                                 ByteIndex(mapping.byte_range.length() as isize));
 
+                let mut flags = ScannedTextFlags::empty();
+                let text_size = old_fragment.border_box.size;
+
                 let requires_line_break_afterward_if_wrapping_on_newlines =
                     scanned_run.run.text[mapping.byte_range.begin()..mapping.byte_range.end()]
                     .ends_with('\n');
+
                 if requires_line_break_afterward_if_wrapping_on_newlines {
                     byte_range.extend_by(ByteIndex(-1)); // Trim the '\n'
+                    flags.insert(REQUIRES_LINE_BREAK_AFTERWARD_IF_WRAPPING_ON_NEWLINES);
                 }
 
-                let text_size = old_fragment.border_box.size;
-
-                let mut flags = ScannedTextFlags::empty();
                 if mapping.selected {
                     flags.insert(SELECTED);
                 }
-                if requires_line_break_afterward_if_wrapping_on_newlines {
-                    flags.insert(REQUIRES_LINE_BREAK_AFTERWARD_IF_WRAPPING_ON_NEWLINES);
-                }
 
                 let insertion_point = if mapping.contains_insertion_point(scanned_run.insertion_point) {
                     scanned_run.insertion_point