update callers to not use SkColorProfileType

src/core/SkLinearBitmapPipeline_sample.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLinearBitmapPipeline_sampler_DEFINED
 #define SkLinearBitmapPipeline_sampler_DEFINED
 
@@ skipping 37 matching lines @@
     Sk4f sum = px11 * fxys;
     sum = sum + px01 * (fys - fxys);
     sum = sum + px10 * (fxs - fxys);
     sum = sum + px00 * (Sk4f{1.0f} - fxs - fys + fxys);
     return sum;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // PixelGetter is the lowest level interface to the source data. There is a PixelGetter for each
 // of the different SkColorTypes.
-template <SkColorType colorType, SkColorProfileType colorProfile> class PixelGetter;
+template <SkColorType, SkGammaType> class PixelGetter;
 
 // Alpha handling:
 //   The alpha from the paint (tintColor) is used in the blend part of the pipeline to modulate
 // the entire bitmap. So, the tint color is given an alpha of 1.0 so that the later alpha can
 // modulate this color later.
 template <>
-class PixelGetter<kAlpha_8_SkColorType, kLinear_SkColorProfileType> {
+class PixelGetter<kAlpha_8_SkColorType, kLinear_SkGammaType> {
 public:
     using Element = uint8_t;
     PixelGetter(const SkPixmap& srcPixmap, SkColor tintColor)
         : fTintColor{set_alpha(Sk4f_from_SkColor(tintColor), 1.0f)} { }
 
     Sk4f getPixelAt(const uint8_t* src) {
         return fTintColor * (*src * (1.0f/255.0f));
     }
 
 private:
     const Sk4f fTintColor;
 };
 
-template <SkColorProfileType colorProfile>
-class PixelGetter<kRGB_565_SkColorType, colorProfile> {
+template <SkGammaType gammaType>
+class PixelGetter<kRGB_565_SkColorType, gammaType> {
 public:
     using Element = uint16_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint16_t* src) {
         SkPMColor pixel = SkPixel16ToPixel32(*src);
-        return colorProfile == kSRGB_SkColorProfileType
+        return gammaType == kSRGB_SkGammaType
                ? Sk4f_fromS32(pixel)
                : Sk4f_fromL32(pixel);
     }
 };
 
-template <SkColorProfileType colorProfile>
-class PixelGetter<kARGB_4444_SkColorType, colorProfile> {
+template <SkGammaType gammaType>
+class PixelGetter<kARGB_4444_SkColorType, gammaType> {
 public:
     using Element = uint16_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint16_t* src) {
         SkPMColor pixel = SkPixel4444ToPixel32(*src);
-        return colorProfile == kSRGB_SkColorProfileType
+        return gammaType == kSRGB_SkGammaType
                ? Sk4f_fromS32(pixel)
                : Sk4f_fromL32(pixel);
     }
 };
 
-template <SkColorProfileType colorProfile>
-class PixelGetter<kRGBA_8888_SkColorType, colorProfile> {
+template <SkGammaType gammaType>
+class PixelGetter<kRGBA_8888_SkColorType, gammaType> {
 public:
     using Element = uint32_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint32_t* src) {
-        return colorProfile == kSRGB_SkColorProfileType
+        return gammaType == kSRGB_SkGammaType
                ? Sk4f_fromS32(*src)
                : Sk4f_fromL32(*src);
     }
 };
 
-template <SkColorProfileType colorProfile>
-class PixelGetter<kBGRA_8888_SkColorType, colorProfile> {
+template <SkGammaType gammaType>
+class PixelGetter<kBGRA_8888_SkColorType, gammaType> {
 public:
     using Element = uint32_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint32_t* src) {
-        Sk4f pixel = colorProfile == kSRGB_SkColorProfileType
+        Sk4f pixel = gammaType == kSRGB_SkGammaType
                      ? Sk4f_fromS32(*src)
                      : Sk4f_fromL32(*src);
         return swizzle_rb(pixel);
     }
 };
 
-template <SkColorProfileType colorProfile>
-class PixelGetter<kIndex_8_SkColorType, colorProfile> {
+template <SkGammaType gammaType>
+class PixelGetter<kIndex_8_SkColorType, gammaType> {
 public:
     using Element = uint8_t;
     PixelGetter(const SkPixmap& srcPixmap) {
         SkColorTable* skColorTable = srcPixmap.ctable();
         SkASSERT(skColorTable != nullptr);
 
         fColorTable = (Sk4f*)SkAlign16((intptr_t)fColorTableStorage.get());
         for (int i = 0; i < skColorTable->count(); i++) {
             fColorTable[i] = this->convertPixel((*skColorTable)[i]);
         }
@@ skipping 13 matching lines @@
 
 private:
     static const size_t kColorTableSize = sizeof(Sk4f[256]) + 12;
     Sk4f convertPixel(SkPMColor pmColor) {
         Sk4f pixel = to_4f(pmColor);
         float alpha = get_alpha(pixel);
         if (alpha != 0.0f) {
             float invAlpha = 1.0f / alpha;
             Sk4f normalize = {invAlpha, invAlpha, invAlpha, 1.0f / 255.0f};
             pixel = pixel * normalize;
-            if (colorProfile == kSRGB_SkColorProfileType) {
+            if (gammaType == kSRGB_SkGammaType) {
                 pixel = linear_to_srgb(pixel);
             }
             return pixel;
         } else {
             return Sk4f{0.0f};
         }
     }
     SkAutoMalloc         fColorTableStorage{kColorTableSize};
     Sk4f*                fColorTable;
 };
 
-template <SkColorProfileType colorProfile>
-class PixelGetter<kGray_8_SkColorType, colorProfile> {
+template <SkGammaType gammaType>
+class PixelGetter<kGray_8_SkColorType, gammaType> {
 public:
     using Element = uint8_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint8_t* src) {
         float gray = *src * (1.0f/255.0f);
         Sk4f pixel = Sk4f{gray, gray, gray, 1.0f};
-        return colorProfile == kSRGB_SkColorProfileType
+        return gammaType == kSRGB_SkGammaType
                ? srgb_to_linear(pixel)
                : pixel;
     }
 };
 
 template <>
-class PixelGetter<kRGBA_F16_SkColorType, kLinear_SkColorProfileType> {
+class PixelGetter<kRGBA_F16_SkColorType, kLinear_SkGammaType> {
 public:
     using Element = uint64_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint64_t* src) {
         return SkHalfToFloat_01(*src);
     }
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // PixelAccessor handles all the same plumbing for all the PixelGetters.
-template <SkColorType colorType, SkColorProfileType colorProfile>
+template <SkColorType colorType, SkGammaType gammaType>
 class PixelAccessor {
-    using Element = typename PixelGetter<colorType, colorProfile>::Element;
+    using Element = typename PixelGetter<colorType, gammaType>::Element;
 public:
     template <typename... Args>
     PixelAccessor(const SkPixmap& srcPixmap, Args&&... args)
         : fSrc{static_cast<const Element*>(srcPixmap.addr())}
         , fWidth{srcPixmap.rowBytesAsPixels()}
         , fGetter{srcPixmap, std::move<Args>(args)...} { }
 
     void VECTORCALL getFewPixels(int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
         Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
         Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
@@ skipping 34 matching lines @@
 
     Sk4f getPixelAt(int index) {
         return this->getPixelFromRow(fSrc, index);
     }
 
     const void* row(int y) const { return fSrc + y * fWidth[0]; }
 
 private:
     const Element* const                 fSrc;
     const Sk4i                           fWidth;
-    PixelGetter<colorType, colorProfile> fGetter;
+    PixelGetter<colorType, gammaType> fGetter;
 };
 
 // We're moving through source space at a rate of 1 source pixel per 1 dst pixel.
 // We'll never re-use pixels, but we can at least load contiguous pixels.
 template <typename Next, typename Strategy>
 static void src_strategy_blend(Span span, Next* next, Strategy* strategy) {
     SkPoint start;
     SkScalar length;
     int count;
     std::tie(start, length, count) = span;
@@ skipping 24 matching lines @@
 
         while (count > 0) {
             next->blendPixel(strategy->getPixelFromRow(row, ix));
             ix -= 1;
             count -= 1;
         }
     }
 }
 
 // NearestNeighborSampler - use nearest neighbor filtering to create runs of destination pixels.
-template<SkColorType colorType, SkColorProfileType colorProfile, typename Next>
+template<SkColorType colorType, SkGammaType gammaType, typename Next>
 class NearestNeighborSampler : public SkLinearBitmapPipeline::SampleProcessorInterface {
 public:
     template<typename... Args>
     NearestNeighborSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
     : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
 
     NearestNeighborSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
     const NearestNeighborSampler& sampler)
     : fNext{next}, fStrategy{sampler.fStrategy} { }
 
@@ skipping 95 matching lines @@
     void spanUnitRate(Span span) {
         src_strategy_blend(span, fNext, &fStrategy);
     }
 
     // We're moving through source space faster than dst (zoomed out),
     // so we'll never reuse a source pixel or be able to do contiguous loads.
     void spanFastRate(Span span) {
         span_fallback(span, this);
     }
 
-    Next* const                            fNext;
-    PixelAccessor<colorType, colorProfile> fStrategy;
+    Next* const                         fNext;
+    PixelAccessor<colorType, gammaType> fStrategy;
 };
 
 // -- BilerpSampler --------------------------------------------------------------------------------
 // BilerpSampler - use a bilerp filter to create runs of destination pixels.
-template<SkColorType colorType, SkColorProfileType colorProfile, typename Next>
+template<SkColorType colorType, SkGammaType gammaType, typename Next>
 class BilerpSampler : public SkLinearBitmapPipeline::SampleProcessorInterface {
 public:
     template<typename... Args>
     BilerpSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
         : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
 
     BilerpSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
                    const BilerpSampler& sampler)
         : fNext{next}, fStrategy{sampler.fStrategy} { }
 
@@ skipping 350 matching lines @@
             Sk4f ys = {y - 0.5f, y - 0.5f, y1 + 0.5f, y1 + 0.5f};
             while (count > 0) {
                 Sk4f xs = Sk4f{-0.5f, 0.5f, -0.5f, 0.5f} + Sk4f{x};
                 this->bilerpEdge(xs, ys);
                 x += dx;
                 count -= 1;
             }
         }
     }
 
-    Next* const                            fNext;
-    PixelAccessor<colorType, colorProfile> fStrategy;
+    Next* const                         fNext;
+    PixelAccessor<colorType, gammaType> fStrategy;
 };
 
 }  // namespace
 
 #endif  // SkLinearBitmapPipeline_sampler_DEFINED