Make SkMemory.h and adjust all files for usage.

This will be rolled out in three stages:
1) make SkMemory.h and have SkTypes.h include it.
2) Adjust chromium and android.
3) no long include SkMemory.h in SkTypes.h

Change-Id: If360ef5e1164d88f50b03f279e2e963ca2f57d5d
Reviewed-on: https://skia-review.googlesource.com/9874
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Herb Derby <herb@google.com>

33 files changed, 136 insertions, 73 deletions

diff --git a/experimental/SkSetPoly3To3.cpp b/experimental/SkSetPoly3To3.cpp
index f8d8d1d46b..0eac861f1e 100644
--- a/experimental/SkSetPoly3To3.cpp
+++ b/experimental/SkSetPoly3To3.cpp
@@ -6,6 +6,7 @@
  * found in the LICENSE file.
  */
 #include "SkMatrix.h"
+#include "SkMemory.h"
 
 // FIXME: needs to be in a header
 bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]);
diff --git a/experimental/SkSetPoly3To3_A.cpp b/experimental/SkSetPoly3To3_A.cpp
index bce6314d17..13026b9476 100644
--- a/experimental/SkSetPoly3To3_A.cpp
+++ b/experimental/SkSetPoly3To3_A.cpp
@@ -6,6 +6,7 @@
  * found in the LICENSE file.
  */
 #include "SkMatrix.h"
+#include "SkMemory.h"
 
 // FIXME: needs to be in a header
 bool SkSetPoly3To3_A(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]);
diff --git a/experimental/SkSetPoly3To3_D.cpp b/experimental/SkSetPoly3To3_D.cpp
index 2fb99d8751..8302d909bf 100644
--- a/experimental/SkSetPoly3To3_D.cpp
+++ b/experimental/SkSetPoly3To3_D.cpp
@@ -6,6 +6,7 @@
  * found in the LICENSE file.
  */
 #include "SkMatrix.h"
+#include "SkMemory.h"
 
 // FIXME: needs to be in a header
 bool SkSetPoly3To3_D(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]);
diff --git a/fuzz/Fuzz.h b/fuzz/Fuzz.h
index 9b3fea766b..599abc0270 100644
--- a/fuzz/Fuzz.h
+++ b/fuzz/Fuzz.h
@@ -10,6 +10,7 @@
 
 #include "SkData.h"
 #include "../tools/Registry.h"
+#include "SkMemory.h"
 #include "SkTypes.h"
 
 #include <cmath>
diff --git a/gn/core.gni b/gn/core.gni
index 3e2e53e68f..e03bbb0c85 100644
--- a/gn/core.gni
+++ b/gn/core.gni
@@ -456,8 +456,9 @@ skia_core_sources = [
   "$_include/private/SkFixed.h",
   "$_include/private/SkFloatBits.h",
   "$_include/private/SkFloatingPoint.h",
-  "$_include/private/SkMiniRecorder.h",
+  "$_include/private/SkMemory.h",
   "$_include/private/SkMessageBus.h",
+  "$_include/private/SkMiniRecorder.h",
   "$_include/private/SkMutex.h",
   "$_include/private/SkOnce.h",
   "$_include/private/SkRecords.h",
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index 8baf246d34..8f32bfbc28 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -34,32 +34,13 @@
 // IWYU pragma: end_exports
 
 #include <string.h>
+// TODO(herb): remove after chromuim skia/ext/SkMemory_new_handler.cpp
+// has been updated to point to private/SkMemory.h
+#include "../private/SkMemory.h"
 
 // enable to test new device-base clipping
 //#define SK_USE_DEVICE_CLIPPING
 
-/**
- *  sk_careful_memcpy() is just like memcpy(), but guards against undefined behavior.
- *
- * It is undefined behavior to call memcpy() with null dst or src, even if len is 0.
- * If an optimizer is "smart" enough, it can exploit this to do unexpected things.
- *     memcpy(dst, src, 0);
- *     if (src) {
- *         printf("%x\n", *src);
- *     }
- * In this code the compiler can assume src is not null and omit the if (src) {...} check,
- * unconditionally running the printf, crashing the program if src really is null.
- * Of the compilers we pay attention to only GCC performs this optimization in practice.
- */
-static inline void* sk_careful_memcpy(void* dst, const void* src, size_t len) {
-    // When we pass >0 len we had better already be passing valid pointers.
-    // So we just need to skip calling memcpy when len == 0.
-    if (len) {
-        memcpy(dst,src,len);
-    }
-    return dst;
-}
-
 /** \file SkTypes.h
 */
 
@@ -69,57 +50,13 @@ static inline void* sk_careful_memcpy(void* dst, const void* src, size_t len) {
 #define SKIA_VERSION_MINOR  0
 #define SKIA_VERSION_PATCH  0
 
-/*
-    memory wrappers to be implemented by the porting layer (platform)
-*/
 
-/** Called internally if we run out of memory. The platform implementation must
-    not return, but should either throw an exception or otherwise exit.
-*/
-SK_API extern void sk_out_of_memory(void);
 /** Called internally if we hit an unrecoverable error.
     The platform implementation must not return, but should either throw
     an exception or otherwise exit.
 */
 SK_API extern void sk_abort_no_print(void);
 
-enum {
-    SK_MALLOC_TEMP  = 0x01, //!< hint to sk_malloc that the requested memory will be freed in the scope of the stack frame
-    SK_MALLOC_THROW = 0x02  //!< instructs sk_malloc to call sk_throw if the memory cannot be allocated.
-};
-/** Return a block of memory (at least 4-byte aligned) of at least the
-    specified size. If the requested memory cannot be returned, either
-    return null (if SK_MALLOC_TEMP bit is clear) or throw an exception
-    (if SK_MALLOC_TEMP bit is set). To free the memory, call sk_free().
-*/
-SK_API extern void* sk_malloc_flags(size_t size, unsigned flags);
-/** Same as sk_malloc(), but hard coded to pass SK_MALLOC_THROW as the flag
-*/
-SK_API extern void* sk_malloc_throw(size_t size);
-/** Same as standard realloc(), but this one never returns null on failure. It will throw
-    an exception if it fails.
-*/
-SK_API extern void* sk_realloc_throw(void* buffer, size_t size);
-/** Free memory returned by sk_malloc(). It is safe to pass null.
-*/
-SK_API extern void sk_free(void*);
-
-/** Much like calloc: returns a pointer to at least size zero bytes, or NULL on failure.
- */
-SK_API extern void* sk_calloc(size_t size);
-
-/** Same as sk_calloc, but throws an exception instead of returning NULL on failure.
- */
-SK_API extern void* sk_calloc_throw(size_t size);
-
-// bzero is safer than memset, but we can't rely on it, so... sk_bzero()
-static inline void sk_bzero(void* buffer, size_t size) {
-    // Please c.f. sk_careful_memcpy.  It's undefined behavior to call memset(null, 0, 0).
-    if (size) {
-        memset(buffer, 0, size);
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef override_GLOBAL_NEW
diff --git a/include/private/SkMemory.h b/include/private/SkMemory.h
new file mode 100644
index 0000000000..02ad0ce52e
--- /dev/null
+++ b/include/private/SkMemory.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkMemory_DEFINED
+#define SkMemory_DEFINED
+
+#include <cstddef>
+#include <cstring>
+
+#include "SkPreConfig.h"
+
+/*
+    memory wrappers to be implemented by the porting layer (platform)
+*/
+
+enum {
+    SK_MALLOC_TEMP  = 0x01, //!< hint to sk_malloc that the requested memory will be freed in the scope of the stack frame
+    SK_MALLOC_THROW = 0x02  //!< instructs sk_malloc to call sk_throw if the memory cannot be allocated.
+};
+/** Return a block of memory (at least 4-byte aligned) of at least the
+    specified size. If the requested memory cannot be returned, either
+    return null (if SK_MALLOC_TEMP bit is clear) or throw an exception
+    (if SK_MALLOC_TEMP bit is set). To free the memory, call sk_free().
+*/
+SK_API extern void* sk_malloc_flags(size_t size, unsigned flags);
+/** Same as sk_malloc(), but hard coded to pass SK_MALLOC_THROW as the flag
+*/
+SK_API extern void* sk_malloc_throw(size_t size);
+/** Same as standard realloc(), but this one never returns null on failure. It will throw
+    an exception if it fails.
+*/
+SK_API extern void* sk_realloc_throw(void* buffer, size_t size);
+/** Free memory returned by sk_malloc(). It is safe to pass null.
+*/
+SK_API extern void sk_free(void*);
+
+/** Much like calloc: returns a pointer to at least size zero bytes, or NULL on failure.
+ */
+SK_API extern void* sk_calloc(size_t size);
+
+/** Same as sk_calloc, but throws an exception instead of returning NULL on failure.
+ */
+SK_API extern void* sk_calloc_throw(size_t size);
+
+/** Called internally if we run out of memory. The platform implementation must
+    not return, but should either throw an exception or otherwise exit.
+*/
+SK_API extern void sk_out_of_memory(void);
+
+// bzero is safer than memset, but we can't rely on it, so... sk_bzero()
+static inline void sk_bzero(void* buffer, size_t size) {
+    // Please c.f. sk_careful_memcpy.  It's undefined behavior to call memset(null, 0, 0).
+    if (size) {
+        memset(buffer, 0, size);
+    }
+}
+
+/**
+ *  sk_careful_memcpy() is just like memcpy(), but guards against undefined behavior.
+ *
+ * It is undefined behavior to call memcpy() with null dst or src, even if len is 0.
+ * If an optimizer is "smart" enough, it can exploit this to do unexpected things.
+ *     memcpy(dst, src, 0);
+ *     if (src) {
+ *         printf("%x\n", *src);
+ *     }
+ * In this code the compiler can assume src is not null and omit the if (src) {...} check,
+ * unconditionally running the printf, crashing the program if src really is null.
+ * Of the compilers we pay attention to only GCC performs this optimization in practice.
+ */
+static inline void* sk_careful_memcpy(void* dst, const void* src, size_t len) {
+    // When we pass >0 len we had better already be passing valid pointers.
+    // So we just need to skip calling memcpy when len == 0.
+    if (len) {
+        memcpy(dst,src,len);
+    }
+    return dst;
+}
+
+#endif  //SkMemory_DEFINED
diff --git a/include/private/SkTDArray.h b/include/private/SkTDArray.h
index 16f8474bd4..acf69b58b4 100644
--- a/include/private/SkTDArray.h
+++ b/include/private/SkTDArray.h
@@ -11,6 +11,7 @@
 #define SkTDArray_DEFINED
 
 #include "SkTypes.h"
+#include "SkMemory.h"
 
 template <typename T> class SkTDArray {
 public:
@@ -234,7 +235,7 @@ public:
         }
         return -1;
     }
-    
+
     int find(const T& elem) const {
         const T* iter = fArray;
         const T* stop = fArray + fCount;
diff --git a/include/private/SkTemplates.h b/include/private/SkTemplates.h
index 6f29aa14f9..e8dd04e6c5 100644
--- a/include/private/SkTemplates.h
+++ b/include/private/SkTemplates.h
@@ -11,6 +11,7 @@
 #define SkTemplates_DEFINED
 
 #include "SkMath.h"
+#include "SkMemory.h"
 #include "SkTLogic.h"
 #include "SkTypes.h"
 #include <limits.h>
diff --git a/src/core/SkAutoMalloc.h b/src/core/SkAutoMalloc.h
index 7be882547d..77901a8380 100644
--- a/src/core/SkAutoMalloc.h
+++ b/src/core/SkAutoMalloc.h
@@ -9,6 +9,7 @@
 #define SkAutoMalloc_DEFINED
 
 #include "SkTypes.h"
+#include "SkMemory.h"
 
 #include <memory>
 
diff --git a/src/core/SkAutoPixmapStorage.h b/src/core/SkAutoPixmapStorage.h
index 379bf420b0..ef7f23f28d 100644
--- a/src/core/SkAutoPixmapStorage.h
+++ b/src/core/SkAutoPixmapStorage.h
@@ -8,6 +8,7 @@
 #ifndef SkAutoPixmapStorage_DEFINED
 #define SkAutoPixmapStorage_DEFINED
 
+#include "SkMemory.h"
 #include "SkPixmap.h"
 
 class SK_API SkAutoPixmapStorage : public SkPixmap {
diff --git a/src/core/SkCachedData.cpp b/src/core/SkCachedData.cpp
index 1ea232b2c5..5f28c6ce35 100644
--- a/src/core/SkCachedData.cpp
+++ b/src/core/SkCachedData.cpp
@@ -7,6 +7,7 @@
 
 #include "SkCachedData.h"
 #include "SkDiscardableMemory.h"
+#include "SkMemory.h"
 
 //#define TRACK_CACHEDDATA_LIFETIME
 
diff --git a/src/core/SkDeque.cpp b/src/core/SkDeque.cpp
index f9ab4af531..6639a77dc0 100644
--- a/src/core/SkDeque.cpp
+++ b/src/core/SkDeque.cpp
@@ -5,8 +5,8 @@
  * found in the LICENSE file.
  */
 
-
 #include "SkDeque.h"
+#include "SkMemory.h"
 
 struct SkDeque::Block {
     Block*  fNext;
diff --git a/src/core/SkMask.cpp b/src/core/SkMask.cpp
index 111508074a..25cc65187d 100644
--- a/src/core/SkMask.cpp
+++ b/src/core/SkMask.cpp
@@ -7,6 +7,8 @@
 
 #include "SkMask.h"
 
+#include "SkMemory.h"
+
 //#define TRACK_SKMASK_LIFETIME
 
 /** returns the product if it is positive and fits in 31 bits. Otherwise this
diff --git a/src/core/SkMetaData.cpp b/src/core/SkMetaData.cpp
index 6e1f5e2a3d..462325a092 100644
--- a/src/core/SkMetaData.cpp
+++ b/src/core/SkMetaData.cpp
@@ -7,6 +7,8 @@
 
 
 #include "SkMetaData.h"
+
+#include "SkMemory.h"
 #include "SkRefCnt.h"
 
 struct PtrPair {
diff --git a/src/core/SkRWBuffer.cpp b/src/core/SkRWBuffer.cpp
index c97b646c15..4ef2d94c77 100644
--- a/src/core/SkRWBuffer.cpp
+++ b/src/core/SkRWBuffer.cpp
@@ -5,8 +5,10 @@
  * found in the LICENSE file.
  */
 
-#include "SkAtomics.h"
 #include "SkRWBuffer.h"
+
+#include "SkAtomics.h"
+#include "SkMemory.h"
 #include "SkStream.h"
 
 // Force small chunks to be a page's worth
diff --git a/src/core/SkRect.cpp b/src/core/SkRect.cpp
index 0b2723ab0a..d91596dc07 100644
--- a/src/core/SkRect.cpp
+++ b/src/core/SkRect.cpp
@@ -7,6 +7,8 @@
 
 #include "SkRect.h"
 
+#include "SkMemory.h"
+
 void SkIRect::join(int32_t left, int32_t top, int32_t right, int32_t bottom) {
     // do nothing if the params are empty
     if (left >= right || top >= bottom) {
diff --git a/src/core/SkRegionPriv.h b/src/core/SkRegionPriv.h
index ef369143e3..04ec0e2d47 100644
--- a/src/core/SkRegionPriv.h
+++ b/src/core/SkRegionPriv.h
@@ -10,7 +10,9 @@
 #define SkRegionPriv_DEFINED
 
 #include "SkRegion.h"
+
 #include "SkAtomics.h"
+#include "SkMemory.h"
 
 inline bool SkRegionValueIsSentinel(int32_t value) {
     return value == (int32_t)SkRegion::kRunTypeSentinel;
diff --git a/src/core/SkTLList.h b/src/core/SkTLList.h
index 58fa3f4aac..c9cb2d3eac 100644
--- a/src/core/SkTLList.h
+++ b/src/core/SkTLList.h
@@ -9,6 +9,8 @@
 #define SkTLList_DEFINED
 
 #include "SkTInternalLList.h"
+
+#include "SkMemory.h"
 #include "SkTypes.h"
 #include <utility>
 
diff --git a/src/core/SkTSearch.cpp b/src/core/SkTSearch.cpp
index 9ff9777638..1744d0ad89 100644
--- a/src/core/SkTSearch.cpp
+++ b/src/core/SkTSearch.cpp
@@ -7,6 +7,9 @@
 
 
 #include "SkTSearch.h"
+
+#include "SkMemory.h"
+
 #include <ctype.h>
 
 static inline const char* index_into_base(const char*const* base, int index,
diff --git a/src/core/SkVarAlloc.cpp b/src/core/SkVarAlloc.cpp
index ea0524b67f..2877d5ba9f 100644
--- a/src/core/SkVarAlloc.cpp
+++ b/src/core/SkVarAlloc.cpp
@@ -7,6 +7,8 @@
 
 #include "SkVarAlloc.h"
 
+#include "SkMemory.h"
+
 struct SkVarAlloc::Block {
     Block* prev;
     char* data() { return (char*)(this + 1); }
diff --git a/src/effects/gradients/SkGradientBitmapCache.cpp b/src/effects/gradients/SkGradientBitmapCache.cpp
index 20b87e02ca..f6f248e9a1 100644
--- a/src/effects/gradients/SkGradientBitmapCache.cpp
+++ b/src/effects/gradients/SkGradientBitmapCache.cpp
@@ -8,6 +8,8 @@
 
 #include "SkGradientBitmapCache.h"
 
+#include "SkMemory.h"
+
 struct SkGradientBitmapCache::Entry {
     Entry*      fPrev;
     Entry*      fNext;
diff --git a/src/gpu/GrMemoryPool.cpp b/src/gpu/GrMemoryPool.cpp
index c95b59fc8c..0b956aecf9 100644
--- a/src/gpu/GrMemoryPool.cpp
+++ b/src/gpu/GrMemoryPool.cpp
@@ -7,6 +7,8 @@
 
 #include "GrMemoryPool.h"
 
+#include "SkMemory.h"
+
 #ifdef SK_DEBUG
     #define VALIDATE this->validate()
 #else
diff --git a/src/gpu/GrRectanizer_pow2.h b/src/gpu/GrRectanizer_pow2.h
index 296e0520bf..424d22e003 100644
--- a/src/gpu/GrRectanizer_pow2.h
+++ b/src/gpu/GrRectanizer_pow2.h
@@ -10,6 +10,7 @@
 
 #include "GrRectanizer.h"
 #include "SkMathPriv.h"
+#include "SkMemory.h"
 #include "SkPoint.h"
 
 // This Rectanizer quantizes the incoming rects to powers of 2. Each power
diff --git a/src/lazy/SkDiscardableMemoryPool.cpp b/src/lazy/SkDiscardableMemoryPool.cpp
index 6ced5bfc02..fece7f0d6f 100644
--- a/src/lazy/SkDiscardableMemoryPool.cpp
+++ b/src/lazy/SkDiscardableMemoryPool.cpp
@@ -8,6 +8,7 @@
 #include "SkDiscardableMemory.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkImageGenerator.h"
+#include "SkMemory.h"
 #include "SkMutex.h"
 #include "SkOnce.h"
 #include "SkTInternalLList.h"
diff --git a/src/pdf/SkDeflate.cpp b/src/pdf/SkDeflate.cpp
index c2b85fccb3..af727640bf 100644
--- a/src/pdf/SkDeflate.cpp
+++ b/src/pdf/SkDeflate.cpp
@@ -9,6 +9,7 @@
 #include "SkData.h"
 #include "SkDeflate.h"
 #include "SkMakeUnique.h"
+#include "SkMemory.h"
 
 #include "zlib.h"
 
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index d155308074..9e3a7d3f9d 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -18,6 +18,7 @@
 #include "SkMask.h"
 #include "SkMaskGamma.h"
 #include "SkMatrix22.h"
+#include "SkMemory.h"
 #include "SkMutex.h"
 #include "SkOTUtils.h"
 #include "SkPath.h"
diff --git a/src/ports/SkFontMgr_android_parser.cpp b/src/ports/SkFontMgr_android_parser.cpp
index e50a73946a..17dac84ec1 100644
--- a/src/ports/SkFontMgr_android_parser.cpp
+++ b/src/ports/SkFontMgr_android_parser.cpp
@@ -10,6 +10,7 @@
 #include "SkFixed.h"
 #include "SkFontMgr.h"
 #include "SkFontMgr_android_parser.h"
+#include "SkMemory.h"
 #include "SkOSFile.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
diff --git a/src/ports/SkMemory_malloc.cpp b/src/ports/SkMemory_malloc.cpp
index 5574a8a0f2..a303abb080 100644
--- a/src/ports/SkMemory_malloc.cpp
+++ b/src/ports/SkMemory_malloc.cpp
@@ -4,10 +4,11 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+#include "SkMemory.h"
 
 #include "SkTypes.h"
 
-#include <stdlib.h>
+#include <cstdlib>
 
 #define SK_DEBUGFAILF(fmt, ...) \
     SkASSERT((SkDebugf(fmt"\n", __VA_ARGS__), false))
diff --git a/src/ports/SkMemory_mozalloc.cpp b/src/ports/SkMemory_mozalloc.cpp
index f8a996307e..d665799bbf 100644
--- a/src/ports/SkMemory_mozalloc.cpp
+++ b/src/ports/SkMemory_mozalloc.cpp
@@ -6,8 +6,9 @@
  * found in the LICENSE file.
  */
 
-#include "SkTypes.h"
+#include "SkMemory.h"
 
+#include "SkTypes.h"
 #include "mozilla/mozalloc.h"
 #include "mozilla/mozalloc_abort.h"
 #include "mozilla/mozalloc_oom.h"
diff --git a/src/ports/SkOSFile_win.cpp b/src/ports/SkOSFile_win.cpp
index 9c5ada607d..541e06b513 100644
--- a/src/ports/SkOSFile_win.cpp
+++ b/src/ports/SkOSFile_win.cpp
@@ -9,6 +9,7 @@
 #if defined(SK_BUILD_FOR_WIN32)
 
 #include "SkLeanWindows.h"
+#include "SkMemory.h"
 #include "SkOSFile.h"
 #include "SkTFitsIn.h"
 
diff --git a/src/utils/SkInterpolator.cpp b/src/utils/SkInterpolator.cpp
index d3c0b26fef..db090184b6 100644
--- a/src/utils/SkInterpolator.cpp
+++ b/src/utils/SkInterpolator.cpp
@@ -5,10 +5,11 @@
  * found in the LICENSE file.
  */
 
+#include "SkInterpolator.h"
 
 #include "SkFixed.h"
-#include "SkInterpolator.h"
 #include "SkMath.h"
+#include "SkMemory.h"
 #include "SkTSearch.h"
 
 SkInterpolatorBase::SkInterpolatorBase() {
diff --git a/src/utils/mac/SkStream_mac.cpp b/src/utils/mac/SkStream_mac.cpp
index e878c97244..06b717b1c8 100644
--- a/src/utils/mac/SkStream_mac.cpp
+++ b/src/utils/mac/SkStream_mac.cpp
@@ -6,9 +6,11 @@
  */
 
 #include "SkTypes.h"
+
 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
 
 #include "SkCGUtils.h"
+#include "SkMemory.h"
 #include "SkStream.h"
 
 // These are used by CGDataProviderCreateWithData