ui: Fix cc/paint skia type mismatches

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>
@@ skipping 15 matching lines @@
 // Maps from code points to glyph indices in a font.
 typedef std::map<uint32_t, uint16_t> GlyphCache;
 
 typedef std::pair<HarfBuzzFace, GlyphCache> FaceCache;
 
 // Font data provider for HarfBuzz using Skia. Copied from Blink.
 // TODO(ckocagil): Eliminate the duplication. http://crbug.com/368375
 struct FontData {
   FontData(GlyphCache* glyph_cache) : glyph_cache_(glyph_cache) {}
 
-  SkPaint paint_;
+  cc::PaintFlags flags_;
   GlyphCache* glyph_cache_;
 };
 
 // Deletes the object at the given pointer after casting it to the given type.
 template<typename Type>
 void DeleteByType(void* data) {
   Type* typed_data = reinterpret_cast<Type*>(data);
   delete typed_data;
 }
 
 template<typename Type>
 void DeleteArrayByType(void* data) {
   Type* typed_data = reinterpret_cast<Type*>(data);
   delete[] typed_data;
 }
 
 // Outputs the |width| and |extents| of the glyph with index |codepoint| in
 // |paint|'s font.
-void GetGlyphWidthAndExtents(SkPaint* paint,
+void GetGlyphWidthAndExtents(cc::PaintFlags* flags,
                              hb_codepoint_t codepoint,
                              hb_position_t* width,
                              hb_glyph_extents_t* extents) {
+  SkPaint paint(cc::ToSkPaint(*flags));
+
   DCHECK_LE(codepoint, std::numeric_limits<uint16_t>::max());
-  paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+  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);
+  paint.getTextWidths(&glyph, sizeof(glyph), &sk_width, &sk_bounds);
   if (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 = 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,
                    void* user_data) {
   FontData* font_data = reinterpret_cast<FontData*>(data);
   GlyphCache* cache = font_data->glyph_cache_;
 
   bool exists = cache->count(unicode) != 0;
   if (!exists) {
-    SkPaint* paint = &font_data->paint_;
-    paint->setTextEncoding(SkPaint::kUTF32_TextEncoding);
-    paint->textToGlyphs(&unicode, sizeof(hb_codepoint_t), &(*cache)[unicode]);
+    font_data->flags_.setTextEncoding(cc::PaintFlags::kUTF32_TextEncoding);
+    SkPaint paint(cc::ToSkPaint(font_data->flags_));

[enne (OOO), 2017/02/27 01:56:21]

Similar to my comments on https://codereview.chromium.org/2716203002 about text
intercepts, I think cc/paint should should only be about recording, and anything
related to glyphs and rastering and actual text should be deferred to Skia. 
Hence, converting back to SkPaint types here.

+    paint.textToGlyphs(&unicode, sizeof(hb_codepoint_t), &(*cache)[unicode]);
   }
   *glyph = (*cache)[unicode];
   return !!*glyph;
 }
 
 // Returns the horizontal advance value of the |glyph|.
 hb_position_t GetGlyphHorizontalAdvance(hb_font_t* font,
                                         void* data,
                                         hb_codepoint_t glyph,
                                         void* user_data) {
   FontData* font_data = reinterpret_cast<FontData*>(data);
   hb_position_t advance = 0;
 
-  GetGlyphWidthAndExtents(&font_data->paint_, glyph, &advance, 0);
+  GetGlyphWidthAndExtents(&font_data->flags_, glyph, &advance, 0);
   return advance;
 }
 
 hb_bool_t GetGlyphHorizontalOrigin(hb_font_t* font,
                                    void* data,
                                    hb_codepoint_t glyph,
                                    hb_position_t* x,
                                    hb_position_t* y,
                                    void* user_data) {
   // Just return true, like the HarfBuzz-FreeType implementation.
   return true;
 }
 
 hb_position_t GetGlyphKerning(FontData* font_data,
                               hb_codepoint_t first_glyph,
                               hb_codepoint_t second_glyph) {
-  SkTypeface* typeface = font_data->paint_.getTypeface();
+  SkTypeface* typeface = font_data->flags_.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();
+  SkScalar size = font_data->flags_.getTextSize();
   return SkiaScalarToHarfBuzzUnits(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()) {
+  if (font_data->flags_.isVerticalText()) {
     // We don't support cross-stream kerning.
     return 0;
   }
 
   return GetGlyphKerning(font_data, left_glyph, right_glyph);
 }
 
 hb_position_t GetGlyphVerticalKerning(hb_font_t* font,
                                       void* data,
                                       hb_codepoint_t top_glyph,
                                       hb_codepoint_t bottom_glyph,
                                       void* user_data) {
   FontData* font_data = reinterpret_cast<FontData*>(data);
-  if (!font_data->paint_.isVerticalText()) {
+  if (!font_data->flags_.isVerticalText()) {
     // We don't support cross-stream kerning.
     return 0;
   }
 
   return GetGlyphKerning(font_data, top_glyph, bottom_glyph);
 }
 
 // Writes the |extents| of |glyph|.
 hb_bool_t GetGlyphExtents(hb_font_t* font,
                           void* data,
                           hb_codepoint_t glyph,
                           hb_glyph_extents_t* extents,
                           void* user_data) {
   FontData* font_data = reinterpret_cast<FontData*>(data);
 
-  GetGlyphWidthAndExtents(&font_data->paint_, glyph, 0, extents);
+  GetGlyphWidthAndExtents(&font_data->flags_, glyph, 0, extents);
   return true;
 }
 
 class FontFuncs {
  public:
   FontFuncs() : font_funcs_(hb_font_funcs_create()) {
     hb_font_funcs_set_glyph_func(font_funcs_, GetGlyph, 0, 0);
     hb_font_funcs_set_glyph_h_advance_func(
         font_funcs_, GetGlyphHorizontalAdvance, 0, 0);
     hb_font_funcs_set_glyph_h_kerning_func(
@@ skipping 81 matching lines @@
   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.get());
 
   hb_font_t* harfbuzz_font = hb_font_create(face_cache->first.get());
   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(std::move(skia_face));
-  hb_font_data->paint_.setTextSize(text_size);
+  hb_font_data->flags_.setTypeface(std::move(skia_face));
+  hb_font_data->flags_.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_data->flags_);
   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