use expected name for setDrawLooper/getDrawLooper

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAutoKern.h"
 #include "SkColorFilter.h"
@@ skipping 55 matching lines @@
 
 SkPaint::SkPaint(const SkPaint& src)
 #define COPY(field) field(src.field)
     : COPY(fTypeface)
     , COPY(fPathEffect)
     , COPY(fShader)
     , COPY(fXfermode)
     , COPY(fMaskFilter)
     , COPY(fColorFilter)
     , COPY(fRasterizer)
-    , COPY(fLooper)
+    , COPY(fDrawLooper)
     , COPY(fImageFilter)
     , COPY(fTextSize)
     , COPY(fTextScaleX)
     , COPY(fTextSkewX)
     , COPY(fColor)
     , COPY(fWidth)
     , COPY(fMiterLimit)
     , COPY(fBitfields)
 #undef COPY
 {}
 
 SkPaint::SkPaint(SkPaint&& src) {
 #define MOVE(field) field = std::move(src.field)
     MOVE(fTypeface);
     MOVE(fPathEffect);
     MOVE(fShader);
     MOVE(fXfermode);
     MOVE(fMaskFilter);
     MOVE(fColorFilter);
     MOVE(fRasterizer);
-    MOVE(fLooper);
+    MOVE(fDrawLooper);
     MOVE(fImageFilter);
     MOVE(fTextSize);
     MOVE(fTextScaleX);
     MOVE(fTextSkewX);
     MOVE(fColor);
     MOVE(fWidth);
     MOVE(fMiterLimit);
     MOVE(fBitfields);
 #undef MOVE
 }
 
 SkPaint::~SkPaint() {}
 
 SkPaint& SkPaint::operator=(const SkPaint& src) {
     if (this == &src) {
         return *this;
     }
 
 #define ASSIGN(field) field = src.field
     ASSIGN(fTypeface);
     ASSIGN(fPathEffect);
     ASSIGN(fShader);
     ASSIGN(fXfermode);
     ASSIGN(fMaskFilter);
     ASSIGN(fColorFilter);
     ASSIGN(fRasterizer);
-    ASSIGN(fLooper);
+    ASSIGN(fDrawLooper);
     ASSIGN(fImageFilter);
     ASSIGN(fTextSize);
     ASSIGN(fTextScaleX);
     ASSIGN(fTextSkewX);
     ASSIGN(fColor);
     ASSIGN(fWidth);
     ASSIGN(fMiterLimit);
     ASSIGN(fBitfields);
 #undef ASSIGN
 
     return *this;
 }
 
 SkPaint& SkPaint::operator=(SkPaint&& src) {
     if (this == &src) {
         return *this;
     }
 
 #define MOVE(field) field = std::move(src.field)
     MOVE(fTypeface);
     MOVE(fPathEffect);
     MOVE(fShader);
     MOVE(fXfermode);
     MOVE(fMaskFilter);
     MOVE(fColorFilter);
     MOVE(fRasterizer);
-    MOVE(fLooper);
+    MOVE(fDrawLooper);
     MOVE(fImageFilter);
     MOVE(fTextSize);
     MOVE(fTextScaleX);
     MOVE(fTextSkewX);
     MOVE(fColor);
     MOVE(fWidth);
     MOVE(fMiterLimit);
     MOVE(fBitfields);
 #undef MOVE
 
     return *this;
 }
 
 bool operator==(const SkPaint& a, const SkPaint& b) {
 #define EQUAL(field) (a.field == b.field)
     return EQUAL(fTypeface)
         && EQUAL(fPathEffect)
         && EQUAL(fShader)
         && EQUAL(fXfermode)
         && EQUAL(fMaskFilter)
         && EQUAL(fColorFilter)
         && EQUAL(fRasterizer)
-        && EQUAL(fLooper)
+        && EQUAL(fDrawLooper)
         && EQUAL(fImageFilter)
         && EQUAL(fTextSize)
         && EQUAL(fTextScaleX)
         && EQUAL(fTextSkewX)
         && EQUAL(fColor)
         && EQUAL(fWidth)
         && EQUAL(fMiterLimit)
         && EQUAL(fBitfieldsUInt)
         ;
 #undef EQUAL
@@ skipping 171 matching lines @@
 
 #define MOVE_FIELD(Field) void SkPaint::set##Field(sk_sp<Sk##Field> f) { f##Field = std::move(f); }
 MOVE_FIELD(Typeface)
 MOVE_FIELD(Rasterizer)
 MOVE_FIELD(ImageFilter)
 MOVE_FIELD(Shader)
 MOVE_FIELD(ColorFilter)
 MOVE_FIELD(Xfermode)
 MOVE_FIELD(PathEffect)
 MOVE_FIELD(MaskFilter)
+MOVE_FIELD(DrawLooper)
 #undef MOVE_FIELD
-void SkPaint::setLooper(sk_sp<SkDrawLooper> looper) { fLooper = std::move(looper); }
+void SkPaint::setLooper(sk_sp<SkDrawLooper> looper) { fDrawLooper = std::move(looper); }
 
 #define SET_PTR(Field)                              \
     Sk##Field* SkPaint::set##Field(Sk##Field* f) {  \
         this->f##Field.reset(SkSafeRef(f));         \
         return f;                                   \
     }
 #ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
 SET_PTR(Typeface)
 #endif
 #ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
@@ skipping 1974 matching lines @@
 }
 
 // return true if the filter exists, and may affect alpha
 static bool affects_alpha(const SkImageFilter* imf) {
     // TODO: check if we should allow imagefilters to broadcast that they don't affect alpha
     // ala colorfilters
     return imf != nullptr;
 }
 
 bool SkPaint::nothingToDraw() const {
-    if (fLooper) {
+    if (fDrawLooper) {
         return false;
     }
     SkXfermode::Mode mode;
     if (SkXfermode::AsMode(fXfermode.get(), &mode)) {
         switch (mode) {
             case SkXfermode::kSrcOver_Mode:
             case SkXfermode::kSrcATop_Mode:
             case SkXfermode::kDstOut_Mode:
             case SkXfermode::kDstOver_Mode:
             case SkXfermode::kPlus_Mode:
@@ skipping 11 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     static_assert(offsetof(SkPaint, fBitfields) == 9 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkOpts::hash(reinterpret_cast<const uint32_t*>(this),
                         offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }