Update 4f linear gradient selection heuristic

tests/SkColor4fTest.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 "SkColor.h"
 #include "SkColorMatrixFilter.h"
 #include "SkGradientShader.h"
@@ skipping 107 matching lines @@
     return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 }
 
 static SkShader* make_cf_sh() {
     SkAutoTUnref<SkColorFilter> filter(make_mx_cf());
     SkAutoTUnref<SkShader> shader(make_color_sh());
     return shader->newWithColorFilter(filter);
 }
 
 static void compare_spans(const SkPM4f span4f[], const SkPMColor span4b[], int count,
-                          skiatest::Reporter* reporter) {
+                          skiatest::Reporter* reporter, float tolerance = 1.0f/255) {
     for (int i = 0; i < count; ++i) {
         SkPM4f c0 = SkPM4f::FromPMColor(span4b[i]);
         SkPM4f c1 = span4f[i];
-        REPORTER_ASSERT(reporter, nearly_equal(c0, c1, 1.0f/255));
+        REPORTER_ASSERT(reporter, nearly_equal(c0, c1, tolerance));
     }
 }
 
 DEF_TEST(Color4f_shader, reporter) {
     struct {
-        SkShader*   (*fFact)();
-        bool        fSupports4f;
+        SkShader* (*fFact)();
+        bool      fSupports4f;
+        float     fTolerance;
     } recs[] = {
-        { make_color_sh, true },
-        { make_grad_sh,  false },
-        { make_image_sh, false },
-        { make_cf_sh,    true },
+        { make_color_sh, true,  1.0f/255   },
+        // PMColor 4f gradients are interpolated in 255-multiplied values, so we need a
+        // slightly relaxed tolerance to accommodate the cumulative precision deviation.
+        { make_grad_sh,  true,  1.001f/255 },
+        { make_image_sh, false, 1.0f/255   },
+        { make_cf_sh,    true,  1.0f/255   },
     };
 
     SkPaint paint;
     for (const auto& rec : recs) {
         uint32_t storage[200];
         paint.setShader(rec.fFact())->unref();
         // Encourage 4f context selection. At some point we may need
         // to instantiate two separate contexts for optimal 4b/4f selection.
         const SkShader::ContextRec contextRec(paint, SkMatrix::I(), nullptr,
                                               SkShader::ContextRec::kPM4f_DstType);
         SkASSERT(paint.getShader()->contextSize(contextRec) <= sizeof(storage));
         SkShader::Context* ctx = paint.getShader()->createContext(contextRec, storage);
         REPORTER_ASSERT(reporter, ctx->supports4f() == rec.fSupports4f);
         if (ctx->supports4f()) {
             const int N = 100;
             SkPM4f buffer4f[N];
             ctx->shadeSpan4f(0, 0, buffer4f, N);
             SkPMColor buffer4b[N];
             ctx->shadeSpan(0, 0, buffer4b, N);
-            compare_spans(buffer4f, buffer4b, N, reporter);
+            compare_spans(buffer4f, buffer4b, N, reporter, rec.fTolerance);
         }
         ctx->~Context();
     }
 }
 
 DEF_TEST(Color4f_colorfilter, reporter) {
     struct {
         SkColorFilter* (*fFact)();
         bool           fSupports4f;
     } recs[] = {
@@ skipping 58 matching lines @@
 //
 DEF_TEST(Color4f_xfermode_proc4f, reporter) {
     // TODO: extend xfermodes so that all cases can be tested.
     //
     for (int mode = SkXfermode::kClear_Mode; mode <= SkXfermode::kScreen_Mode; ++mode) {
         SkXfermodeProc   proc32 = SkXfermode::GetProc((SkXfermode::Mode)mode);
         SkXfermodeProc4f proc4f = SkXfermode::GetProc4f((SkXfermode::Mode)mode);
         REPORTER_ASSERT(reporter, compare_procs(proc32, proc4f));
     }
 }