Add LazyLineBreakIterator::Next/PreviousBreakOpportunity()

third_party/WebKit/Source/platform/fonts/shaping/ShapingLineBreaker.cpp

 // Copyright 2017 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 "platform/fonts/shaping/ShapingLineBreaker.h"
 
 #include "platform/fonts/Font.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/fonts/shaping/ShapeResult.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
@@ skipping 35 matching lines @@
   // HarfBuzzHarfBuzz safe to break info when available.
   for (; offset < end; offset++) {
     if (text[offset] == kSpaceCharacter)
       break;
   }
   return offset;
 }
 
 }  // namespace
 
-// TODO(eae); Should take a const LazyLineBreakIterator& but that requires the
-// LazyLineBreakIterator::isBreakable method to be updated to be const.
-unsigned ShapingLineBreaker::PreviousBreakOpportunity(
-    LazyLineBreakIterator* break_iterator,
-    unsigned start,
-    unsigned offset) {
-  DCHECK(break_iterator);
-  unsigned pos = std::min(start + offset, shaper_->TextLength());
-  for (; pos > start; pos--) {
-    int next_break = 0;
-    if (break_iterator->IsBreakable(pos, next_break, break_type_))
-      return pos;
-  }
-  return start;
-}
-
-unsigned ShapingLineBreaker::NextBreakOpportunity(
-    LazyLineBreakIterator* break_iterator,
-    unsigned offset) {
-  DCHECK(break_iterator);
-  int next_break = 0;
-  break_iterator->IsBreakable(offset, next_break, break_type_);
-  return next_break;
-}
-
 // Shapes a line of text by finding a valid and appropriate break opportunity
 // based on the shaping results for the entire paragraph. Re-shapes the start
 // and end of the line as needed.
 //
 // Definitions:
 //   Candidate break opportunity: Ideal point to break, disregarding line
 //                                breaking rules. May be in the middle of a word
 //                                or inside a ligature.
 //    Valid break opportunity:    A point where a break is allowed according to
 //                                the relevant breaking rules.
@@ skipping 33 matching lines @@
   if (first_safe != start) {
     LayoutUnit original_width =
         result_->SnappedEndPositionForOffset(first_safe) - start_position;
     line_start_result = shaper_->Shape(font_, direction, start, first_safe);
     available_space += line_start_result->SnappedWidth() - original_width;
   }
 
   // Find a candidate break opportunity by identifying the last offset before
   // exceeding the available space and the determine the closest valid break
   // preceding the candidate.
-  LazyLineBreakIterator break_iterator(text_, locale_);
+  LazyLineBreakIterator break_iterator(text_, locale_, break_type_);
   LayoutUnit end_position = start_position + available_space;
   unsigned candidate_break = result_->OffsetForPosition(end_position, false);
   unsigned break_opportunity =
-      PreviousBreakOpportunity(&break_iterator, start, candidate_break);
+      break_iterator.PreviousBreakOpportunity(candidate_break, start);
   if (break_opportunity <= start) {
-    break_opportunity = NextBreakOpportunity(&break_iterator, candidate_break);
+    break_opportunity = break_iterator.NextBreakOpportunity(candidate_break);
   }
 
   RefPtr<ShapeResult> line_end_result;
   unsigned last_safe = break_opportunity;
   while (break_opportunity > start) {
     // If the previous valid break opportunity is not at a safe-to-break
     // boundary reshape between the safe-to-break offset and the valid break
     // offset. If the resulting width exceeds the available space the
     // preceding boundary is tried until the available space is sufficient.
     unsigned previous_safe = std::max(
         PreviousSafeToBreakAfter(shaper_->GetText(), start, break_opportunity),
         start);
     if (previous_safe != break_opportunity) {
       LayoutUnit safe_position =
           result_->SnappedStartPositionForOffset(previous_safe);
       while (break_opportunity > previous_safe && previous_safe > start) {
         line_end_result =
             shaper_->Shape(font_, direction, previous_safe, break_opportunity);
         if (safe_position + line_end_result->SnappedWidth() <= end_position)
           break;
         line_end_result = nullptr;
-        break_opportunity = PreviousBreakOpportunity(&break_iterator, start,
-                                                     break_opportunity - 1);
+        break_opportunity = break_iterator.PreviousBreakOpportunity(
+            break_opportunity - 1, start);
       }
     }
 
     if (break_opportunity > start) {
       last_safe = previous_safe;
       break;
     }
 
     // No suitable break opportunity, not exceeding the available space,
     // found. Choose the next valid one even though it will overflow.
-    break_opportunity = NextBreakOpportunity(&break_iterator, candidate_break);
+    break_opportunity = break_iterator.NextBreakOpportunity(candidate_break);
   }
 
   // Create shape results for the line by copying from the re-shaped result (if
   // reshaping was needed) and the original shape results.
   RefPtr<ShapeResult> line_result = ShapeResult::Create(font_, 0, direction);
   unsigned max_length = std::numeric_limits<unsigned>::max();
   if (line_start_result)
     line_start_result->CopyRange(0, max_length, line_result.Get());
   if (last_safe > first_safe)
     result_->CopyRange(first_safe, last_safe, line_result.Get());
   if (line_end_result)
     line_end_result->CopyRange(last_safe, max_length, line_result.Get());
 
   *break_offset = break_opportunity;
   return line_result.Release();
 }
 
 }  // namespace blink