Make cc/paint have concrete types

cc/paint/paint_flags.h

 // Copyright 2017 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.
 
 #ifndef CC_PAINT_PAINT_FLAGS_H_
 #define CC_PAINT_PAINT_FLAGS_H_
 
+#include "base/compiler_specific.h"
+#include "cc/paint/paint_shader.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
+#include "third_party/skia/include/core/SkMaskFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkPathEffect.h"
+#include "third_party/skia/include/core/SkTypeface.h"
 
 namespace cc {
 
-using PaintFlags = SkPaint;
-
-inline const SkPaint& ToSkPaint(const PaintFlags& flags) {
-  return flags;
+class CC_PAINT_EXPORT PaintFlags {
+ public:
+  PaintFlags() = default;

[vmpstr, 2017/03/03 07:12:08]

I don't think you need to declare any ctors or assignment ops. As far as I can
tell the stuff here is all going to be automatically generated anyway (plus a
move ctor which right now is not generated due to dtor and copy ctor). Or did I
miss a subtlety somewhere?

+  ~PaintFlags() = default;
+
+  PaintFlags(const PaintFlags& flags) : paint_(flags.paint_) {}
+  PaintFlags& operator=(const PaintFlags& flags) {
+    paint_ = flags.paint_;
+    return *this;
+  }
+
+  enum Style {
+    kFill_Style = SkPaint::kFill_Style,
+    kStroke_Style = SkPaint::kStroke_Style,
+    kStrokeAndFill_Style = SkPaint::kStrokeAndFill_Style,
+  };
+  ALWAYS_INLINE Style getStyle() const {
+    return static_cast<Style>(paint_.getStyle());
+  }
+  ALWAYS_INLINE void setStyle(Style style) {
+    paint_.setStyle(static_cast<SkPaint::Style>(style));
+  }
+  ALWAYS_INLINE SkColor getColor() const { return paint_.getColor(); }
+  ALWAYS_INLINE void setColor(SkColor color) { paint_.setColor(color); }
+  ALWAYS_INLINE void setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
+    paint_.setARGB(a, r, g, b);
+  }
+  ALWAYS_INLINE uint8_t getAlpha() const { return paint_.getAlpha(); }
+  ALWAYS_INLINE void setAlpha(U8CPU a) { paint_.setAlpha(a); }
+  ALWAYS_INLINE void setBlendMode(SkBlendMode mode) {
+    paint_.setBlendMode(mode);
+  }
+  ALWAYS_INLINE SkBlendMode getBlendMode() const {
+    return paint_.getBlendMode();
+  }
+  ALWAYS_INLINE bool isSrcOver() const { return paint_.isSrcOver(); }
+  ALWAYS_INLINE bool isAntiAlias() const { return paint_.isAntiAlias(); }
+  ALWAYS_INLINE void setAntiAlias(bool aa) { paint_.setAntiAlias(aa); }
+  ALWAYS_INLINE bool isVerticalText() const { return paint_.isVerticalText(); }
+  ALWAYS_INLINE void setVerticalText(bool vertical) {
+    paint_.setVerticalText(vertical);
+  }
+  ALWAYS_INLINE bool isSubpixelText() const { return paint_.isSubpixelText(); }
+  ALWAYS_INLINE void setSubpixelText(bool subpixelText) {

[danakj, 2017/03/03 18:33:19]

sub_pixel_text

+    paint_.setSubpixelText(subpixelText);
+  }
+  ALWAYS_INLINE bool isLCDRenderText() const {
+    return paint_.isLCDRenderText();
+  }
+  ALWAYS_INLINE void setLCDRenderText(bool lcdText) {

[danakj, 2017/03/03 18:33:19]

lcd_text

+    paint_.setLCDRenderText(lcdText);
+  }
+  enum Hinting {
+    kNo_Hinting = SkPaint::kNo_Hinting,
+    kSlight_Hinting = SkPaint::kSlight_Hinting,
+    kNormal_Hinting = SkPaint::kNormal_Hinting,  //!< this is the default
+    kFull_Hinting = SkPaint::kFull_Hinting
+  };
+  ALWAYS_INLINE Hinting getHinting() const {
+    return static_cast<Hinting>(paint_.getHinting());
+  }
+  ALWAYS_INLINE void setHinting(Hinting hinting_level) {
+    paint_.setHinting(static_cast<SkPaint::Hinting>(hinting_level));
+  }
+  ALWAYS_INLINE bool isAutohinted() const { return paint_.isAutohinted(); }
+  ALWAYS_INLINE void setAutohinted(bool use_auto_hinter) {
+    paint_.setAutohinted(use_auto_hinter);
+  }
+  ALWAYS_INLINE bool isDither() const { return paint_.isDither(); }
+  ALWAYS_INLINE void setDither(bool dither) { paint_.setDither(dither); }
+  enum TextEncoding {
+    kUTF8_TextEncoding = SkPaint::kUTF8_TextEncoding,
+    kUTF16_TextEncoding = SkPaint::kUTF16_TextEncoding,
+    kUTF32_TextEncoding = SkPaint::kUTF32_TextEncoding,
+    kGlyphID_TextEncoding = SkPaint::kGlyphID_TextEncoding
+  };
+  ALWAYS_INLINE TextEncoding getTextEncoding() const {
+    return static_cast<TextEncoding>(paint_.getTextEncoding());
+  }
+  ALWAYS_INLINE void setTextEncoding(TextEncoding encoding) {
+    paint_.setTextEncoding(static_cast<SkPaint::TextEncoding>(encoding));
+  }
+  ALWAYS_INLINE SkScalar getTextSize() const { return paint_.getTextSize(); }
+  ALWAYS_INLINE void setTextSize(SkScalar textSize) {
+    paint_.setTextSize(textSize);
+  }
+  ALWAYS_INLINE void setFilterQuality(SkFilterQuality quality) {
+    paint_.setFilterQuality(quality);
+  }
+  ALWAYS_INLINE SkFilterQuality getFilterQuality() const {
+    return paint_.getFilterQuality();
+  }
+  ALWAYS_INLINE SkScalar getStrokeWidth() const {
+    return paint_.getStrokeWidth();
+  }
+  ALWAYS_INLINE void setStrokeWidth(SkScalar width) {
+    paint_.setStrokeWidth(width);
+  }
+  ALWAYS_INLINE SkScalar getStrokeMiter() const {
+    return paint_.getStrokeMiter();
+  }
+  ALWAYS_INLINE void setStrokeMiter(SkScalar miter) {
+    paint_.setStrokeMiter(miter);
+  }
+  enum Cap {
+    kButt_Cap = SkPaint::kButt_Cap,    //!< begin/end contours with no extension
+    kRound_Cap = SkPaint::kRound_Cap,  //!< begin/end contours with a
+                                       //! semi-circle extension
+    kSquare_Cap = SkPaint::kSquare_Cap,  //!< begin/end contours with a half
+                                         //! square extension
+    kLast_Cap = kSquare_Cap,
+    kDefault_Cap = kButt_Cap
+  };
+  ALWAYS_INLINE Cap getStrokeCap() const {
+    return static_cast<Cap>(paint_.getStrokeCap());
+  }
+  ALWAYS_INLINE void setStrokeCap(Cap cap) {
+    paint_.setStrokeCap(static_cast<SkPaint::Cap>(cap));
+  }
+  enum Join {
+    kMiter_Join = SkPaint::kMiter_Join,
+    kRound_Join = SkPaint::kRound_Join,
+    kBevel_Join = SkPaint::kBevel_Join,
+    kLast_Join = kBevel_Join,
+    kDefault_Join = kMiter_Join
+  };
+  ALWAYS_INLINE Join getStrokeJoin() const {
+    return static_cast<Join>(paint_.getStrokeJoin());
+  }
+  ALWAYS_INLINE void setStrokeJoin(Join join) {
+    paint_.setStrokeJoin(static_cast<SkPaint::Join>(join));
+  }
+  ALWAYS_INLINE SkTypeface* getTypeface() const { return paint_.getTypeface(); }
+  ALWAYS_INLINE void setTypeface(sk_sp<SkTypeface> typeface) {
+    paint_.setTypeface(std::move(typeface));
+  }
+  ALWAYS_INLINE SkColorFilter* getColorFilter() const {
+    return paint_.getColorFilter();
+  }
+  ALWAYS_INLINE void setColorFilter(sk_sp<SkColorFilter> filter) {
+    paint_.setColorFilter(std::move(filter));
+  }
+  ALWAYS_INLINE SkMaskFilter* getMaskFilter() const {
+    return paint_.getMaskFilter();
+  }
+  ALWAYS_INLINE void setMaskFilter(sk_sp<SkMaskFilter> mask) {
+    paint_.setMaskFilter(std::move(mask));
+  }
+  ALWAYS_INLINE PaintShader* getShader() const { return paint_.getShader(); }
+  ALWAYS_INLINE void setShader(sk_sp<PaintShader> shader) {
+    paint_.setShader(std::move(shader));
+  }
+  ALWAYS_INLINE SkPathEffect* getPathEffect() const {
+    return paint_.getPathEffect();
+  }
+  ALWAYS_INLINE void setPathEffect(sk_sp<SkPathEffect> effect) {
+    paint_.setPathEffect(std::move(effect));
+  }
+  ALWAYS_INLINE bool getFillPath(const SkPath& src,
+                                 SkPath* dst,
+                                 const SkRect* cullRect = nullptr,
+                                 SkScalar resScale = 1) const {
+    return paint_.getFillPath(src, dst, cullRect, resScale);
+  }
+  ALWAYS_INLINE sk_sp<SkImageFilter> refImageFilter() const {
+    return paint_.refImageFilter();
+  }
+  ALWAYS_INLINE SkImageFilter* getImageFilter() const {
+    return paint_.getImageFilter();
+  }
+  void setImageFilter(sk_sp<SkImageFilter> filter) {
+    paint_.setImageFilter(std::move(filter));
+  }
+  ALWAYS_INLINE SkDrawLooper* getDrawLooper() const {
+    return paint_.getDrawLooper();
+  }
+  ALWAYS_INLINE SkDrawLooper* getLooper() const { return paint_.getLooper(); }
+  ALWAYS_INLINE void setLooper(sk_sp<SkDrawLooper> looper) {
+    paint_.setLooper(std::move(looper));
+  }
+  ALWAYS_INLINE bool canComputeFastBounds() const {
+    return paint_.canComputeFastBounds();
+  }
+  ALWAYS_INLINE const SkRect& computeFastBounds(const SkRect& orig,
+                                                SkRect* storage) const {
+    return paint_.computeFastBounds(orig, storage);
+  }
+
+ private:
+  friend const SkPaint& ToSkPaint(const PaintFlags& flags);
+  friend const SkPaint* ToSkPaint(const PaintFlags* flags);
+
+  SkPaint paint_;
+};
+
+ALWAYS_INLINE const SkPaint& ToSkPaint(const PaintFlags& flags) {
+  return flags.paint_;
 }
 
+ALWAYS_INLINE const SkPaint* ToSkPaint(const PaintFlags* flags) {
+  return &flags->paint_;
+}
+
 }  // namespace cc
 
 #endif  // CC_PAINT_PAINT_FLAGS_H_