Use Opportunity Iterator to position text fragments in NGLineBuilder

third_party/WebKit/Source/core/layout/ng/ng_line_builder.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/ng_line_builder.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/layout/ng/ng_bidi_paragraph.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_inline_node.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_text_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/text/BidiRunList.h"
 
 namespace blink {
 
 NGLineBuilder::NGLineBuilder(NGInlineNode* inline_box,
-                             const NGConstraintSpace* constraint_space)
+                             NGConstraintSpace* constraint_space)
     : inline_box_(inline_box),
       constraint_space_(constraint_space),
       baseline_type_(constraint_space->WritingMode() ==
                              NGWritingMode::kHorizontalTopBottom
                          ? FontBaseline::AlphabeticBaseline
                          : FontBaseline::IdeographicBaseline)
 #if DCHECK_IS_ON()
       ,
       is_bidi_reordered_(false)
 #endif
 {
 }
 
 bool NGLineBuilder::CanFitOnLine() const {
-  LayoutUnit available_size = constraint_space_->AvailableSize().inline_size;
+  LayoutUnit available_size = current_opportunity_.InlineSize();
   if (available_size == NGSizeIndefinite)
     return true;
   return end_position_ <= available_size;
 }
 
 bool NGLineBuilder::HasItems() const {
   return start_offset_ != end_offset_;
 }
 
 bool NGLineBuilder::HasBreakOpportunity() const {
@@ skipping 133 matching lines @@
   line_item_chunks->swap(line_item_chunks_in_visual_order);
 }
 
 void NGLineBuilder::PlaceItems(
     const Vector<LineItemChunk, 32>& line_item_chunks) {
   const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
   const unsigned fragment_start_index = fragments_.size();
 
   NGFragmentBuilder text_builder(NGPhysicalFragment::kFragmentText,
                                  inline_box_);
-  text_builder.SetWritingMode(constraint_space_->WritingMode());
+  text_builder.SetWritingMode(ConstraintSpace().WritingMode());
   line_box_data_list_.grow(line_box_data_list_.size() + 1);
   LineBoxData& line_box_data = line_box_data_list_.back();
 
   // Use the block style to compute the estimated baseline position because the
   // baseline position is not known until we know the maximum ascent and leading
   // of the line. Items are placed on this baseline, then adjusted later if the
   // estimation turned out to be different.
   const ComputedStyle* block_style = inline_box_->BlockStyle();
   InlineItemMetrics estimated_metrics(*block_style, baseline_type_);
   LayoutUnit estimated_baseline =
@@ skipping 28 matching lines @@
     // properties, not the resolved bidi direction.
     text_builder.SetDirection(style->direction())
         .SetInlineSize(line_item_chunk.inline_size)
         .SetInlineOverflow(line_item_chunk.inline_size)
         .SetBlockSize(height)
         .SetBlockOverflow(height);
     RefPtr<NGPhysicalTextFragment> text_fragment = text_builder.ToTextFragment(
         line_item_chunk.index, line_item_chunk.start_offset,
         line_item_chunk.end_offset);
     fragments_.push_back(std::move(text_fragment));
-    offsets_.push_back(NGLogicalOffset(line_box_data.inline_size, top));
+
+    NGLogicalOffset logical_offset(
+        current_opportunity_.InlineStartOffset() -
+            ConstraintSpace().BfcOffset().inline_offset,
+        top);

[kojii, 2017/03/09 03:01:54]

Don't we need to add |line_box_data.inline_size|, or is it included somewhere I
missed?

[Gleb Lanbin, 2017/03/09 22:26:45]

could you explain why you think we need to include it?
Here is how I understand it
1) LayoutOpportunityIterator returns a LayoutOpportunity(NGLogicalRect)
2) NGTextLayoutAlgorithm::LayoutInline tries to fit as much text as possible to
that opportunity and then calls
NGLineBuilder::CreateLineUpToLastBreakOpportunity which place line_item_chunks
that has inline_size. 
3) In order to calculate the logical offset for each line we need to subtract
the current layout opportunity's offset from ConstraintSpace().offset. 

[kojii, 2017/03/10 03:12:43]

Ok if tests pass, I'll need to debug to understand better, and we can fix
anytime later.

When you have multiple elements, or multiple bidi-items, this is where we flow
inline items horizontally, and |line_box_data.inline_size| is the offset from
the left edge. The original comment was that I was not sure either opportunity
or BfcOffset() incorporates it.

+    offsets_.push_back(logical_offset);
     line_box_data.inline_size += line_item_chunk.inline_size;
   }
   DCHECK_EQ(fragments_.size(), offsets_.size());
 
   if (fragment_start_index == fragments_.size()) {
     // The line was empty. Remove the LineBoxData.
     line_box_data_list_.shrink(line_box_data_list_.size() - 1);
     return;
   }
 
@@ skipping 71 matching lines @@
   DCHECK(!HasItems()) << "Must call CreateLine()";
   DCHECK_EQ(fragments_.size(), offsets_.size());
 
   for (unsigned i = 0; i < fragments_.size(); i++) {
     // TODO(layout-dev): This should really be a std::move but
     // CopyFragmentDataToLayoutBlockFlow also uses the fragments.
     container_builder->AddChild(fragments_[i].get(), offsets_[i]);
   }
 
   // TODO(kojii): Check if the line box width should be content or available.
-  // TODO(kojii): Need to take constraint_space into account.
   container_builder->SetInlineSize(max_inline_size_)
       .SetInlineOverflow(max_inline_size_)
       .SetBlockSize(content_size_)
       .SetBlockOverflow(content_size_);
 }
 
 void NGLineBuilder::CopyFragmentDataToLayoutBlockFlow() {
   LayoutBlockFlow* block = inline_box_->GetLayoutBlockFlow();
   block->deleteLineBoxTree();
 
@@ skipping 36 matching lines @@
     // RootInlineBox are set to Bidirun::m_box.
     line_info.setEmpty(false);
     // TODO(kojii): Implement setFirstLine, LastLine, etc.
     RootInlineBox* line_box = block->constructLine(bidi_runs, line_info);
 
     // Copy fragments data to InlineBoxes.
     DCHECK_EQ(fragments_for_bidi_runs.size(), bidi_runs.runCount());
     BidiRun* run = bidi_runs.firstRun();
     for (auto* physical_fragment : fragments_for_bidi_runs) {
       DCHECK(run);
-      NGTextFragment fragment(constraint_space_->WritingMode(),
+      NGTextFragment fragment(ConstraintSpace().WritingMode(),
                               toNGPhysicalTextFragment(physical_fragment));
       InlineBox* inline_box = run->m_box;
       inline_box->setLogicalWidth(fragment.InlineSize());
       inline_box->setLogicalLeft(fragment.InlineOffset());
       inline_box->setLogicalTop(fragment.BlockOffset());
       run = run->next();
     }
     DCHECK(!run);
 
     // Copy LineBoxData to RootInlineBox.
     line_box->setLogicalWidth(line_box_data.inline_size);
     LayoutUnit baseline_position =
         line_box_data.top_with_leading +
         LayoutUnit(line_box_data.max_ascent_and_leading);
     line_box->setLineTopBottomPositions(
         baseline_position - LayoutUnit(line_box_data.max_ascent),
         baseline_position + LayoutUnit(line_box_data.max_descent),
         line_box_data.top_with_leading,
         baseline_position + LayoutUnit(line_box_data.max_descent_and_leading));
 
     bidi_runs.deleteRuns();
     fragments_for_bidi_runs.clear();
   }
 }
 
+void NGLineBuilder::FindNextLayoutOpportunity() {
+  NGLogicalOffset iter_offset = constraint_space_->BfcOffset();
+  iter_offset.block_offset += content_size_;
+  auto* iter = constraint_space_->LayoutOpportunityIterator(iter_offset);
+  NGLayoutOpportunity opportunity = iter->Next();
+  if (!opportunity.IsEmpty())
+    current_opportunity_ = opportunity;
+}
+
 }  // namespace blink