Update 4f linear gradient selection heuristic

src/effects/gradients/SkLinearGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "SkLinearGradient.h"
 
 // define to test the 4f gradient path
-// #define USE_4fGRADIENTS
+// #define FORCE_4F_CONTEXT
 
 static const float kInv255Float = 1.0f / 255;
 
 static inline int repeat_8bits(int x) {
     return x & 0xFF;
 }
 
 // Visual Studio 2010 (MSC_VER=1600) optimizes bit-shift code incorrectly.
 // See http://code.google.com/p/skia/issues/detail?id=472
 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
@@ skipping 17 matching lines @@
     SkScalar    inv = mag ? SkScalarInvert(mag) : 0;
 
     vec.scale(inv);
     SkMatrix matrix;
     matrix.setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
     matrix.postTranslate(-pts[0].fX, -pts[0].fY);
     matrix.postScale(inv, inv);
     return matrix;
 }
 
-static bool use_4f_context(uint32_t flags) {
-#ifdef USE_4fGRADIENTS
+static bool use_4f_context(const SkShader::ContextRec& rec, uint32_t flags) {
+#ifdef FORCE_4F_CONTEXT
     return true;
 #else
-    return SkToBool(flags & SkLinearGradient::kForce4fContext_PrivateFlag);
+    // Perspective not supported in 4f yet.
+    if (rec.fMatrix->hasPerspective()
+        || (rec.fLocalMatrix && rec.fLocalMatrix->hasPerspective())) {
+        return false;
+    }
+
+    return rec.fPreferredDstType == SkShader::ContextRec::kPM4f_DstType
+        || SkToBool(flags & SkLinearGradient::kForce4fContext_PrivateFlag);
 #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc)
     : SkGradientShaderBase(desc, pts_to_unit_matrix(pts))
     , fStart(pts[0])
     , fEnd(pts[1]) {
 }
 
 SkFlattenable* SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
     DescriptorScope desc;
     if (!desc.unflatten(buffer)) {
         return nullptr;
     }
     SkPoint pts[2];
     pts[0] = buffer.readPoint();
     pts[1] = buffer.readPoint();
     return SkGradientShader::CreateLinear(pts, desc.fColors, desc.fPos, desc.fCount,
                                           desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix);
 }
 
 void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writePoint(fStart);
     buffer.writePoint(fEnd);
 }
 
-size_t SkLinearGradient::contextSize(const ContextRec&) const {
-    return use_4f_context(fGradFlags)
+size_t SkLinearGradient::contextSize(const ContextRec& rec) const {
+    return use_4f_context(rec, fGradFlags)
         ? sizeof(LinearGradient4fContext)
         : sizeof(LinearGradientContext);
 }
 
 SkShader::Context* SkLinearGradient::onCreateContext(const ContextRec& rec, void* storage) const {
-    return use_4f_context(fGradFlags)
+    return use_4f_context(rec, fGradFlags)
         ? static_cast<SkShader::Context*>(new (storage) LinearGradient4fContext(*this, rec))
         : static_cast<SkShader::Context*>(new (storage) LinearGradientContext(*this, rec));
 }
 
 // This swizzles SkColor into the same component order as SkPMColor, but does not actually
 // "pre" multiply the color components.
 //
 // This allows us to map directly to Sk4f, and eventually scale down to bytes to output a
 // SkPMColor from the floats, without having to swizzle each time.
 //
@@ skipping 653 matching lines @@
             this->shade4_dx_clamp<false, true>(dstC, count, fx, dx, invDx, dither);
         }
     } else {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
         }
     }
 }