Uses and returns the fractional width in text eliding

ui/views/corewm/tooltip_controller.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/views/corewm/tooltip_controller.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 20 matching lines @@
 
 namespace {
 
 const SkColor kTooltipBackground = 0xFFFFFFCC;
 const SkColor kTooltipBorder = 0xFF646450;
 const int kTooltipBorderWidth = 1;
 const int kTooltipHorizontalPadding = 3;
 
 // Max visual tooltip width. If a tooltip is greater than this width, it will
 // be wrapped.
-const int kTooltipMaxWidthPixels = 400;
+const float kTooltipMaxWidthPixels = 400;
 
 // Maximum number of lines we allow in the tooltip.
 const size_t kMaxLines = 10;
 
 // TODO(derat): This padding is needed on Chrome OS devices but seems excessive
 // when running the same binary on a Linux workstation; presumably there's a
 // difference in font metrics.  Rationalize this.
 const int kTooltipVerticalPadding = 2;
 const int kTooltipTimeoutMs = 500;
 const int kDefaultTooltipShownTimeoutMs = 10000;
@@ skipping 50 matching lines @@
   }
 
   virtual ~Tooltip() {
     DestroyWidget();
   }
 
   // Updates the text on the tooltip and resizes to fit.
   void SetText(aura::Window* window,
                const string16& tooltip_text,
                const gfx::Point& location) {
-    int max_width, line_count;
+    float max_width;
+    int line_count;
     string16 trimmed_text(tooltip_text);
     controller_->TrimTooltipToFit(
         controller_->GetMaxWidth(location), &trimmed_text, &max_width,
         &line_count);
     label_.SetText(trimmed_text);
 
-    int width = max_width + 2 * kTooltipHorizontalPadding;
+    float width = max_width + 2 * kTooltipHorizontalPadding;
     int height = label_.GetHeightForWidth(max_width) +
         2 * kTooltipVerticalPadding;
     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoDropShadows)) {
       width += 2 * kTooltipBorderWidth;
       height += 2 * kTooltipBorderWidth;
     }
     GetWidgetForWindow(window);
     SetTooltipBounds(location, width, height);
   }
 
@@ skipping 230 matching lines @@
     widget_bounds = gfx::Rect(root->GetHostOrigin(), root->GetHostSize());
   }
   gfx::Screen* screen = gfx::Screen::GetScreenByType(screen_type_);
   gfx::Rect bounds(screen->GetDisplayNearestPoint(origin).bounds());
   if (!widget_bounds.IsEmpty())
     bounds.Intersect(widget_bounds);
   return bounds;
 }
 
 // static
-void TooltipController::TrimTooltipToFit(int max_width,
+void TooltipController::TrimTooltipToFit(float max_width,
                                          string16* text,
-                                         int* width,
+                                         float* width,
                                          int* line_count) {
   *width = 0;
   *line_count = 0;
 
   // Clamp the tooltip length to kMaxTooltipLength so that we don't
   // accidentally DOS the user with a mega tooltip.
   if (text->length() > kMaxTooltipLength)
     *text = text->substr(0, kMaxTooltipLength);
 
   // Determine the available width for the tooltip.
-  int available_width = std::min(kTooltipMaxWidthPixels, max_width);
+  float available_width = std::min(kTooltipMaxWidthPixels, max_width);
 
   std::vector<string16> lines;
   base::SplitString(*text, '\n', &lines);
   std::vector<string16> result_lines;
 
   // Format each line to fit.
   gfx::Font font = GetDefaultFont();
   for (std::vector<string16>::iterator l = lines.begin(); l != lines.end();
       ++l) {
     // We break the line at word boundaries, then stuff as many words as we can
     // in the available width to the current line, and move the remaining words
     // to a new line.
     std::vector<string16> words;
     base::SplitStringDontTrim(*l, ' ', &words);
-    int current_width = 0;
+    float current_width = 0;
     string16 line;
     for (std::vector<string16>::iterator w = words.begin(); w != words.end();
         ++w) {
       string16 word = *w;
       if (w + 1 != words.end())
         word.push_back(' ');
-      int word_width = font.GetStringWidth(word);
+      float word_width = font.GetStringWidth(word);
       if (current_width + word_width > available_width) {
         // Current width will exceed the available width. Must start a new line.
         if (!line.empty())
           result_lines.push_back(line);
         current_width = 0;
         line.clear();
       }
       current_width += word_width;
       line.append(word);
     }
     result_lines.push_back(line);
   }
 
   // Clamp number of lines to |kMaxLines|.
   if (result_lines.size() > kMaxLines) {
     result_lines.resize(kMaxLines);
     // Add ellipses character to last line.
     result_lines[kMaxLines - 1] = gfx::TruncateString(
         result_lines.back(), result_lines.back().length() - 1);
   }
   *line_count = result_lines.size();
 
   // Flatten the result.
   string16 result;
   for (std::vector<string16>::iterator l = result_lines.begin();
       l != result_lines.end(); ++l) {
     if (!result.empty())
       result.push_back('\n');
-    int line_width = font.GetStringWidth(*l);
+    float line_width = font.GetStringWidth(*l);
     // Since we only break at word boundaries, it could happen that due to some
     // very long word, line_width is greater than the available_width. In such
     // case, we simply truncate at available_width and add ellipses at the end.
     if (line_width > available_width) {
       *width = available_width;
       result.append(gfx::ElideText(*l, font, available_width,
                                    gfx::ELIDE_AT_END));
     } else {
       *width = std::max(*width, line_width);
       result.append(*l);
@@ skipping 101 matching lines @@
 int TooltipController::GetTooltipShownTimeout() {
   std::map<aura::Window*, int>::const_iterator it =
       tooltip_shown_timeout_map_.find(tooltip_window_);
   if (it == tooltip_shown_timeout_map_.end())
     return kDefaultTooltipShownTimeoutMs;
   return it->second;
 }
 
 }  // namespace corewm
 }  // namespace views