ui: Clean up naming of paint-related identifiers

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 "cc/paint/paint_flags.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;
 
 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) {}
 
-  cc::PaintFlags paint_;
+  SkPaint paint_;
   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(cc::PaintFlags* paint,
+void GetGlyphWidthAndExtents(SkPaint* paint,
                              hb_codepoint_t codepoint,
                              hb_position_t* width,
                              hb_glyph_extents_t* extents) {
   DCHECK_LE(codepoint, std::numeric_limits<uint16_t>::max());
-  paint->setTextEncoding(cc::PaintFlags::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);
   if (width)
     *width = SkiaScalarToHarfBuzzUnits(sk_width);
   if (extents) {
     // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be
@@ skipping 11 matching lines @@
                    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) {
-    cc::PaintFlags* paint = &font_data->paint_;
-    paint->setTextEncoding(cc::PaintFlags::kUTF32_TextEncoding);
+    SkPaint* paint = &font_data->paint_;
+    paint->setTextEncoding(SkPaint::kUTF32_TextEncoding);
     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,
@@ skipping 175 matching lines @@
   // 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