switch maskfilters to sk_sp

src/effects/SkEmbossMaskFilter.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkEmbossMaskFilter.h"
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkEmbossMask.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkString.h"
 
-SkMaskFilter* SkEmbossMaskFilter::Create(SkScalar blurSigma, const Light& light) {
-    return new SkEmbossMaskFilter(blurSigma, light);
+sk_sp<SkMaskFilter> SkEmbossMaskFilter::Make(SkScalar blurSigma, const Light& light) {
+    return sk_sp<SkMaskFilter>(new SkEmbossMaskFilter(blurSigma, light));
 }
 
+#ifdef SK_SUPPORT_LEGACY_MASKFILTER_PTR
 SkMaskFilter* SkBlurMaskFilter::CreateEmboss(const SkScalar direction[3],
                                              SkScalar ambient, SkScalar specular,
                                              SkScalar blurRadius) {
     return SkBlurMaskFilter::CreateEmboss(SkBlurMask::ConvertRadiusToSigma(blurRadius),
                                           direction, ambient, specular);
 }
+#endif
 
-SkMaskFilter* SkBlurMaskFilter::CreateEmboss(SkScalar blurSigma, const SkScalar direction[3],
-                                             SkScalar ambient, SkScalar specular) {
+sk_sp<SkMaskFilter> SkBlurMaskFilter::MakeEmboss(SkScalar blurSigma, const SkScalar direction[3],
+                                                 SkScalar ambient, SkScalar specular) {
     if (direction == nullptr) {
         return nullptr;
     }
 
     SkEmbossMaskFilter::Light   light;
 
     memcpy(light.fDirection, direction, sizeof(light.fDirection));
     // ambient should be 0...1 as a scalar
     light.fAmbient = SkUnitScalarClampToByte(ambient);
     // specular should be 0..15.99 as a scalar
     static const SkScalar kSpecularMultiplier = SkIntToScalar(255) / 16;
     light.fSpecular = static_cast<U8CPU>(SkScalarPin(specular, 0, 16) * kSpecularMultiplier + 0.5);
 
-    return SkEmbossMaskFilter::Create(blurSigma, light);
+    return SkEmbossMaskFilter::Make(blurSigma, light);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void normalize(SkScalar v[3]) {
     SkScalar mag = SkScalarSquare(v[0]) + SkScalarSquare(v[1]) + SkScalarSquare(v[2]);
     mag = SkScalarSqrt(mag);
 
     for (int i = 0; i < 3; i++) {
         v[i] /= mag;
@@ skipping 57 matching lines @@
     memcpy(dst->fImage, src.fImage, src.computeImageSize());
 
     return true;
 }
 
 sk_sp<SkFlattenable> SkEmbossMaskFilter::CreateProc(SkReadBuffer& buffer) {
     Light light;
     if (buffer.readByteArray(&light, sizeof(Light))) {
         light.fPad = 0; // for the font-cache lookup to be clean
         const SkScalar sigma = buffer.readScalar();
-        return sk_sp<SkFlattenable>(Create(sigma, light));
+        return Make(sigma, light);
     }
     return nullptr;
 }
 
 void SkEmbossMaskFilter::flatten(SkWriteBuffer& buffer) const {
     Light tmpLight = fLight;
     tmpLight.fPad = 0;    // for the font-cache lookup to be clean
     buffer.writeByteArray(&tmpLight, sizeof(tmpLight));
     buffer.writeScalar(fBlurSigma);
 }
@@ skipping 11 matching lines @@
     str->append(") ");
 
     str->appendf("ambient: %d specular: %d ",
         fLight.fAmbient, fLight.fSpecular);
 
     str->append("blurSigma: ");
     str->appendScalar(fBlurSigma);
     str->append(")");
 }
 #endif