Make bigger string size in RenderTextHarfBuzz.

ui/gfx/render_text_harfbuzz.cc

 // Copyright 2014 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 "ui/gfx/render_text_harfbuzz.h"
 
 #include <limits>
 
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 215 matching lines @@
                       const internal::TextRunList& run_list)
       : max_width_((max_width == 0) ? SK_ScalarMax : SkIntToScalar(max_width)),
         min_baseline_(min_baseline),
         min_height_(min_height),
         multiline_(multiline),
         text_(text),
         words_(words),
         run_list_(run_list),
         text_x_(0),
         line_x_(0),
+        max_top_(0),
+        max_bottom_(0),
         max_descent_(0),
         max_ascent_(0) {
     DCHECK_EQ(multiline_, (words_ != nullptr));
     AdvanceLine();
   }
 
   // Breaks the run at given |run_index| into Line structs.
   void AddRun(int run_index) {
     const internal::TextRunHarfBuzz* run = run_list_.runs()[run_index];
     base::char16 first_char = text_[run->range.start()];
     if (multiline_ && first_char == '\n') {
       AdvanceLine();
     } else if (multiline_ && (line_x_ + SkFloatToScalar(run->width)) >
                max_width_) {
       BreakRun(run_index);
     } else {
       AddSegment(run_index, run->range, run->width);
     }
   }
 
   // Finishes line breaking and outputs the results. Can be called at most once.
   void Finalize(std::vector<internal::Line>* lines, SizeF* size) {
     DCHECK(!lines_.empty());
+    float trailing_height = std::max(0.f, max_bottom_ - max_descent_);
     // Add an empty line to finish the line size calculation and remove it.
     AdvanceLine();
     lines_.pop_back();
     *size = total_size_;
+    size->Enlarge(0, trailing_height);
     lines->swap(lines_);
   }
 
  private:
   // A (line index, segment index) pair that specifies a segment in |lines_|.
   typedef std::pair<size_t, size_t> SegmentHandle;
 
   internal::LineSegment* SegmentFromHandle(const SegmentHandle& handle) {
     return &lines_[handle.first].segments[handle.second];
   }
@@ skipping 104 matching lines @@
       internal::Line* line = &lines_.back();
       std::sort(line->segments.begin(), line->segments.end(),
                 [this](const internal::LineSegment& s1,
                        const internal::LineSegment& s2) -> bool {
                   return run_list_.logical_to_visual(s1.run) <
                          run_list_.logical_to_visual(s2.run);
                 });
       line->size.set_height(std::max(min_height_, max_descent_ + max_ascent_));
       line->baseline =
           std::max(min_baseline_, SkScalarRoundToInt(max_ascent_));
-      line->preceding_heights = std::ceil(total_size_.height());
-      total_size_.set_height(total_size_.height() + line->size.height());
+      if (line == &lines_.front()) {

[msw, 2015/02/24 23:31:35]

Why does only the first line add the extra height between |max_top_| and
|max_ascent_|? Why is that different than your change to make all lines add the
extra height between |max_bottom_| and |max_descent_|? Add an explanatory
comment in one or both places.

[Jun Mukai, 2015/02/25 23:49:19]

Comments added.  Our code base seems to assume line height for the height
between ascent and descent, therefore changing this to the height between top
and bottom would make extra space between lines.

+        line->preceding_heights =
+            std::ceil(std::max(0.f, max_top_ - max_ascent_));
+        total_size_.set_height(line->preceding_heights + line->size.height());
+      } else {
+        line->preceding_heights = std::ceil(total_size_.height());
+        total_size_.set_height(total_size_.height() + line->size.height());
+      }
       total_size_.set_width(std::max(total_size_.width(), line->size.width()));
     }
+    max_top_ = 0;
+    max_bottom_ = 0;
     max_descent_ = 0;
     max_ascent_ = 0;
     line_x_ = 0;
     lines_.push_back(internal::Line());
   }
 
   // Adds a new segment with the given properties to |lines_.back()|.
   void AddSegment(int run_index, Range char_range, float width) {
     if (char_range.is_empty()) {
       DCHECK_EQ(0, width);
@@ skipping 14 matching lines @@
 
     SkPaint paint;
     paint.setTypeface(run.skia_face.get());
     paint.setTextSize(SkIntToScalar(run.font_size));
     paint.setAntiAlias(run.render_params.antialiasing);
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
 
     line->size.set_width(line->size.width() + width);
     max_descent_ = std::max(max_descent_, metrics.fDescent);
-    // fAscent is always negative.
+    max_bottom_ = std::max(max_bottom_, metrics.fBottom);
+    // fAscent and fTop are always negative.
     max_ascent_ = std::max(max_ascent_, -metrics.fAscent);
+    max_top_ = std::max(max_top_, -metrics.fTop);
 
     if (run.is_rtl) {
       rtl_segments_.push_back(
           SegmentHandle(lines_.size() - 1, line->segments.size() - 1));
       // If this is the last segment of an RTL run, reprocess the text-space x
       // ranges of all segments from the run.
       if (char_range.end() == run.range.end())
         UpdateRTLSegmentRanges();
     }
     text_x_ += SkFloatToScalar(width);
     line_x_ += SkFloatToScalar(width);
   }
 
   const SkScalar max_width_;
   const int min_baseline_;
   const float min_height_;
   const bool multiline_;
   const base::string16& text_;
   const BreakList<size_t>* const words_;
   const internal::TextRunList& run_list_;
 
   // Stores the resulting lines.
   std::vector<internal::Line> lines_;
 
   // Text space and line space x coordinates of the next segment to be added.
   SkScalar text_x_;
   SkScalar line_x_;
 
+  float max_top_;
+  float max_bottom_;
   float max_descent_;
   float max_ascent_;
 
   // Size of the multiline text, not including the currently processed line.
   SizeF total_size_;
 
   // The current RTL run segments, to be applied by |UpdateRTLSegmentRanges()|.
   std::vector<SegmentHandle> rtl_segments_;
 
   DISALLOW_COPY_AND_ASSIGN(HarfBuzzLineBreaker);
@@ skipping 1003 matching lines @@
   DCHECK(!update_layout_run_list_);
   DCHECK(!update_display_run_list_);
   return text_elided() ? display_run_list_.get() : &layout_run_list_;
 }
 
 const internal::TextRunList* RenderTextHarfBuzz::GetRunList() const {
   return const_cast<RenderTextHarfBuzz*>(this)->GetRunList();
 }
 
 }  // namespace gfx