* 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]);
* 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]);
* 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]);
#include "SkData.h"
#include "../tools/Registry.h"
+#include "SkMemory.h"
#include "SkTypes.h"
#include <cmath>
"$_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",
// 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
*/
#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
--- /dev/null
+/*
+ * 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
#define SkTDArray_DEFINED
#include "SkTypes.h"
+#include "SkMemory.h"
template <typename T> class SkTDArray {
public:
}
return -1;
}
-
+
int find(const T& elem) const {
const T* iter = fArray;
const T* stop = fArray + fCount;
#define SkTemplates_DEFINED
#include "SkMath.h"
+#include "SkMemory.h"
#include "SkTLogic.h"
#include "SkTypes.h"
#include <limits.h>
#define SkAutoMalloc_DEFINED
#include "SkTypes.h"
+#include "SkMemory.h"
#include <memory>
#ifndef SkAutoPixmapStorage_DEFINED
#define SkAutoPixmapStorage_DEFINED
+#include "SkMemory.h"
#include "SkPixmap.h"
class SK_API SkAutoPixmapStorage : public SkPixmap {
#include "SkCachedData.h"
#include "SkDiscardableMemory.h"
+#include "SkMemory.h"
//#define TRACK_CACHEDDATA_LIFETIME
* found in the LICENSE file.
*/
-
#include "SkDeque.h"
+#include "SkMemory.h"
struct SkDeque::Block {
Block* fNext;
#include "SkMask.h"
+#include "SkMemory.h"
+
//#define TRACK_SKMASK_LIFETIME
/** returns the product if it is positive and fits in 31 bits. Otherwise this
#include "SkMetaData.h"
+
+#include "SkMemory.h"
#include "SkRefCnt.h"
struct PtrPair {
* 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
#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) {
#define SkRegionPriv_DEFINED
#include "SkRegion.h"
+
#include "SkAtomics.h"
+#include "SkMemory.h"
inline bool SkRegionValueIsSentinel(int32_t value) {
return value == (int32_t)SkRegion::kRunTypeSentinel;
#define SkTLList_DEFINED
#include "SkTInternalLList.h"
+
+#include "SkMemory.h"
#include "SkTypes.h"
#include <utility>
#include "SkTSearch.h"
+
+#include "SkMemory.h"
+
#include <ctype.h>
static inline const char* index_into_base(const char*const* base, int index,
#include "SkVarAlloc.h"
+#include "SkMemory.h"
+
struct SkVarAlloc::Block {
Block* prev;
char* data() { return (char*)(this + 1); }
#include "SkGradientBitmapCache.h"
+#include "SkMemory.h"
+
struct SkGradientBitmapCache::Entry {
Entry* fPrev;
Entry* fNext;
#include "GrMemoryPool.h"
+#include "SkMemory.h"
+
#ifdef SK_DEBUG
#define VALIDATE this->validate()
#else
#include "GrRectanizer.h"
#include "SkMathPriv.h"
+#include "SkMemory.h"
#include "SkPoint.h"
// This Rectanizer quantizes the incoming rects to powers of 2. Each power
#include "SkDiscardableMemory.h"
#include "SkDiscardableMemoryPool.h"
#include "SkImageGenerator.h"
+#include "SkMemory.h"
#include "SkMutex.h"
#include "SkOnce.h"
#include "SkTInternalLList.h"
#include "SkData.h"
#include "SkDeflate.h"
#include "SkMakeUnique.h"
+#include "SkMemory.h"
#include "zlib.h"
#include "SkMask.h"
#include "SkMaskGamma.h"
#include "SkMatrix22.h"
+#include "SkMemory.h"
#include "SkMutex.h"
#include "SkOTUtils.h"
#include "SkPath.h"
#include "SkFixed.h"
#include "SkFontMgr.h"
#include "SkFontMgr_android_parser.h"
+#include "SkMemory.h"
#include "SkOSFile.h"
#include "SkStream.h"
#include "SkTDArray.h"
* 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))
* 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"
#if defined(SK_BUILD_FOR_WIN32)
#include "SkLeanWindows.h"
+#include "SkMemory.h"
#include "SkOSFile.h"
#include "SkTFitsIn.h"
* 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() {
*/
#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