Remove two Gradient setters

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 24 matching lines @@
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include <algorithm>
 
 typedef Vector<SkScalar, 8> ColorStopOffsetVector;
 typedef Vector<SkColor, 8> ColorStopColorVector;
 
 namespace blink {
 
-Gradient::Gradient(const FloatPoint& p0, const FloatPoint& p1)
+Gradient::Gradient(const FloatPoint& p0,
+                   const FloatPoint& p1,
+                   GradientSpreadMethod spreadMethod,
+                   ColorInterpolation interpolation)
     : m_p0(p0),
       m_p1(p1),
       m_r0(0),
       m_r1(0),
       m_aspectRatio(1),
       m_radial(false),
       m_stopsSorted(false),
-      m_drawInPMColorSpace(false),
-      m_spreadMethod(SpreadMethodPad) {}
+      m_spreadMethod(spreadMethod),
+      m_colorInterpolation(interpolation) {}
 
 Gradient::Gradient(const FloatPoint& p0,
                    float r0,
                    const FloatPoint& p1,
                    float r1,
-                   float aspectRatio)
+                   float aspectRatio,
+                   GradientSpreadMethod spreadMethod,
+                   ColorInterpolation interpolation)
     : m_p0(p0),
       m_p1(p1),
       m_r0(r0),
       m_r1(r1),
       m_aspectRatio(aspectRatio),
       m_radial(true),
       m_stopsSorted(false),
-      m_drawInPMColorSpace(false),
-      m_spreadMethod(SpreadMethodPad) {}
+      m_spreadMethod(spreadMethod),
+      m_colorInterpolation(interpolation) {}
 
 Gradient::~Gradient() {}
 
 static inline bool compareStops(const Gradient::ColorStop& a,
                                 const Gradient::ColorStop& b) {
   return a.stop < b.stop;
 }
 
 void Gradient::addColorStop(const Gradient::ColorStop& stop) {
   if (m_stops.isEmpty()) {
@@ skipping 16 matching lines @@
     return;
 
   m_stopsSorted = true;
 
   if (!m_stops.size())
     return;
 
   std::stable_sort(m_stops.begin(), m_stops.end(), compareStops);
 }
 
-void Gradient::setSpreadMethod(GradientSpreadMethod spreadMethod) {
-  // FIXME: Should it become necessary, allow calls to this method after
-  // |m_gradient| has been set.
-  DCHECK(!m_cachedShader);
-
-  if (m_spreadMethod == spreadMethod)
-    return;
-
-  m_spreadMethod = spreadMethod;
-}
-
-void Gradient::setDrawsInPMColorSpace(bool drawInPMColorSpace) {
-  if (drawInPMColorSpace == m_drawInPMColorSpace)
-    return;
-
-  m_drawInPMColorSpace = drawInPMColorSpace;
-  m_cachedShader.reset();
-}
-
 // Determine the total number of stops needed, including pseudo-stops at the
 // ends as necessary.
 static size_t totalStopsNeeded(const Gradient::ColorStop* stopData,
                                size_t count) {
   // N.B.: The tests in this function should kept in sync with the ones in
   // fillStops(), or badness happens.
   const Gradient::ColorStop* stop = stopData;
   size_t countUsed = count;
   if (count < 1 || stop->stop > 0.0)
     countUsed++;
@@ skipping 66 matching lines @@
       break;
     case SpreadMethodRepeat:
       tile = SkShader::kRepeat_TileMode;
       break;
     case SpreadMethodPad:
       tile = SkShader::kClamp_TileMode;
       break;
   }
 
   sk_sp<SkShader> shader;
-  uint32_t shouldDrawInPMColorSpace =
-      m_drawInPMColorSpace ? SkGradientShader::kInterpolateColorsInPremul_Flag
-                           : 0;
+  uint32_t flags = m_colorInterpolation == ColorInterpolation::Premultiplied
+                       ? SkGradientShader::kInterpolateColorsInPremul_Flag
+                       : 0;
   if (m_radial) {
     SkMatrix adjustedLocalMatrix = localMatrix;
 
     if (m_aspectRatio != 1) {
       // CSS3 elliptical gradients: apply the elliptical scaling at the
       // gradient center point.
       adjustedLocalMatrix.preTranslate(m_p0.x(), m_p0.y());
       adjustedLocalMatrix.preScale(1, 1 / m_aspectRatio);
       adjustedLocalMatrix.preTranslate(-m_p0.x(), -m_p0.y());
       ASSERT(m_p0 == m_p1);
     }
 
     // Since the two-point radial gradient is slower than the plain radial,
     // only use it if we have to.
     if (m_p0 == m_p1 && m_r0 <= 0.0f) {
       shader = SkGradientShader::MakeRadial(
           m_p1.data(), m_r1, colors.data(), pos.data(),
-          static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace,
-          &adjustedLocalMatrix);
+          static_cast<int>(countUsed), tile, flags, &adjustedLocalMatrix);
     } else {
       // The radii we give to Skia must be positive. If we're given a
       // negative radius, ask for zero instead.
       SkScalar radius0 = m_r0 >= 0.0f ? WebCoreFloatToSkScalar(m_r0) : 0;
       SkScalar radius1 = m_r1 >= 0.0f ? WebCoreFloatToSkScalar(m_r1) : 0;
       shader = SkGradientShader::MakeTwoPointConical(
           m_p0.data(), radius0, m_p1.data(), radius1, colors.data(), pos.data(),
-          static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace,
-          &adjustedLocalMatrix);
+          static_cast<int>(countUsed), tile, flags, &adjustedLocalMatrix);
     }
   } else {
     SkPoint pts[2] = {m_p0.data(), m_p1.data()};
-    shader = SkGradientShader::MakeLinear(
-        pts, colors.data(), pos.data(), static_cast<int>(countUsed), tile,
-        shouldDrawInPMColorSpace, &localMatrix);
+    shader = SkGradientShader::MakeLinear(pts, colors.data(), pos.data(),
+                                          static_cast<int>(countUsed), tile,
+                                          flags, &localMatrix);
   }
 
   if (!shader) {
     // use last color, since our "geometry" was degenerate (e.g. radius==0)
     shader = SkShader::MakeColorShader(colors[countUsed - 1]);
   }
 
   return WrapSkShader(shader);
 }
 
 void Gradient::applyToFlags(PaintFlags& flags, const SkMatrix& localMatrix) {
   if (!m_cachedShader || localMatrix != m_cachedShader->getLocalMatrix())
     m_cachedShader = createShader(localMatrix);
 
   flags.setShader(m_cachedShader);
 
   // Legacy behavior: gradients are always dithered.
   flags.setDither(true);
 }
 
 }  // namespace blink