Initial conic-gradient() implementation

third_party/WebKit/Source/platform/graphics/Gradient.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 176 matching lines @@
                                SkShader::TileMode tileMode,
                                uint32_t flags,
                                const SkMatrix& localMatrix) const override {
     SkPoint pts[2] = {m_p0.data(), m_p1.data()};
     return SkGradientShader::MakeLinear(pts, colors.data(), pos.data(),
                                         static_cast<int>(colors.size()),
                                         tileMode, flags, &localMatrix);
   }
 
  private:
-  FloatPoint m_p0;
-  FloatPoint m_p1;
+  const FloatPoint m_p0;
+  const FloatPoint m_p1;
 };
 
 class RadialGradient final : public Gradient {
  public:
   RadialGradient(const FloatPoint& p0,
                  float r0,
                  const FloatPoint& p1,
                  float r1,
                  float aspectRatio,
                  GradientSpreadMethod spreadMethod,
@@ skipping 32 matching lines @@
     // The radii we give to Skia must be positive. If we're given a
     // negative radius, ask for zero instead.
     const SkScalar radius0 = std::max(WebCoreFloatToSkScalar(m_r0), 0.0f);
     const SkScalar radius1 = std::max(WebCoreFloatToSkScalar(m_r1), 0.0f);
     return SkGradientShader::MakeTwoPointConical(
         m_p0.data(), radius0, m_p1.data(), radius1, colors.data(), pos.data(),
         static_cast<int>(colors.size()), tileMode, flags, adjustedLocalMatrix);
   }
 
  private:
-  FloatPoint m_p0;
-  FloatPoint m_p1;
-  float m_r0;
-  float m_r1;
-  float m_aspectRatio;  // For elliptical gradient, width / height.
+  const FloatPoint m_p0;
+  const FloatPoint m_p1;
+  const float m_r0;
+  const float m_r1;
+  const float m_aspectRatio;  // For elliptical gradient, width / height.
+};
+
+class ConicGradient final : public Gradient {
+ public:
+  ConicGradient(const FloatPoint& position,
+                float angle,
+                GradientSpreadMethod spreadMethod,
+                ColorInterpolation interpolation)
+      : Gradient(Type::Conic, spreadMethod, interpolation),
+        m_position(position),
+        m_angle(angle) {}
+
+ protected:
+  sk_sp<SkShader> createShader(const ColorBuffer& colors,
+                               const OffsetBuffer& pos,
+                               SkShader::TileMode tileMode,
+                               uint32_t flags,
+                               const SkMatrix& localMatrix) const override {
+    if (tileMode != SkShader::kClamp_TileMode) {
+      // TODO(fmalita): kRepeat support
+      return nullptr;
+    }
+
+    // Skia's sweep gradient angles are relative to the x-axis, not the y-axis.
+    const float skiaAngle = m_angle - 90;
+    SkTCopyOnFirstWrite<SkMatrix> adjustedLocalMatrix(localMatrix);
+    if (skiaAngle) {
+      adjustedLocalMatrix.writable()->preRotate(skiaAngle, m_position.x(),
+                                                m_position.y());
+    }
+
+    return SkGradientShader::MakeSweep(
+        m_position.x(), m_position.y(), colors.data(), pos.data(),
+        static_cast<int>(colors.size()), flags, adjustedLocalMatrix);
+  }
+
+ private:
+  const FloatPoint m_position;
+  const float m_angle;
 };
 
 }  // anonymous ns
 
 PassRefPtr<Gradient> Gradient::createLinear(const FloatPoint& p0,
                                             const FloatPoint& p1,
                                             GradientSpreadMethod spreadMethod,
                                             ColorInterpolation interpolation) {
   return adoptRef(new LinearGradient(p0, p1, spreadMethod, interpolation));
 }
 
 PassRefPtr<Gradient> Gradient::createRadial(const FloatPoint& p0,
                                             float r0,
                                             const FloatPoint& p1,
                                             float r1,
                                             float aspectRatio,
                                             GradientSpreadMethod spreadMethod,
                                             ColorInterpolation interpolation) {
   return adoptRef(new RadialGradient(p0, r0, p1, r1, aspectRatio, spreadMethod,
                                      interpolation));
 }
 
+PassRefPtr<Gradient> Gradient::createConic(const FloatPoint& position,
+                                           float angle,
+                                           GradientSpreadMethod spreadMethod,
+                                           ColorInterpolation interpolation) {
+  return adoptRef(
+      new ConicGradient(position, angle, spreadMethod, interpolation));
+}
+
 }  // namespace blink