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_;
+    // Add extra space below the last line, because some characters (eg.
+    // underscore) may be drawn under the descent. See http://crbug.com/459812
+    // and the comments in AdvanceLine() below.

[msw, 2015/02/26 00:47:21]

nit: you can remove this line "// and the comments in AdvanceLine() below."

+    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());
+      // Line height is assumed to be the height between the ascent and the

[msw, 2015/02/26 00:47:21]

nit: consider just using a comment like that above: "Add extra space above the
first line, because some characters (eg. A-ring) may be drawn above the ascent.
See http://crbug.com/459812"

+      // descent, however some diacritic marks may appear above the ascent.
+      // Therefore prepare enough space above the first line. Note that the
+      // line height wouldn't be the height between top and bottom to avoid
+      // making extra space between lines. See http://crbug.com/459812
+      if (line == &lines_.front()) {
+        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