remove legacy Skia flags

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2DState.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/canvas2d/CanvasRenderingContext2DState.h"
 
 #include "core/css/CSSFontSelector.h"
 #include "core/css/resolver/FilterOperationResolver.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/StyleResolverState.h"
@@ skipping 261 matching lines @@
   m_isTransformInvertible = true;
 }
 
 static void updateFilterReferences(HTMLCanvasElement* canvasElement,
                                    CanvasRenderingContext2D* context,
                                    const FilterOperations& filters) {
   context->clearFilterReferences();
   context->addFilterReferences(filters, canvasElement->document());
 }
 
-SkImageFilter* CanvasRenderingContext2DState::getFilter(
+sk_sp<SkImageFilter> CanvasRenderingContext2DState::getFilter(
     Element* styleResolutionHost,
     IntSize canvasSize,
     CanvasRenderingContext2D* context) const {
   if (!m_filterValue)
     return nullptr;
 
   // StyleResolverState cannot be used in frame-less documents.
   if (!styleResolutionHost->document().frame())
     return nullptr;
 
@@ skipping 30 matching lines @@
           SkiaImageFilterBuilder::build(lastEffect, ColorSpaceDeviceRGB);
       if (m_resolvedFilter) {
         updateFilterReferences(toHTMLCanvasElement(styleResolutionHost),
                                context, filterStyle->filter());
         if (lastEffect->originTainted())
           context->setOriginTainted();
       }
     }
   }
 
-  return m_resolvedFilter.get();
+  return m_resolvedFilter;
 }
 
 bool CanvasRenderingContext2DState::hasFilter(
     Element* styleResolutionHost,
     IntSize canvasSize,
     CanvasRenderingContext2D* context) const {
   // Checking for a non-null m_filterValue isn't sufficient, since this value
   // might refer to a non-existent filter.
   return !!getFilter(styleResolutionHost, canvasSize, context);
 }
@@ skipping 30 matching lines @@
         DrawLooperBuilder::create();
     drawLooperBuilder->addShadow(m_shadowOffset, m_shadowBlur, m_shadowColor,
                                  DrawLooperBuilder::ShadowIgnoresTransforms,
                                  DrawLooperBuilder::ShadowRespectsAlpha);
     drawLooperBuilder->addUnmodifiedContent();
     m_shadowAndForegroundDrawLooper = drawLooperBuilder->detachDrawLooper();
   }
   return m_shadowAndForegroundDrawLooper.get();
 }
 
-SkImageFilter* CanvasRenderingContext2DState::shadowOnlyImageFilter() const {
+sk_sp<SkImageFilter> CanvasRenderingContext2DState::shadowOnlyImageFilter()
+    const {
   if (!m_shadowOnlyImageFilter) {
     double sigma = skBlurRadiusToSigma(m_shadowBlur);
     m_shadowOnlyImageFilter = SkDropShadowImageFilter::Make(
         m_shadowOffset.width(), m_shadowOffset.height(), sigma, sigma,
         m_shadowColor, SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode,
         nullptr);
   }
-  return m_shadowOnlyImageFilter.get();
+  return m_shadowOnlyImageFilter;
 }
 
-SkImageFilter* CanvasRenderingContext2DState::shadowAndForegroundImageFilter()
-    const {
+sk_sp<SkImageFilter>
+CanvasRenderingContext2DState::shadowAndForegroundImageFilter() const {
   if (!m_shadowAndForegroundImageFilter) {
     double sigma = skBlurRadiusToSigma(m_shadowBlur);
     m_shadowAndForegroundImageFilter = SkDropShadowImageFilter::Make(
         m_shadowOffset.width(), m_shadowOffset.height(), sigma, sigma,
         m_shadowColor,
         SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr);
   }
-  return m_shadowAndForegroundImageFilter.get();
+  return m_shadowAndForegroundImageFilter;
 }
 
 void CanvasRenderingContext2DState::shadowParameterChanged() {
   m_shadowOnlyDrawLooper.reset();
   m_shadowAndForegroundDrawLooper.reset();
   m_shadowOnlyImageFilter.reset();
   m_shadowAndForegroundImageFilter.reset();
 }
 
 void CanvasRenderingContext2DState::setShadowOffsetX(double x) {
@@ skipping 141 matching lines @@
     paint->setLooper(0);
     paint->setImageFilter(shadowAndForegroundImageFilter());
     return paint;
   }
   paint->setLooper(sk_ref_sp(shadowAndForegroundDrawLooper()));
   paint->setImageFilter(0);
   return paint;
 }
 
 }  // namespace blink