Revert of move erase into SkPixmap (patchset #1 id:1 of https://codereview.chromium.org/1161033005/)

Reason for revert:
broken builds

Original issue's description:
> move erase into SkPixmap
>
> harvested from https://codereview.chromium.org/1148793007
>
> BUG=skia:
> TBR=
>
> Committed: https://skia.googlesource.com/skia/+/0963f5dab079627c5523ce6a443af27a33e361f7

TBR=reed@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/1157303008

4 files changed, 126 insertions, 154 deletions

diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index b13b6f7451..c070203d04 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -473,7 +473,10 @@ public:
      *  of the color is ignored (treated as opaque). If the colortype only supports
      *  alpha (e.g. A1 or A8) then the color's r,g,b components are ignored.
      */
-    void eraseColor(SkColor c) const;
+    void eraseColor(SkColor c) const {
+        this->eraseARGB(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c),
+                        SkColorGetB(c));
+    }
 
     /**
      *  Fill the entire bitmap with the specified color.
@@ -481,9 +484,7 @@ public:
      *  of the color is ignored (treated as opaque). If the colortype only supports
      *  alpha (e.g. A1 or A8) then the color's r,g,b components are ignored.
      */
-    void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
-        this->eraseColor(SkColorSetARGB(a, r, g, b));
-    }
+    void eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const;
 
     SK_ATTR_DEPRECATED("use eraseARGB or eraseColor")
     void eraseRGB(U8CPU r, U8CPU g, U8CPU b) const {
@@ -496,12 +497,7 @@ public:
      *  of the color is ignored (treated as opaque). If the colortype only supports
      *  alpha (e.g. A1 or A8) then the color's r,g,b components are ignored.
      */
-    void erase(SkColor c, const SkIRect& area) const;
-
-    // DEPRECATED
-    void eraseArea(const SkIRect& area, SkColor c) const {
-        this->erase(c, area);
-    }
+    void eraseArea(const SkIRect& area, SkColor c) const;
 
     /**
      *  Return the SkColor of the specified pixel.  In most cases this will
@@ -740,9 +736,13 @@ private:
     };
 
     SkImageInfo fInfo;
+
     uint32_t    fRowBytes;
+
     uint8_t     fFlags;
 
+    void internalErase(const SkIRect&, U8CPU a, U8CPU r, U8CPU g, U8CPU b)const;
+
     /*  Unreference any pixelrefs or colortables
     */
     void freePixels();
diff --git a/include/core/SkPixmap.h b/include/core/SkPixmap.h
index a32b40c58d..913d007c4d 100644
--- a/include/core/SkPixmap.h
+++ b/include/core/SkPixmap.h
@@ -133,14 +133,6 @@ public:
         return this->readPixels(dst.info(), dst.writable_addr(), dst.rowBytes(), 0, 0);
     }
 
-    /**
-     *  Returns true if pixels were written to (e.g. if colorType is kUnknown_SkColorType, this
-     *  will return false). If subset does not intersect the bounds of this pixmap, returns false.
-     */
-    bool erase(SkColor, const SkIRect& subset) const;
-
-    bool erase(SkColor color) const { return this->erase(color, this->bounds()); }
-
 private:
     const void*     fPixels;
     SkColorTable*   fCTable;
@@ -173,34 +165,8 @@ public:
      */
     void alloc(const SkImageInfo&);
 
-    // We wrap these so we can clear our internal storage
-
-    void reset() {
-        this->freeStorage();
-        this->INHERITED::reset();
-    }
-    void reset(const SkImageInfo& info, const void* addr, size_t rb, SkColorTable* ctable = NULL) {
-        this->freeStorage();
-        this->INHERITED::reset(info, addr, rb, ctable);
-    }
-    void reset(const SkImageInfo& info) {
-        this->freeStorage();
-        this->INHERITED::reset(info);
-    }
-    bool SK_WARN_UNUSED_RESULT reset(const SkMask& mask) {
-        this->freeStorage();
-        return this->INHERITED::reset(mask);
-    }
-
 private:
     void*   fStorage;
-
-    void freeStorage() {
-        sk_free(fStorage);
-        fStorage = NULL;
-    }
-
-    typedef SkPixmap INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 49e2c04bfb..f2668f0a20 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -666,8 +666,101 @@ bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkBitmap::erase(SkColor c, const SkIRect& area) const {
+static uint16_t pack_8888_to_4444(unsigned a, unsigned r, unsigned g, unsigned b) {
+    unsigned pixel = (SkA32To4444(a) << SK_A4444_SHIFT) |
+                     (SkR32To4444(r) << SK_R4444_SHIFT) |
+                     (SkG32To4444(g) << SK_G4444_SHIFT) |
+                     (SkB32To4444(b) << SK_B4444_SHIFT);
+    return SkToU16(pixel);
+}
+
+static bool internal_erase(const SkPixmap& pmap, const SkIRect& area,
+                           U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
+    int height = area.height();
+    const int width = area.width();
+    const int rowBytes = pmap.rowBytes();
+
+    switch (pmap.colorType()) {
+        case kGray_8_SkColorType: {
+            if (255 != a) {
+                r = SkMulDiv255Round(r, a);
+                g = SkMulDiv255Round(g, a);
+                b = SkMulDiv255Round(b, a);
+            }
+            int gray = SkComputeLuminance(r, g, b);
+            uint8_t* p = pmap.writable_addr8(area.fLeft, area.fTop);
+            while (--height >= 0) {
+                memset(p, gray, width);
+                p += rowBytes;
+            }
+            break;
+        }
+        case kAlpha_8_SkColorType: {
+            uint8_t* p = pmap.writable_addr8(area.fLeft, area.fTop);
+            while (--height >= 0) {
+                memset(p, a, width);
+                p += rowBytes;
+            }
+            break;
+        }
+        case kARGB_4444_SkColorType:
+        case kRGB_565_SkColorType: {
+            uint16_t* p = pmap.writable_addr16(area.fLeft, area.fTop);
+            uint16_t v;
+
+            // make rgb premultiplied
+            if (255 != a) {
+                r = SkAlphaMul(r, a);
+                g = SkAlphaMul(g, a);
+                b = SkAlphaMul(b, a);
+            }
+
+            if (kARGB_4444_SkColorType == pmap.colorType()) {
+                v = pack_8888_to_4444(a, r, g, b);
+            } else {
+                v = SkPackRGB16(r >> (8 - SK_R16_BITS),
+                                g >> (8 - SK_G16_BITS),
+                                b >> (8 - SK_B16_BITS));
+            }
+            while (--height >= 0) {
+                sk_memset16(p, v, width);
+                p = (uint16_t*)((char*)p + rowBytes);
+            }
+            break;
+        }
+        case kBGRA_8888_SkColorType:
+        case kRGBA_8888_SkColorType: {
+            uint32_t* p = pmap.writable_addr32(area.fLeft, area.fTop);
+
+            if (255 != a && kPremul_SkAlphaType == pmap.alphaType()) {
+                r = SkAlphaMul(r, a);
+                g = SkAlphaMul(g, a);
+                b = SkAlphaMul(b, a);
+            }
+            uint32_t v = kRGBA_8888_SkColorType == pmap.colorType() ?
+            SkPackARGB_as_RGBA(a, r, g, b) : SkPackARGB_as_BGRA(a, r, g, b);
+
+            while (--height >= 0) {
+                sk_memset32(p, v, width);
+                p = (uint32_t*)((char*)p + rowBytes);
+            }
+            break;
+        }
+        default:
+            return false; // no change, so don't call notifyPixelsChanged()
+    }
+    return true;
+}
+
+void SkBitmap::internalErase(const SkIRect& area, U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
+#ifdef SK_DEBUG
     SkDEBUGCODE(this->validate();)
+    SkASSERT(!area.isEmpty());
+    {
+        SkIRect total = { 0, 0, this->width(), this->height() };
+        SkASSERT(total.contains(area));
+    }
+#endif
 
     switch (fInfo.colorType()) {
         case kUnknown_SkColorType:
@@ -683,13 +776,24 @@ void SkBitmap::erase(SkColor c, const SkIRect& area) const {
         return;
     }
 
-    if (result.pixmap().erase(c, area)) {
+    if (internal_erase(result.pixmap(), area, a, r, g, b)) {
         this->notifyPixelsChanged();
     }
 }
 
-void SkBitmap::eraseColor(SkColor c) const {
-    this->erase(c, SkIRect::MakeWH(this->width(), this->height()));
+void SkBitmap::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
+    SkIRect area = { 0, 0, this->width(), this->height() };
+    if (!area.isEmpty()) {
+        this->internalErase(area, a, r, g, b);
+    }
+}
+
+void SkBitmap::eraseArea(const SkIRect& rect, SkColor c) const {
+    SkIRect area = { 0, 0, this->width(), this->height() };
+    if (area.intersect(rect)) {
+        this->internalErase(area, SkColorGetA(c), SkColorGetR(c),
+                            SkColorGetG(c), SkColorGetB(c));
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp
index 339dea0072..9b7f993792 100644
--- a/src/core/SkPixmap.cpp
+++ b/src/core/SkPixmap.cpp
@@ -5,11 +5,9 @@
  * found in the LICENSE file.
  */
 
-#include "SkColorPriv.h"
 #include "SkConfig8888.h"
 #include "SkMask.h"
 #include "SkPixmap.h"
-#include "SkUtils.h"
 
 void SkAutoPixmapUnlock::reset(const SkPixmap& pm, void (*unlock)(void*), void* ctx) {
     SkASSERT(pm.addr() != NULL);
@@ -107,126 +105,30 @@ bool SkPixmap::readPixels(const SkImageInfo& requestedDstInfo, void* dstPixels,
                                    srcInfo, srcPixels, this->rowBytes(), this->ctable());
 }
 
-static uint16_t pack_8888_to_4444(unsigned a, unsigned r, unsigned g, unsigned b) {
-    unsigned pixel = (SkA32To4444(a) << SK_A4444_SHIFT) |
-    (SkR32To4444(r) << SK_R4444_SHIFT) |
-    (SkG32To4444(g) << SK_G4444_SHIFT) |
-    (SkB32To4444(b) << SK_B4444_SHIFT);
-    return SkToU16(pixel);
-}
-
-bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const {
-    if (NULL == fPixels) {
-        return false;
-    }
-    SkIRect area;
-    if (!area.intersect(this->bounds(), inArea)) {
-        return false;
-    }
-
-    U8CPU a = SkColorGetA(color);
-    U8CPU r = SkColorGetR(color);
-    U8CPU g = SkColorGetG(color);
-    U8CPU b = SkColorGetB(color);
-
-    int height = area.height();
-    const int width = area.width();
-    const int rowBytes = this->rowBytes();
-    
-    switch (this->colorType()) {
-        case kGray_8_SkColorType: {
-            if (255 != a) {
-                r = SkMulDiv255Round(r, a);
-                g = SkMulDiv255Round(g, a);
-                b = SkMulDiv255Round(b, a);
-            }
-            int gray = SkComputeLuminance(r, g, b);
-            uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
-            while (--height >= 0) {
-                memset(p, gray, width);
-                p += rowBytes;
-            }
-            break;
-        }
-        case kAlpha_8_SkColorType: {
-            uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
-            while (--height >= 0) {
-                memset(p, a, width);
-                p += rowBytes;
-            }
-            break;
-        }
-        case kARGB_4444_SkColorType:
-        case kRGB_565_SkColorType: {
-            uint16_t* p = this->writable_addr16(area.fLeft, area.fTop);
-            uint16_t v;
-            
-            // make rgb premultiplied
-            if (255 != a) {
-                r = SkAlphaMul(r, a);
-                g = SkAlphaMul(g, a);
-                b = SkAlphaMul(b, a);
-            }
-            
-            if (kARGB_4444_SkColorType == this->colorType()) {
-                v = pack_8888_to_4444(a, r, g, b);
-            } else {
-                v = SkPackRGB16(r >> (8 - SK_R16_BITS),
-                                g >> (8 - SK_G16_BITS),
-                                b >> (8 - SK_B16_BITS));
-            }
-            while (--height >= 0) {
-                sk_memset16(p, v, width);
-                p = (uint16_t*)((char*)p + rowBytes);
-            }
-            break;
-        }
-        case kBGRA_8888_SkColorType:
-        case kRGBA_8888_SkColorType: {
-            uint32_t* p = this->writable_addr32(area.fLeft, area.fTop);
-            
-            if (255 != a && kPremul_SkAlphaType == this->alphaType()) {
-                r = SkAlphaMul(r, a);
-                g = SkAlphaMul(g, a);
-                b = SkAlphaMul(b, a);
-            }
-            uint32_t v = kRGBA_8888_SkColorType == this->colorType() ?
-            SkPackARGB_as_RGBA(a, r, g, b) : SkPackARGB_as_BGRA(a, r, g, b);
-            
-            while (--height >= 0) {
-                sk_memset32(p, v, width);
-                p = (uint32_t*)((char*)p + rowBytes);
-            }
-            break;
-        }
-        default:
-            return false; // no change, so don't call notifyPixelsChanged()
-    }
-    return true;
-}
-
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(NULL) {}
 
 SkAutoPixmapStorage::~SkAutoPixmapStorage() {
-    this->freeStorage();
+    sk_free(fStorage);
 }
 
 bool SkAutoPixmapStorage::tryAlloc(const SkImageInfo& info) {
-    this->freeStorage();
+    if (fStorage) {
+        sk_free(fStorage);
+        fStorage = NULL;
+    }
     
     size_t rb = info.minRowBytes();
     size_t size = info.getSafeSize(rb);
     if (0 == size) {
         return false;
     }
-    void* pixels = sk_malloc_flags(size, 0);
-    if (NULL == pixels) {
+    fStorage = sk_malloc_flags(size, 0);
+    if (NULL == fStorage) {
         return false;
     }
-    this->reset(info, pixels, rb);
-    fStorage = pixels;
+    this->reset(info, fStorage, rb);
     return true;
 }