Add float version of gfx::Range

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 <map>
 
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/lazy_instance.h"
 #include "base/profiler/scoped_tracker.h"
 #include "third_party/harfbuzz-ng/src/hb.h"
 #include "third_party/icu/source/common/unicode/ubidi.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_fallback.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/utf16_indexing.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/font_fallback_win.h"
 #endif
 
-using gfx::internal::RangeF;
 using gfx::internal::RoundRangeF;
 
 namespace gfx {
 
 namespace {
 
 // Text length limit. Longer strings are slow and not fully tested.
 const size_t kMaxTextLength = 10000;
 
 // The maximum number of scripts a Unicode character can belong to. This value
@@ skipping 423 matching lines @@
   DCHECK(!chars->is_empty());
   DCHECK(!glyphs->is_reversed());
   DCHECK(!glyphs->is_empty());
 }
 
 }  // namespace
 
 namespace internal {
 
 Range RoundRangeF(const RangeF& range_f) {
-  return Range(std::floor(range_f.first + 0.5f),
-               std::floor(range_f.second + 0.5f));
+  return Range(std::floor(range_f.start() + 0.5f),
+               std::floor(range_f.end() + 0.5f));
 }
 
 TextRunHarfBuzz::TextRunHarfBuzz()
     : width(0.0f),
       preceding_run_widths(0.0f),
       is_rtl(false),
       level(0),
       script(USCRIPT_INVALID_CODE),
       glyph_count(static_cast<size_t>(-1)),
       font_size(0),
@@ skipping 175 matching lines @@
   if (run_index >= runs_.size())
     return Range(GetStringSize().width());
   const size_t layout_index = TextIndexToLayoutIndex(index);
   internal::TextRunHarfBuzz* run = runs_[run_index];
   RangeF bounds =
       run->GetGraphemeBounds(grapheme_iterator_.get(), layout_index);
   // If cursor is enabled, extend the last glyph up to the rightmost cursor
   // position since clients expect them to be contiguous.
   if (cursor_enabled() && run_index == runs_.size() - 1 &&
       index == (run->is_rtl ? run->range.start() : run->range.end() - 1))
-    bounds.second = std::ceil(bounds.second);
+    bounds.set_end(std::ceil(bounds.end()));
   return RoundRangeF(run->is_rtl ?
-      RangeF(bounds.second, bounds.first) : bounds);
+      RangeF(bounds.end(), bounds.start()) : bounds);
 }
 
 int RenderTextHarfBuzz::GetLayoutTextBaseline() {
   EnsureLayout();
   return lines()[0].baseline;
 }
 
 SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
@@ skipping 651 matching lines @@
     if (!run->render_params.subpixel_positioning)
       run->width = std::floor(run->width + 0.5f);
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
   return true;
 }
 
 }  // namespace gfx