Type conversion fixes, text rendering edition.

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"
+#include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/gfx/text_utils.h"
 
 namespace gfx {
 
@@ skipping 72 matching lines @@
     *text = RemoveAcceleratorChar(*text, '&', &char_pos, &char_span);
     if ((flags & Canvas::SHOW_PREFIX) && char_pos != -1)
       return Range(char_pos, char_pos + char_span);
   }
   return Range::InvalidRange();
 }
 
 // Elides |text| and adjusts |range| appropriately. If eliding causes |range|
 // to no longer point to the same character in |text|, |range| is made invalid.
 void ElideTextAndAdjustRange(const FontList& font_list,
-                             int width,
+                             float width,
                              base::string16* text,
                              Range* range) {
   const base::char16 start_char =
       (range->IsValid() ? text->at(range->start()) : 0);
   *text = ElideText(*text, font_list, width, ELIDE_TAIL);
   if (!range->IsValid())
     return;
   if (range->start() >= text->length() ||
       text->at(range->start()) != start_char) {
     *range = Range::InvalidRange();
@@ skipping 53 matching lines @@
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   if ((flags & MULTI_LINE) && *width != 0) {
     WordWrapBehavior wrap_behavior = TRUNCATE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
       wrap_behavior = ELIDE_LONG_WORDS;
 
-    Rect rect(*width, INT_MAX);
     std::vector<base::string16> strings;
-    ElideRectangleText(adjusted_text, font_list, rect.width(), rect.height(),
+    ElideRectangleText(adjusted_text, font_list,
+                       *width, INT_MAX,
                        wrap_behavior, &strings);
+    Rect rect(ClampToInt(*width), INT_MAX);
     scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
     UpdateRenderText(rect, base::string16(), font_list, flags, 0,
                      render_text.get());
 
     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 SizeF& string_size = render_text->GetStringSizeF();
       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();
+      *width = static_cast<float>(
+          font_list.GetExpectedTextWidth(adjusted_text.length()));
+      *height = static_cast<float>(font_list.GetHeight());
     } else {
       scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-      Rect rect(*width, *height);
+      Rect rect(ClampToInt(*width), ClampToInt(*height));
       StripAcceleratorChars(flags, &adjusted_text);
       UpdateRenderText(rect, adjusted_text, font_list, flags, 0,
                        render_text.get());
       const SizeF& string_size = render_text->GetStringSizeF();
       *width = string_size.width();
       *height = string_size.height();
     }
   }
 }
 
@@ skipping 24 matching lines @@
   render_text->set_shadows(shadows);
 
   if (flags & MULTI_LINE) {
     WordWrapBehavior wrap_behavior = IGNORE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
       wrap_behavior = ELIDE_LONG_WORDS;
 
     std::vector<base::string16> strings;
-    ElideRectangleText(adjusted_text, font_list, text_bounds.width(),
+    ElideRectangleText(adjusted_text, font_list,
+                       static_cast<float>(text_bounds.width()),
                        text_bounds.height(), wrap_behavior, &strings);
 
     for (size_t i = 0; i < strings.size(); i++) {
       Range range = StripAcceleratorChars(flags, &strings[i]);
       UpdateRenderText(rect, strings[i], font_list, flags, color,
                        render_text.get());
       int line_padding = 0;
       if (line_height > 0)
         line_padding = line_height - render_text->GetStringSize().height();
       else
@@ skipping 26 matching lines @@
     if (elide_text) {
       render_text->SetText(adjusted_text);
       if (render_text->GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
         render_text->SetElideBehavior(FADE_TAIL);
         elide_text = false;
       }
     }
 #endif
 
     if (elide_text) {
-      ElideTextAndAdjustRange(font_list, text_bounds.width(), &adjusted_text,
-                              &range);
+      ElideTextAndAdjustRange(font_list,
+                              static_cast<float>(text_bounds.width()),
+                              &adjusted_text, &range);
     }
 
     UpdateRenderText(rect, adjusted_text, font_list, flags, color,
                      render_text.get());
     if (range.IsValid())
       render_text->ApplyStyle(UNDERLINE, true, range);
     render_text->Draw(this);
   }
 
   canvas_->restore();
@@ skipping 79 matching lines @@
   UpdateRenderText(rect, text, font_list, flags, color, render_text.get());
   render_text->SetElideBehavior(FADE_TAIL);
 
   canvas_->save();
   ClipRect(display_rect);
   render_text->Draw(this);
   canvas_->restore();
 }
 
 }  // namespace gfx