Replace uses of SkFixed for HarfBuzz conversions.

ui/gfx/harfbuzz_font_skia.cc

 // Copyright 2015 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/harfbuzz_font_skia.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/render_text.h"
+#include "ui/gfx/skia_util.h"
 
 namespace gfx {
 
 namespace {
 
 class HarfBuzzFace;
 
 // Maps from code points to glyph indices in a font.
 typedef std::map<uint32_t, uint16_t> GlyphCache;
 
@@ skipping 29 matching lines @@
                              hb_glyph_extents_t* extents) {
   DCHECK_LE(codepoint, std::numeric_limits<uint16_t>::max());
   paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
   SkScalar sk_width;
   SkRect sk_bounds;
   uint16_t glyph = static_cast<uint16_t>(codepoint);
 
   paint->getTextWidths(&glyph, sizeof(glyph), &sk_width, &sk_bounds);
   if (width)
-    *width = SkScalarToFixed(sk_width);
+    *width = SkiaScalarToHarfBuzzUnits(sk_width);
   if (extents) {
     // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be
     // y-grows-up.
-    extents->x_bearing = SkScalarToFixed(sk_bounds.fLeft);
-    extents->y_bearing = SkScalarToFixed(-sk_bounds.fTop);
-    extents->width = SkScalarToFixed(sk_bounds.width());
-    extents->height = SkScalarToFixed(-sk_bounds.height());
+    extents->x_bearing = SkiaScalarToHarfBuzzUnits(sk_bounds.fLeft);
+    extents->y_bearing = SkiaScalarToHarfBuzzUnits(-sk_bounds.fTop);
+    extents->width = SkiaScalarToHarfBuzzUnits(sk_bounds.width());
+    extents->height = SkiaScalarToHarfBuzzUnits(-sk_bounds.height());
   }
 }
 
 // Writes the |glyph| index for the given |unicode| code point. Returns whether
 // the glyph exists, i.e. it is not a missing glyph.
 hb_bool_t GetGlyph(hb_font_t* font,
                    void* data,
                    hb_codepoint_t unicode,
                    hb_codepoint_t variation_selector,
                    hb_codepoint_t* glyph,
@@ skipping 39 matching lines @@
   SkTypeface* typeface = font_data->paint_.getTypeface();
   const uint16_t glyphs[2] = { static_cast<uint16_t>(first_glyph),
                                static_cast<uint16_t>(second_glyph) };
   int32_t kerning_adjustments[1] = { 0 };
 
   if (!typeface->getKerningPairAdjustments(glyphs, 2, kerning_adjustments))
     return 0;
 
   SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm());
   SkScalar size = font_data->paint_.getTextSize();
-  return SkScalarToFixed(
+  return SkiaScalarToHarfBuzzUnits(
       SkScalarMulDiv(SkIntToScalar(kerning_adjustments[0]), size, upm));
 }
 
 hb_position_t GetGlyphHorizontalKerning(hb_font_t* font,
                                         void* data,
                                         hb_codepoint_t left_glyph,
                                         hb_codepoint_t right_glyph,
                                         void* user_data) {
   FontData* font_data = reinterpret_cast<FontData*>(data);
   if (font_data->paint_.isVerticalText()) {
@@ skipping 118 matching lines @@
                               const FontRenderParams& params,
                               bool subpixel_rendering_suppressed) {
   // TODO(ckocagil): This shouldn't grow indefinitely. Maybe use base::MRUCache?
   static std::map<SkFontID, FaceCache> face_caches;
 
   FaceCache* face_cache = &face_caches[skia_face->uniqueID()];
   if (face_cache->first.get() == NULL)
     face_cache->first.Init(skia_face);
 
   hb_font_t* harfbuzz_font = hb_font_create(face_cache->first.get());
-  const int scale = SkScalarToFixed(text_size);
+  const int scale = SkiaScalarToHarfBuzzUnits(text_size);
   hb_font_set_scale(harfbuzz_font, scale, scale);
   FontData* hb_font_data = new FontData(&face_cache->second);
   hb_font_data->paint_.setTypeface(skia_face);
   hb_font_data->paint_.setTextSize(text_size);
   // TODO(ckocagil): Do we need to update these params later?
   internal::ApplyRenderParams(params, subpixel_rendering_suppressed,
                               &hb_font_data->paint_);
   hb_font_set_funcs(harfbuzz_font, g_font_funcs.Get().get(), hb_font_data,
                     DeleteByType<FontData>);
   hb_font_make_immutable(harfbuzz_font);
   return harfbuzz_font;
 }
 
 }  // namespace gfx