Uses and returns the fractional width in text eliding

ui/gfx/canvas_skia.cc

 // Copyright (c) 2012 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/canvas.h"
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/font_list.h"
@@ skipping 151 matching lines @@
 #endif
 
   return flags;
 }
 
 }  // namespace
 
 // static
 void Canvas::SizeStringInt(const base::string16& text,
                            const FontList& font_list,
-                           int* width, int* height,
+                           float* width, float* height,

[msw, 2013/09/27 21:54:48]

nit: one arg per line here, perhaps the function should return a SizeF?

[jianli, 2013/10/01 00:32:58]

Done. We can't return SizeF since width and height parameters serve as both in
and out.

                            int line_height,
                            int flags) {
   DCHECK_GE(*width, 0);
   DCHECK_GE(*height, 0);
 
   flags = AdjustPlatformSpecificFlags(text, flags);
 
   base::string16 adjusted_text = text;
 #if defined(OS_WIN)
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   if ((flags & MULTI_LINE) && *width != 0) {
     gfx::WordWrapBehavior wrap_behavior = gfx::TRUNCATE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = gfx::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
       wrap_behavior = gfx::ELIDE_LONG_WORDS;
 
     Rect rect(*width, INT_MAX);
     std::vector<base::string16> strings;
     gfx::ElideRectangleText(adjusted_text, font_list,
                            rect.width(), rect.height(),
                            wrap_behavior, &strings);
     scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
     UpdateRenderText(rect, base::string16(), font_list, flags, 0,
                      render_text.get());
 
-    int h = 0;
-    int w = 0;
+    float h = 0;
+    float w = 0;
     for (size_t i = 0; i < strings.size(); ++i) {
       StripAcceleratorChars(flags, &strings[i]);
       render_text->SetText(strings[i]);
-      const Size& string_size = render_text->GetStringSize();
+      const SizeF& string_size = render_text->GetStringSize();
       w = std::max(w, string_size.width());
       h += (i > 0 && line_height > 0) ? line_height : string_size.height();
     }
     *width = w;
     *height = h;
   } else {
     // If the string is too long, the call by |RenderTextWin| to |ScriptShape()|
     // will inexplicably fail with result E_INVALIDARG. Guard against this.
     const size_t kMaxRenderTextLength = 5000;
     if (adjusted_text.length() >= kMaxRenderTextLength) {
       *width = font_list.GetExpectedTextWidth(adjusted_text.length());
       *height = font_list.GetHeight();
     } else {
       scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
       Rect rect(*width, *height);
       StripAcceleratorChars(flags, &adjusted_text);
       UpdateRenderText(rect, adjusted_text, font_list, flags, 0,
                        render_text.get());
-      const Size& string_size = render_text->GetStringSize();
+      const SizeF& string_size = render_text->GetStringSizeF();
       *width = string_size.width();
       *height = string_size.height();
     }
   }
 }
 
 void Canvas::DrawStringRectWithShadows(const base::string16& text,
                                        const FontList& font_list,
                                        SkColor color,
                                        const Rect& text_bounds,
@@ skipping 227 matching lines @@
     size_t desired_characters_to_truncate_from_head,
     const Font& font,
     SkColor color,
     const Rect& display_rect) {
   DrawFadeTruncatingStringRect(text, truncate_mode,
                                desired_characters_to_truncate_from_head,
                                FontList(font), color, display_rect);
 }
 
 }  // namespace gfx