update callers to not use SkColorProfileType

src/core/SkLinearBitmapPipeline.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLinearBitmapPipeline.h"
 
 #include <algorithm>
@@ skipping 549 matching lines @@
     };
 
     const uint32_t* const fSrc;
     const int32_t         fWidth;
     uint32_t*             fDest;
     uint32_t*             fEnd;
 };
 
 using Blender = SkLinearBitmapPipeline::BlendProcessorInterface;
 
-template <SkColorType colorType, template <SkColorType, SkColorProfileType, typename> class Sampler>
+template <SkColorType colorType, template <SkColorType, SkGammaType, typename> class Sampler>
 static void choose_specific_sampler(
     Blender* next,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage)
 {
-    if (srcPixmap.info().profileType() == kSRGB_SkColorProfileType) {
-        using S = Sampler<colorType, kSRGB_SkColorProfileType, Blender>;
+    if (srcPixmap.info().gammaCloseToSRGB()) {
+        using S = Sampler<colorType, kSRGB_SkGammaType, Blender>;
         sampleStage->initStage<S>(next, srcPixmap);
     } else {
-        using S = Sampler<colorType, kLinear_SkColorProfileType, Blender>;
+        using S = Sampler<colorType, kLinear_SkGammaType, Blender>;
         sampleStage->initStage<S>(next, srcPixmap);
     }
 }
 
-template<template <SkColorType, SkColorProfileType, typename> class Sampler>
+template<template <SkColorType, SkGammaType, typename> class Sampler>
 static SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler_base(
     Blender* next,
     const SkPixmap& srcPixmap,
     const SkColor A8TintColor,
     SkLinearBitmapPipeline::SampleStage* sampleStage)
 {
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
         case kAlpha_8_SkColorType: {
-                using S = Sampler<kAlpha_8_SkColorType, kLinear_SkColorProfileType, Blender>;
+                using S = Sampler<kAlpha_8_SkColorType, kLinear_SkGammaType, Blender>;
                 sampleStage->initStage<S>(next, srcPixmap, A8TintColor);
             }
             break;
         case kARGB_4444_SkColorType:
             choose_specific_sampler<kARGB_4444_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kRGB_565_SkColorType:
             choose_specific_sampler<kRGB_565_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kRGBA_8888_SkColorType:
             choose_specific_sampler<kRGBA_8888_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kBGRA_8888_SkColorType:
             choose_specific_sampler<kBGRA_8888_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kIndex_8_SkColorType:
             choose_specific_sampler<kIndex_8_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kGray_8_SkColorType:
             choose_specific_sampler<kGray_8_SkColorType, Sampler>(next, srcPixmap, sampleStage);
             break;
         case kRGBA_F16_SkColorType: {
-                using S = Sampler<kRGBA_F16_SkColorType, kLinear_SkColorProfileType, Blender>;
+                using S = Sampler<kRGBA_F16_SkColorType, kLinear_SkGammaType, Blender>;
                 sampleStage->initStage<S>(next, srcPixmap);
             }
             break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
@@ skipping 136 matching lines @@
         && srcPixmap.info().alphaType() == kOpaque_SkAlphaType) {
         xferMode = SkXfermode::kSrc_Mode;
     }
 
     if (matrixMask & ~SkMatrix::kTranslate_Mask ) { return false; }
     if (filterQuality != SkFilterQuality::kNone_SkFilterQuality) { return false; }
     if (finalAlpha != 1.0f) { return false; }
     if (srcPixmap.info().colorType() != kRGBA_8888_SkColorType
         || dstInfo.colorType() != kRGBA_8888_SkColorType) { return false; }
 
-    if (srcPixmap.info().profileType() != kSRGB_SkColorProfileType
-        || dstInfo.profileType() != kSRGB_SkColorProfileType) { return false; }
+    if (!srcPixmap.info().gammaCloseToSRGB() || !dstInfo.gammaCloseToSRGB()) {
+        return false;
+    }
 
     if (xferMode != SkXfermode::kSrc_Mode && xferMode != SkXfermode::kSrcOver_Mode) {
         return false;
     }
 
     pipelineStorage->init(pipeline, srcPixmap, xferMode, dstInfo);
 
     return true;
 }
 
@@ skipping 33 matching lines @@
 void SkLinearBitmapPipeline::blitSpan(int x, int y, void* dst, int count) {
     SkASSERT(count > 0);
     fLastStage->setDestination(dst, count);
 
     // The count and length arguments start out in a precise relation in order to keep the
     // math correct through the different stages. Count is the number of pixel to produce.
     // Since the code samples at pixel centers, length is the distance from the center of the
     // first pixel to the center of the last pixel. This implies that length is count-1.
     fFirstStage->pointSpan(Span{{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }