Reland of [2] of "switch colorfilters to sk_sp (patchset #11 id:200001 of https://codereview.chromium.o…

src/effects/SkTableColorFilter.cpp

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "SkTableColorFilter.h"
 
 #include "SkBitmap.h"
@@ skipping 28 matching lines @@
         }
         if (tableB) {
             memcpy(dst, tableB, 256);
             fFlags |= kB_Flag;
         }
     }
 
     virtual ~SkTable_ColorFilter() { delete fBitmap; }
 
     bool asComponentTable(SkBitmap* table) const override;
-    SkColorFilter* newComposed(const SkColorFilter* inner) const override;
+    sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter> inner) const override;
 
 #if SK_SUPPORT_GPU
     const GrFragmentProcessor* asFragmentProcessor(GrContext*) const override;
 #endif
 
     void filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const override;
 
     SK_TO_STRING_OVERRIDE()
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTable_ColorFilter)
@@ skipping 184 matching lines @@
         ptr += 256;
     }
     if (flags & kG_Flag) {
         g = ptr;
         ptr += 256;
     }
     if (flags & kB_Flag) {
         b = ptr;
         ptr += 256;
     }
-    return SkTableColorFilter::CreateARGB(a, r, g, b);
+    return SkTableColorFilter::MakeARGB(a, r, g, b).release();
 }
 
 bool SkTable_ColorFilter::asComponentTable(SkBitmap* table) const {
     if (table) {
         if (nullptr == fBitmap) {
             SkBitmap* bmp = new SkBitmap;
             bmp->allocPixels(SkImageInfo::MakeA8(256, 4));
             uint8_t* bitmapPixels = bmp->getAddr8(0, 0);
             int offset = 0;
             static const unsigned kFlags[] = { kA_Flag, kR_Flag, kG_Flag, kB_Flag };
@@ skipping 15 matching lines @@
 }
 
 // Combines the two lookup tables so that making a lookup using res[] has
 // the same effect as making a lookup through inner[] then outer[].
 static void combine_tables(uint8_t res[256], const uint8_t outer[256], const uint8_t inner[256]) {
     for (int i = 0; i < 256; i++) {
         res[i] = outer[inner[i]];
     }
 }
 
-SkColorFilter* SkTable_ColorFilter::newComposed(const SkColorFilter* innerFilter) const {
+sk_sp<SkColorFilter> SkTable_ColorFilter::makeComposed(sk_sp<SkColorFilter> innerFilter) const {
     SkBitmap innerBM;
     if (!innerFilter->asComponentTable(&innerBM)) {
         return nullptr;
     }
 
     innerBM.lockPixels();
     if (nullptr == innerBM.getPixels()) {
         return nullptr;
     }
 
@@ skipping 18 matching lines @@
     uint8_t concatA[256];
     uint8_t concatR[256];
     uint8_t concatG[256];
     uint8_t concatB[256];
 
     combine_tables(concatA, tableA, innerBM.getAddr8(0, 0));
     combine_tables(concatR, tableR, innerBM.getAddr8(0, 1));
     combine_tables(concatG, tableG, innerBM.getAddr8(0, 2));
     combine_tables(concatB, tableB, innerBM.getAddr8(0, 3));
 
-    return SkTableColorFilter::CreateARGB(concatA, concatR, concatG, concatB);
+    return SkTableColorFilter::MakeARGB(concatA, concatR, concatG, concatB);
 }
 
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "SkGr.h"
 #include "effects/GrTextureStripAtlas.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
@@ skipping 207 matching lines @@
             flags |= d->fRandom->nextBool() ? (1  << i): 0;
         }
     } while (!flags);
     for (int i = 0; i < 4; ++i) {
         if (flags & (1 << i)) {
             for (int j = 0; j < 256; ++j) {
                 luts[j][i] = SkToU8(d->fRandom->nextBits(8));
             }
         }
     }
-    SkAutoTUnref<SkColorFilter> filter(SkTableColorFilter::CreateARGB(
+    auto filter(SkTableColorFilter::MakeARGB(
         (flags & (1 << 0)) ? luts[0] : nullptr,
         (flags & (1 << 1)) ? luts[1] : nullptr,
         (flags & (1 << 2)) ? luts[2] : nullptr,
         (flags & (1 << 3)) ? luts[3] : nullptr
     ));
 
     const GrFragmentProcessor* fp = filter->asFragmentProcessor(d->fContext);
     SkASSERT(fp);
     return fp;
 }
@@ skipping 12 matching lines @@
 #ifdef SK_CPU_BENDIAN
 #else
     #define SK_A32_INDEX    (3 - (SK_A32_SHIFT >> 3))
     #define SK_R32_INDEX    (3 - (SK_R32_SHIFT >> 3))
     #define SK_G32_INDEX    (3 - (SK_G32_SHIFT >> 3))
     #define SK_B32_INDEX    (3 - (SK_B32_SHIFT >> 3))
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkColorFilter* SkTableColorFilter::Create(const uint8_t table[256]) {
-    return new SkTable_ColorFilter(table, table, table, table);
+sk_sp<SkColorFilter> SkTableColorFilter::Make(const uint8_t table[256]) {
+    return sk_make_sp<SkTable_ColorFilter>(table, table, table, table);
 }
 
-SkColorFilter* SkTableColorFilter::CreateARGB(const uint8_t tableA[256],
-                                              const uint8_t tableR[256],
-                                              const uint8_t tableG[256],
-                                              const uint8_t tableB[256]) {
-    return new SkTable_ColorFilter(tableA, tableR, tableG, tableB);
+sk_sp<SkColorFilter> SkTableColorFilter::MakeARGB(const uint8_t tableA[256],
+                                                  const uint8_t tableR[256],
+                                                  const uint8_t tableG[256],
+                                                  const uint8_t tableB[256]) {
+    return sk_make_sp<SkTable_ColorFilter>(tableA, tableR, tableG, tableB);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkTableColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTable_ColorFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END