Revert "Remove deadcode for sRGB image shading."

This reverts commit 51f6a0f89e55b2c0f102aa7963320a23c586e71d.

Reason for revert: crazy attempt to fix chrome roll

Original change's description:
> Remove deadcode for sRGB image shading.
> 
> Change-Id: I9d98da67d97b64ab55cf44b9ae447882dccda1ca
> Reviewed-on: https://skia-review.googlesource.com/20695
> Reviewed-by: Mike Klein <mtklein@chromium.org>
> Commit-Queue: Herb Derby <herb@google.com>

TBR=mtklein@chromium.org,mtklein@google.com,herb@google.com,reed@google.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Change-Id: Icab02936d6c18e50b8de353aa1cd4c225e15e0bf
Reviewed-on: https://skia-review.googlesource.com/20800
Reviewed-by: Mike Reed <reed@google.com>

1 files changed, 354 insertions, 0 deletions

diff --git a/bench/SkLinearBitmapPipelineBench.cpp b/bench/SkLinearBitmapPipelineBench.cpp
new file mode 100644
index 0000000000..f8919bf61b
--- /dev/null
+++ b/bench/SkLinearBitmapPipelineBench.cpp
@@ -0,0 +1,354 @@
+/*
+ * 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 "Benchmark.h"
+
+#include "SkArenaAlloc.h"
+#include "SkBitmapProcShader.h"
+#include "SkColor.h"
+#include "SkArenaAlloc.h"
+#include "SkImage.h"
+#include "SkLinearBitmapPipeline.h"
+#include "SkPM4f.h"
+#include "SkShaderBase.h"
+
+struct CommonBitmapFPBenchmark : public Benchmark {
+    CommonBitmapFPBenchmark(
+        SkISize srcSize,
+        bool isSRGB,
+        SkMatrix m,
+        bool useBilerp,
+        SkShader::TileMode xTile,
+        SkShader::TileMode yTile)
+        : 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) {
+            case SkShader::kClamp_TileMode:
+                name.append("Clamp");
+                return name;
+            case SkShader::kRepeat_TileMode:
+                name.append("Repeat");
+                return name;
+            case SkShader::kMirror_TileMode:
+                name.append("Mirror");
+                return name;
+            default:
+                name.append("Unknown");
+                return name;
+        }
+    }
+
+    const char* onGetName() override {
+        fName.set("SkBitmapFP");
+        if (fM.getType() & SkMatrix::kPerspective_Mask) {
+            fName.append("Perspective");
+        } else if (fM.getType() & SkMatrix::kAffine_Mask) {
+            fName.append("Affine");
+        } else if (fM.getType() & SkMatrix::kScale_Mask) {
+            fName.append("Scale");
+        } else if (fM.getType() & SkMatrix::kTranslate_Mask) {
+            fName.append("Translate");
+        } else {
+            fName.append("Identity");
+        }
+
+        fName.append(tileName("X", fXTile));
+        fName.append(tileName("Y", fYTile));
+
+        if (fUseBilerp) {
+            fName.append("Filter");
+        } else {
+            fName.append("Nearest");
+        }
+
+        fName.appendf("%s", BaseName().c_str());
+
+        return fName.c_str();
+    }
+
+    void onPreDraw(SkCanvas*) override {
+        int width = fSrcSize.fWidth;
+        int height = fSrcSize.fHeight;
+        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, fIsSRGB ?
+                                      SkColorSpace::MakeSRGB() : nullptr);
+    }
+
+    bool isSuitableFor(Backend backend) override {
+        return backend == kNonRendering_Backend;
+    }
+
+    virtual SkString BaseName() = 0;
+
+    SkString fName;
+    SkISize fSrcSize;
+    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,
+        bool isSRGB,
+        SkMatrix m,
+        bool useBilerp,
+        SkShader::TileMode xTile,
+        SkShader::TileMode yTile)
+            : CommonBitmapFPBenchmark(srcSize, isSRGB, m, useBilerp, xTile, yTile) { }
+
+    SkString BaseName() override {
+        SkString name;
+        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;
+
+        SkAutoTMalloc<SkPM4f> FPbuffer(width*height);
+
+        SkFilterQuality filterQuality;
+        if (fUseBilerp) {
+            filterQuality = SkFilterQuality::kLow_SkFilterQuality;
+        } else {
+            filterQuality = SkFilterQuality::kNone_SkFilterQuality;
+        }
+
+        SkPixmap srcPixmap{fInfo, fBitmap.get(), static_cast<size_t>(4 * width)};
+
+
+        SkSTArenaAlloc<600> allocator(512);
+        SkLinearBitmapPipeline pipeline{
+            fInvert, filterQuality, fXTile, fYTile, SK_ColorBLACK, srcPixmap, &allocator};
+
+        int count = 100;
+
+        for (int n = 0; n < 1000*loops; n++) {
+            pipeline.shadeSpan4f(3, 6, FPbuffer, count);
+        }
+    }
+};
+
+struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark {
+    SkBitmapFPOrigShader(
+        SkISize srcSize,
+        bool isSRGB,
+        SkMatrix m,
+        bool useBilerp,
+        SkShader::TileMode xTile,
+        SkShader::TileMode 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(
+            SkPixmap(fInfo, fBitmap.get(), sizeof(SkPMColor) * fSrcSize.fWidth));
+        fPaint.setShader(fImage->makeShader(fXTile, fYTile));
+        if (fUseBilerp) {
+            fPaint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
+        } else {
+            fPaint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
+        }
+    }
+
+    void onPostDraw(SkCanvas*) override {
+
+    }
+
+    void onDraw(int loops, SkCanvas*) override {
+        if (as_SB(fPaint.getShader())->isRasterPipelineOnly()) {
+            return;
+        }
+        int width = fSrcSize.fWidth;
+        int height = fSrcSize.fHeight;
+
+        SkAutoTMalloc<SkPMColor> buffer4b(width*height);
+
+        SkArenaAlloc alloc{0};
+        const SkShaderBase::ContextRec rec(fPaint, fM, nullptr,
+                                           SkShaderBase::ContextRec::kPMColor_DstType,
+                                           nullptr);
+        SkShaderBase::Context* ctx = as_SB(fPaint.getShader())->makeContext(rec, &alloc);
+
+        int count = 100;
+
+        for (int n = 0; n < 1000*loops; n++) {
+            ctx->shadeSpan(3, 6, buffer4b, count);
+        }
+    }
+    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, gSRGB, mI, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mI, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mI, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mI, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mI, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    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, gSRGB, mS, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mS, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mS, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mS, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mS, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mS, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+// Repeat
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mS, false,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mS, false,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mS, false,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mS, true,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mS, true,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    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, gSRGB, mR, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mR, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mR, false,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mR, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mR, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mR, true,
+    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
+
+// Repeat
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mR, false,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mR, false,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mR, false,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gSRGB, mR, true,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPGeneral(
+    srcSize, gLinearRGB, mR, true,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)
+
+DEF_BENCH(return new SkBitmapFPOrigShader(
+    srcSize, gLinearRGB, mR, true,
+    SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);)