For non-opaque SkBitmapDevices, replace malloc-then-zero with calloc.

src/core/SkMallocPixelRef.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMallocPixelRef.h"
 #include "SkBitmap.h"
 #include "SkReadBuffer.h"
@@ skipping 30 matching lines @@
                                               void* addr,
                                               size_t rowBytes,
                                               SkColorTable* ctable) {
     if (!is_valid(info, ctable)) {
         return nullptr;
     }
     return new SkMallocPixelRef(info, addr, rowBytes, ctable, nullptr, nullptr);
 }
 
 
-SkMallocPixelRef* SkMallocPixelRef::NewAllocate(const SkImageInfo& info,
-                                                size_t requestedRowBytes,
-                                                SkColorTable* ctable) {
+ SkMallocPixelRef* SkMallocPixelRef::NewUsing(void*(*alloc)(size_t),
+                                              const SkImageInfo& info,
+                                              size_t requestedRowBytes,
+                                              SkColorTable* ctable) {
     if (!is_valid(info, ctable)) {
         return nullptr;
     }
 
     // only want to permit 31bits of rowBytes
     int64_t minRB = (int64_t)info.minRowBytes64();
     if (minRB < 0 || !sk_64_isS32(minRB)) {
         return nullptr;    // allocation will be too large
     }
     if (requestedRowBytes > 0 && (int32_t)requestedRowBytes < minRB) {
         return nullptr;    // cannot meet requested rowbytes
     }
 
     int32_t rowBytes;
     if (requestedRowBytes) {
         rowBytes = SkToS32(requestedRowBytes);
     } else {
         rowBytes = minRB;
     }
 
     int64_t bigSize = (int64_t)info.height() * rowBytes;
     if (!sk_64_isS32(bigSize)) {
         return nullptr;
     }
 
     size_t size = sk_64_asS32(bigSize);
     SkASSERT(size >= info.getSafeSize(rowBytes));
-    void* addr = sk_malloc_flags(size, 0);
+    void* addr = alloc(size);
     if (nullptr == addr) {
         return nullptr;
     }
 
     return new SkMallocPixelRef(info, addr, rowBytes, ctable, sk_free_releaseproc, nullptr);
 }
 
+SkMallocPixelRef* SkMallocPixelRef::NewAllocate(const SkImageInfo& info,
+                                                size_t rowBytes,
+                                                SkColorTable* ctable) {
+    auto sk_malloc_nothrow = [](size_t size) { return sk_malloc_flags(size, 0); };
+    return NewUsing(sk_malloc_nothrow, info, rowBytes, ctable);
+}
+
+SkMallocPixelRef* SkMallocPixelRef::NewZeroed(const SkImageInfo& info,
+                                              size_t rowBytes,
+                                              SkColorTable* ctable) {
+    return NewUsing(sk_calloc, info, rowBytes, ctable);
+}
+
 SkMallocPixelRef* SkMallocPixelRef::NewWithProc(const SkImageInfo& info,
                                                 size_t rowBytes,
                                                 SkColorTable* ctable,
                                                 void* addr,
                                                 SkMallocPixelRef::ReleaseProc proc,
                                                 void* context) {
     if (!is_valid(info, ctable)) {
         return nullptr;
     }
     return new SkMallocPixelRef(info, addr, rowBytes, ctable, proc, context);
@@ skipping 95 matching lines @@
 size_t SkMallocPixelRef::getAllocatedSizeInBytes() const {
     return this->info().getSafeSize(fRB);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPixelRef* SkMallocPixelRef::PRFactory::create(const SkImageInfo& info, size_t rowBytes,
                                                 SkColorTable* ctable) {
     return SkMallocPixelRef::NewAllocate(info, rowBytes, ctable);
 }
+
+SkPixelRef* SkMallocPixelRef::ZeroedPRFactory::create(const SkImageInfo& info, size_t rowBytes,
+                                                      SkColorTable* ctable) {
+    return SkMallocPixelRef::NewZeroed(info, rowBytes, ctable);
+}