update callers to not use SkColorProfileType

bench/SkLinearBitmapPipelineBench.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 <memory>
 #include "SkColor.h"
 #include "SkLinearBitmapPipeline.h"
 #include "SkBitmapProcShader.h"
 #include "SkPM4f.h"
 #include "Benchmark.h"
 #include "SkShader.h"
 #include "SkImage.h"
 
 struct CommonBitmapFPBenchmark : public Benchmark {
     CommonBitmapFPBenchmark(
         SkISize srcSize,
-        SkColorProfileType colorProfile,
+        bool isSRGB,
         SkMatrix m,
         bool useBilerp,
         SkShader::TileMode xTile,
         SkShader::TileMode yTile)
-        : fColorProfile(colorProfile)
+        : fIsSRGB(isSRGB)
         , fM{m}
         , fUseBilerp{useBilerp}
         , fXTile{xTile}
         , fYTile{yTile} {
         fSrcSize = srcSize;
     }
 
     static SkString tileName(const char* pre, SkShader::TileMode mode) {
         SkString name{pre};
         switch (mode) {
@@ skipping 46 matching lines @@
         fBitmap.reset(new uint32_t[width * height]);
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
                 fBitmap[y * width + x] = (y << 8) + x + (128<<24);
             }
         }
 
         bool trash = fM.invert(&fInvert);
         sk_ignore_unused_variable(trash);
 
-        fInfo = SkImageInfo::MakeN32Premul(width, height, fColorProfile);
+        fInfo = SkImageInfo::MakeN32Premul(width, height, fIsSRGB ?
+                                       SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named) : nullptr);
     }
 
     bool isSuitableFor(Backend backend) override {
         return backend == kNonRendering_Backend;
     }
 
     virtual SkString BaseName() = 0;
 
     SkString fName;
     SkISize fSrcSize;
-    SkColorProfileType fColorProfile;
+    bool fIsSRGB;
     SkMatrix fM;
     SkMatrix fInvert;
     bool fUseBilerp;
     SkShader::TileMode fXTile;
     SkShader::TileMode fYTile;
     SkImageInfo fInfo;
     std::unique_ptr<uint32_t[]> fBitmap;
 };
 
 struct SkBitmapFPGeneral final : public CommonBitmapFPBenchmark {
     SkBitmapFPGeneral(
         SkISize srcSize,
-        SkColorProfileType colorProfile,
+        bool isSRGB,
         SkMatrix m,
         bool useBilerp,
         SkShader::TileMode xTile,
         SkShader::TileMode yTile)
-            : CommonBitmapFPBenchmark(srcSize, colorProfile, m, useBilerp, xTile, yTile) { }
+            : CommonBitmapFPBenchmark(srcSize, isSRGB, m, useBilerp, xTile, yTile) { }
 
     SkString BaseName() override {
         SkString name;
-        if (fInfo.isSRGB()) {
+        if (fInfo.gammaCloseToSRGB()) {
             name.set("sRGB");
         } else {
             name.set("Linr");
         }
         return name;
     }
 
     void onDraw(int loops, SkCanvas*) override {
         int width = fSrcSize.fWidth;
         int height = fSrcSize.fHeight;
@@ skipping 16 matching lines @@
 
         for (int n = 0; n < 1000*loops; n++) {
             pipeline.shadeSpan4f(3, 6, FPbuffer, count);
         }
     }
 };
 
 struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark {
     SkBitmapFPOrigShader(
         SkISize srcSize,
-        SkColorProfileType colorProfile,
+        bool isSRGB,
         SkMatrix m,
         bool useBilerp,
         SkShader::TileMode xTile,
         SkShader::TileMode yTile)
-            : CommonBitmapFPBenchmark(srcSize, colorProfile, m, useBilerp, xTile, yTile) { }
+            : CommonBitmapFPBenchmark(srcSize, isSRGB, m, useBilerp, xTile, yTile) { }
 
     SkString BaseName() override {
         SkString name{"Orig"};
         return name;
     }
 
     void onPreDraw(SkCanvas* c) override {
         CommonBitmapFPBenchmark::onPreDraw(c);
 
         fImage = SkImage::MakeRasterCopy(
@@ skipping 27 matching lines @@
         for (int n = 0; n < 1000*loops; n++) {
             ctx->shadeSpan(3, 6, buffer4b, count);
         }
 
         ctx->~Context();
     }
     SkPaint fPaint;
     sk_sp<SkImage> fImage;
 };
 
+const bool gSRGB = true;
+const bool gLinearRGB = false;
 static SkISize srcSize = SkISize::Make(120, 100);
 static SkMatrix mI = SkMatrix::I();
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mI, false,
+    srcSize, gSRGB, mI, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mI, false,
+    srcSize, gLinearRGB, mI, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mI, false,
+    srcSize, gLinearRGB, mI, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mI, true,
+    srcSize, gSRGB, mI, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mI, true,
+    srcSize, gLinearRGB, mI, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mI, true,
+    srcSize, gLinearRGB, mI, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 static SkMatrix mS = SkMatrix::MakeScale(2.7f, 2.7f);
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mS, false,
+    srcSize, gSRGB, mS, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mS, false,
+    srcSize, gLinearRGB, mS, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mS, false,
+    srcSize, gLinearRGB, mS, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mS, true,
+    srcSize, gSRGB, mS, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mS, true,
+    srcSize, gLinearRGB, mS, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mS, true,
+    srcSize, gLinearRGB, mS, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 // Repeat
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mS, false,
+    srcSize, gSRGB, mS, false,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mS, false,
+    srcSize, gLinearRGB, mS, false,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mS, false,
+    srcSize, gLinearRGB, mS, false,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mS, true,
+    srcSize, gSRGB, mS, true,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mS, true,
+    srcSize, gLinearRGB, mS, true,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mS, true,
+    srcSize, gLinearRGB, mS, true,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 static SkMatrix rotate(SkScalar r) {
     SkMatrix m;
     m.setRotate(30);
     return m;
 }
 
 static SkMatrix mR = rotate(30);
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mR, false,
+    srcSize, gSRGB, mR, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mR, false,
+    srcSize, gLinearRGB, mR, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mR, false,
+    srcSize, gLinearRGB, mR, false,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mR, true,
+    srcSize, gSRGB, mR, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mR, true,
+    srcSize, gLinearRGB, mR, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mR, true,
+    srcSize, gLinearRGB, mR, true,
     SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
 
 // Repeat
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mR, false,
+    srcSize, gSRGB, mR, false,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mR, false,
+    srcSize, gLinearRGB, mR, false,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mR, false,
+    srcSize, gLinearRGB, mR, false,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kSRGB_SkColorProfileType, mR, true,
+    srcSize, gSRGB, mR, true,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPGeneral(
-    srcSize, kLinear_SkColorProfileType, mR, true,
+    srcSize, gLinearRGB, mR, true,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
 
 DEF_BENCH(return new SkBitmapFPOrigShader(
-    srcSize, kLinear_SkColorProfileType, mR, true,
+    srcSize, gLinearRGB, mR, true,
     SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)