rngine 0.7.2 → 0.8.1

package/shared/skia/include/private/SkASAN.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkASAN_DEFINED
+#define SkASAN_DEFINED
+
+#include <cstddef>
+
+#ifdef __SANITIZE_ADDRESS__
+    #define SK_SANITIZE_ADDRESS 1
+#endif
+#if !defined(SK_SANITIZE_ADDRESS) && defined(__has_feature)
+    #if __has_feature(address_sanitizer)
+        #define SK_SANITIZE_ADDRESS 1
+    #endif
+#endif
+
+// Typically declared in LLVM's asan_interface.h.
+#ifdef SK_SANITIZE_ADDRESS
+extern "C" {
+    void __asan_poison_memory_region(void const volatile *addr, size_t size);
+    void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+    int __asan_address_is_poisoned(void const volatile *addr);
+}
+#endif
+
+// Code that implements bespoke allocation arenas can poison the entire arena on creation, then
+// unpoison chunks of arena memory as they are parceled out. Consider leaving gaps between blocks
+// to detect buffer overrun.
+static inline void sk_asan_poison_memory_region([[maybe_unused]] void const volatile* addr,
+                                                [[maybe_unused]] size_t size) {
+#ifdef SK_SANITIZE_ADDRESS
+    __asan_poison_memory_region(addr, size);
+#endif
+}
+
+static inline void sk_asan_unpoison_memory_region([[maybe_unused]] void const volatile* addr,
+                                                  [[maybe_unused]] size_t size) {
+#ifdef SK_SANITIZE_ADDRESS
+    __asan_unpoison_memory_region(addr, size);
+#endif
+}
+
+static inline int sk_asan_address_is_poisoned([[maybe_unused]] void const volatile* addr) {
+#ifdef SK_SANITIZE_ADDRESS
+    return __asan_address_is_poisoned(addr);
+#else
+    return 0;
+#endif
+}
+
+#endif  // SkASAN_DEFINED

package/shared/skia/include/private/SkAlign.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAlign_DEFINED
+#define SkAlign_DEFINED
+
+#include "include/private/SkAssert.h"
+
+#include <cstddef>
+
+template <typename T> static constexpr T SkAlign2(T x) { return (x + 1) >> 1 << 1; }
+template <typename T> static constexpr T SkAlign4(T x) { return (x + 3) >> 2 << 2; }
+template <typename T> static constexpr T SkAlign8(T x) { return (x + 7) >> 3 << 3; }
+template <typename T> static constexpr T SkAlign16(T x) { return (x + 15) >> 4 << 4; }
+
+template <typename T> static constexpr bool SkIsAlign2(T x) { return 0 == (x & 1); }
+template <typename T> static constexpr bool SkIsAlign4(T x) { return 0 == (x & 3); }
+template <typename T> static constexpr bool SkIsAlign8(T x) { return 0 == (x & 7); }
+template <typename T> static constexpr bool SkIsAlign16(T x) { return 0 == (x & 15); }
+
+
+template <typename T> static constexpr T SkAlignPtr(T x) {
+    static_assert(sizeof(void*) == 4 || sizeof(void*) == 8);
+    return sizeof(void*) == 8 ? SkAlign8(x) : SkAlign4(x);
+}
+template <typename T> static constexpr bool SkIsAlignPtr(T x) {
+    static_assert(sizeof(void*) == 4 || sizeof(void*) == 8);
+    return sizeof(void*) == 8 ? SkIsAlign8(x) : SkIsAlign4(x);
+}
+
+/**
+ *  align up to a power of 2
+ */
+template <typename T> static constexpr T SkAlignTo(T x, T alignment) {
+    // The same as alignment && SkIsPow2(value), w/o a dependency cycle.
+    SkASSERT(alignment && (alignment & (alignment - 1)) == 0);
+    return (x + alignment - 1) & ~(alignment - 1);
+}
+
+/**
+ *  align up to a non power of 2
+ */
+template <typename T> static constexpr T SkAlignNonPow2(T x, T alignment) {
+    return ((x + alignment - 1) / alignment) * alignment;
+}
+
+#endif

package/shared/skia/include/private/SkAlignedStorage.h

@@ -0,0 +1,32 @@
+// Copyright 2022 Google LLC
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+#ifndef SkAlignedStorage_DEFINED
+#define SkAlignedStorage_DEFINED
+
+#include <cstddef>
+#include <iterator>
+
+template <int N, typename T> class SkAlignedSTStorage {
+public:
+    SkAlignedSTStorage() {}
+    SkAlignedSTStorage(SkAlignedSTStorage&&) = delete;
+    SkAlignedSTStorage(const SkAlignedSTStorage&) = delete;
+    SkAlignedSTStorage& operator=(SkAlignedSTStorage&&) = delete;
+    SkAlignedSTStorage& operator=(const SkAlignedSTStorage&) = delete;
+
+    // Returns void* because this object does not initialize the
+    // memory. Use placement new for types that require a constructor.
+    void* get() { return fStorage; }
+    const void* get() const { return fStorage; }
+
+    // Act as a container of bytes because the storage is uninitialized.
+    std::byte* data() { return fStorage; }
+    const std::byte* data() const { return fStorage; }
+    size_t size() const { return std::size(fStorage); }
+
+private:
+    alignas(T) std::byte fStorage[sizeof(T) * N];
+};
+
+#endif  // SkAlignedStorage_DEFINED

package/shared/skia/include/private/SkAnySubclass.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAnySubclass_DEFINED
+#define SkAnySubclass_DEFINED
+
+#include "include/private/SkAssert.h"
+
+#include <cstddef>
+#include <new>
+#include <type_traits>  // IWYU pragma: keep
+#include <utility>
+
+/**
+ *  Stores any subclass `T` of `Base`, where sizeof(T) <= `Size`, without using the heap.
+ *  Doesn't need advance knowledge of T, so it's particularly suited to platform or backend
+ *  implementations of a generic interface, where the set of possible subclasses is finite and
+ *  known, but can't be made available at compile-time.
+ */
+template <typename Base, size_t Size>
+class SkAnySubclass {
+public:
+    SkAnySubclass() = default;
+    ~SkAnySubclass() {
+        this->reset();
+    }
+
+    SkAnySubclass(const SkAnySubclass&) = delete;
+    SkAnySubclass& operator=(const SkAnySubclass&) = delete;
+    SkAnySubclass(SkAnySubclass&&) = delete;
+    SkAnySubclass& operator=(SkAnySubclass&&) = delete;
+
+    template <typename T, typename... Args>
+    void emplace(Args&&... args) {
+        static_assert(std::is_base_of_v<Base, T>);
+        static_assert(sizeof(T) <= Size);
+        // We're going to clean up our stored object by calling ~Base:
+        static_assert(std::has_virtual_destructor_v<Base> || std::is_trivially_destructible_v<T>);
+        SkASSERT(!fValid);
+        new (fData) T(std::forward<Args>(args)...);
+        fValid = true;
+    }
+
+    void reset() {
+        if (fValid) {
+            this->get()->~Base();
+        }
+        fValid = false;
+    }
+
+    bool has_value() const { return fValid; }
+    explicit operator bool() const { return this->has_value(); }
+
+    const Base* get() const {
+        SkASSERT(fValid);
+        return std::launder(reinterpret_cast<const Base*>(fData));
+    }
+
+    Base* get() {
+        SkASSERT(fValid);
+        return std::launder(reinterpret_cast<Base*>(fData));
+    }
+
+    Base* operator->() { return this->get(); }
+    const Base* operator->() const { return this->get(); }
+
+    Base& operator*() { return *this->get(); }
+    const Base& operator*() const { return *this->get(); }
+
+private:
+    alignas(8) std::byte fData[Size];
+    bool fValid = false;
+};
+
+#endif  // SkAnySubclass_DEFINED

package/shared/skia/include/private/SkAssert.h

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAssert_DEFINED
+#define SkAssert_DEFINED
+
+#include "include/private/SkAPI.h"
+#include "include/private/SkAttributes.h"
+#include "include/private/SkDebug.h" // IWYU pragma: keep
+#include "include/private/SkLog.h"
+
+#include <cstddef>
+#include <limits>
+
+#if defined(__clang__) && defined(__has_attribute)
+    #if __has_attribute(likely)
+        #define SK_LIKELY [[likely]]
+        #define SK_UNLIKELY [[unlikely]]
+    #else
+        #define SK_LIKELY
+        #define SK_UNLIKELY
+    #endif
+#else
+    #define SK_LIKELY
+    #define SK_UNLIKELY
+#endif
+
+// c++23 will give us [[assume]] -- until then we're stuck with various other options:
+#if defined(__clang__)
+    #define SK_ASSUME(cond) __builtin_assume(cond)
+#elif defined(__GNUC__)
+    #if __GNUC__ >= 13
+        #define SK_ASSUME(cond) __attribute__((assume(cond)))
+    #else
+        // NOTE: This implementation could actually evaluate `cond`, which is not desirable.
+        #define SK_ASSUME(cond) ((cond) ? (void)0 : __builtin_unreachable())
+    #endif
+#elif defined(_MSC_VER)
+    #define SK_ASSUME(cond) __assume(cond)
+#else
+    #define SK_ASSUME(cond) ((void)0)
+#endif
+
+/** Called internally if we hit an unrecoverable error.
+    The platform implementation must not return, but should either throw
+    an exception or otherwise exit.
+*/
+[[noreturn]] SK_API extern void sk_abort_no_print(void);
+
+#if defined(SK_BUILD_FOR_GOOGLE3)
+    void SkDebugfForDumpStackTrace(const char* data, void* unused);
+    namespace base {
+        void DumpStackTrace(int skip_count, void w(const char*, void*), void* arg);
+    }
+#  define SK_DUMP_GOOGLE3_STACK() ::base::DumpStackTrace(0, SkDebugfForDumpStackTrace, nullptr)
+#else
+#  define SK_DUMP_GOOGLE3_STACK()
+#endif
+
+#if !defined(SK_ABORT)
+#  if defined(SK_BUILD_FOR_WIN)
+     // This style lets Visual Studio follow errors back to the source file.
+#    define SK_DUMP_LINE_FORMAT "%s(%d)"
+#  else
+#    define SK_DUMP_LINE_FORMAT "%s:%d"
+#  endif
+#  define SK_ABORT(message, ...) \
+    do { \
+        SKIA_LOG_E(SK_DUMP_LINE_FORMAT ": fatal error: \"" message "\"", \
+                 __FILE__, __LINE__, ##__VA_ARGS__); \
+        SK_DUMP_GOOGLE3_STACK(); \
+        sk_abort_no_print(); \
+    } while (false)
+#endif
+
+// SkASSERT, SkASSERTF and SkASSERT_RELEASE can be used as standalone assertion expressions, e.g.
+//    uint32_t foo(int x) {
+//        SkASSERT(x > 4);
+//        return x - 4;
+//    }
+// and are also written to be compatible with constexpr functions:
+//    constexpr uint32_t foo(int x) {
+//        return SkASSERT(x > 4),
+//               x - 4;
+//    }
+#if defined(__clang__)
+#define SkASSERT_RELEASE(cond) \
+    static_cast<void>( __builtin_expect(static_cast<bool>(cond), 1) \
+        ? static_cast<void>(0) \
+        : []{ SK_ABORT("check(%s)", #cond); }() )
+
+#define SkASSERTF_RELEASE(cond, fmt, ...)                                  \
+    static_cast<void>( __builtin_expect(static_cast<bool>(cond), 1)        \
+        ? static_cast<void>(0)                                             \
+        : [&]{ SK_ABORT("assertf(%s): " fmt, #cond, ##__VA_ARGS__); }() )
+#else
+#define SkASSERT_RELEASE(cond) \
+    static_cast<void>( (cond) ? static_cast<void>(0) : []{ SK_ABORT("check(%s)", #cond); }() )
+
+#define SkASSERTF_RELEASE(cond, fmt, ...)                                   \
+    static_cast<void>( (cond)                                               \
+        ? static_cast<void>(0)                                              \
+        : [&]{ SK_ABORT("assertf(%s): " fmt, #cond, ##__VA_ARGS__); }() )
+#endif
+
+#if defined(SK_DEBUG)
+    #define SkASSERT(cond)            SkASSERT_RELEASE(cond)
+    #define SkASSERTF(cond, fmt, ...) SkASSERTF_RELEASE(cond, fmt, ##__VA_ARGS__)
+    #define SkDEBUGFAIL(message)      SK_ABORT("%s", message)
+    #define SkDEBUGFAILF(fmt, ...)    SK_ABORT(fmt, ##__VA_ARGS__)
+    #define SkAssertResult(cond)      SkASSERT(cond)
+#else
+    #define SkASSERT(cond)            static_cast<void>(0)
+    #define SkASSERTF(cond, fmt, ...) static_cast<void>(0)
+    #define SkDEBUGFAIL(message)
+    #define SkDEBUGFAILF(fmt, ...)
+
+    // unlike SkASSERT, this macro executes its condition in the non-debug build.
+    // The if is present so that this can be used with functions marked [[nodiscard]].
+    #define SkAssertResult(cond)         if (cond) {} do {} while(false)
+#endif
+
+#if !defined(SkUNREACHABLE)
+#  if defined(_MSC_VER) && !defined(__clang__)
+#    include <intrin.h>
+#    define FAST_FAIL_INVALID_ARG                 5
+// See https://developercommunity.visualstudio.com/content/problem/1128631/code-flow-doesnt-see-noreturn-with-extern-c.html
+// for why this is wrapped. Hopefully removable after msvc++ 19.27 is no longer supported.
+[[noreturn]] static inline void sk_fast_fail() { __fastfail(FAST_FAIL_INVALID_ARG); }
+#    define SkUNREACHABLE sk_fast_fail()
+#  else
+#    define SkUNREACHABLE __builtin_trap()
+#  endif
+#endif
+
+[[noreturn]] SK_API inline void sk_print_index_out_of_bounds(size_t i, size_t size) {
+    SK_ABORT("Index (%zu) out of bounds for size %zu.", i, size);
+}
+
+template <typename T> SK_API inline T sk_collection_check_bounds(T i, T size) {
+    if (0 <= i && i < size) SK_LIKELY {
+        return i;
+    }
+
+    SK_UNLIKELY {
+        #if defined(SK_DEBUG)
+            sk_print_index_out_of_bounds(static_cast<size_t>(i), static_cast<size_t>(size));
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+}
+
+[[noreturn]] SK_API inline void sk_print_length_too_big(size_t i, size_t size) {
+    SK_ABORT("Length (%zu) is too big for size %zu.", i, size);
+}
+
+template <typename T> SK_API inline T sk_collection_check_length(T i, T size) {
+    if (0 <= i && i <= size) SK_LIKELY {
+        return i;
+    }
+
+    SK_UNLIKELY {
+        #if defined(SK_DEBUG)
+            sk_print_length_too_big(static_cast<size_t>(i), static_cast<size_t>(size));
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+}
+
+SK_API inline void sk_collection_not_empty(bool empty) {
+    if (empty) SK_UNLIKELY {
+        #if defined(SK_DEBUG)
+            SK_ABORT("Collection is empty.");
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+}
+
+[[noreturn]] SK_API inline void sk_print_size_too_big(size_t size, size_t maxSize) {
+    SK_ABORT("Size (%zu) can't be represented in bytes. Max size is %zu.", size, maxSize);
+}
+
+template <typename T>
+SK_ALWAYS_INLINE size_t check_size_bytes_too_big(size_t size) {
+    const size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
+    if (size > kMaxSize) {
+        #if defined(SK_DEBUG)
+            sk_print_size_too_big(size, kMaxSize);
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+    return size;
+}
+
+#endif  // SkAssert_DEFINED

package/shared/skia/include/private/SkAttributes.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAttributes_DEFINED
+#define SkAttributes_DEFINED
+
+#include "include/private/SkFeatures.h" // IWYU pragma: keep
+#include "include/private/SkLoadUserConfig.h" // IWYU pragma: keep
+
+#if defined(__clang__) || defined(__GNUC__)
+#  define SK_ATTRIBUTE(attr) __attribute__((attr))
+#else
+#  define SK_ATTRIBUTE(attr)
+#endif
+
+/**
+ * If your judgment is better than the compiler's (i.e. you've profiled it),
+ * you can use SK_ALWAYS_INLINE to force inlining. E.g.
+ *     inline void someMethod() { ... }             // may not be inlined
+ *     SK_ALWAYS_INLINE void someMethod() { ... }   // should always be inlined
+ */
+#if !defined(SK_ALWAYS_INLINE)
+#  if defined(SK_BUILD_FOR_WIN)
+#    define SK_ALWAYS_INLINE __forceinline
+#  else
+#    define SK_ALWAYS_INLINE SK_ATTRIBUTE(always_inline) inline
+#  endif
+#endif
+
+/**
+ * If your judgment is better than the compiler's (i.e. you've profiled it),
+ * you can use SK_NEVER_INLINE to prevent inlining.
+ */
+#if !defined(SK_NEVER_INLINE)
+#  if defined(SK_BUILD_FOR_WIN)
+#    define SK_NEVER_INLINE __declspec(noinline)
+#  else
+#    define SK_NEVER_INLINE SK_ATTRIBUTE(noinline)
+#  endif
+#endif
+
+/**
+ * Used to annotate a function as taking printf style arguments.
+ * `A` is the (1 based) index of the format string argument.
+ * `B` is the (1 based) index of the first argument used by the format string.
+ */
+#if !defined(SK_PRINTF_LIKE)
+#  define SK_PRINTF_LIKE(A, B) SK_ATTRIBUTE(format(printf, (A), (B)))
+#endif
+
+/**
+ * Used to ignore sanitizer warnings.
+ */
+#if !defined(SK_NO_SANITIZE)
+  #if defined(__has_attribute)
+    #if __has_attribute(no_sanitize)
+      // This should be for clang and versions of gcc >= 8.0
+      #define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
+    #else
+      // For compilers that don't support sanitization, just do nothing.
+      #define SK_NO_SANITIZE(A)
+    #endif
+  #else // no __has_attribute, e.g. MSVC
+    #define SK_NO_SANITIZE(A)
+  #endif
+#endif
+
+/**
+ * Used to ignore CFI sanitizer warnings, supported only by Clang at the moment.
+ */
+#if defined(__clang__)
+  #define SK_NO_SANITIZE_CFI SK_NO_SANITIZE("cfi")
+#else
+  #define SK_NO_SANITIZE_CFI
+#endif
+
+/**
+ * Annotates a class' non-trivial special functions as trivial for the purposes of calls.
+ * Allows a class with a non-trivial destructor to be __is_trivially_relocatable.
+ * Use of this attribute on a public API breaks platform ABI.
+ * Annotated classes may not hold pointers derived from `this`.
+ * Annotated classes must implement move+delete as equivalent to memcpy+free.
+ * Use may require more complete types, as callee destroys.
+ *
+ * https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
+ * https://libcxx.llvm.org/DesignDocs/UniquePtrTrivialAbi.html
+ */
+#if !defined(SK_TRIVIAL_ABI)
+#  define SK_TRIVIAL_ABI
+#endif
+
+#endif

package/shared/skia/include/private/SkCPUTypes.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkCPUTypes_DEFINED
+#define SkCPUTypes_DEFINED
+
+// TODO(bungeman,kjlubick) There are a lot of assumptions throughout the codebase that
+//   these types are 32 bits, when they could be more or less. Public APIs should stop
+//   using these. Internally, we could use uint_fast8_t and uint_fast16_t, but not in
+//   public APIs due to ABI incompatibilities.
+
+/** Fast type for unsigned 8 bits. Use for parameter passing and local
+    variables, not for storage
+*/
+typedef unsigned U8CPU;
+
+/** Fast type for unsigned 16 bits. Use for parameter passing and local
+    variables, not for storage
+*/
+typedef unsigned U16CPU;
+
+#endif

package/shared/skia/include/private/SkContainers.h

@@ -0,0 +1,54 @@
+// Copyright 2022 Google LLC
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+#ifndef SkContainers_DEFINED
+#define SkContainers_DEFINED
+
+#include "include/core/SkSpan.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkAlign.h"
+
+#include <cstddef>
+#include <cstdint>
+
+class SK_SPI SkContainerAllocator {
+public:
+    SkContainerAllocator(size_t sizeOfT, int maxCapacity)
+            : fSizeOfT{sizeOfT}
+            , fMaxCapacity{maxCapacity} {}
+
+    // allocate will abort on failure. Given a capacity of 0, it will return the empty span.
+    // The bytes allocated are freed using sk_free().
+    SkSpan<std::byte> allocate(int capacity, double growthFactor = 1.0);
+
+    // Rounds a requested capacity up towards `kCapacityMultiple` in a constexpr-friendly fashion.
+    template <typename T>
+    static constexpr size_t RoundUp(size_t capacity) {
+        return SkAlignTo(capacity * sizeof(T), (size_t) kCapacityMultiple) / sizeof(T);
+    }
+
+private:
+    friend struct SkContainerAllocatorTestingPeer;
+
+    // All capacity counts will be rounded up to kCapacityMultiple. This matches ASAN's shadow
+    // granularity, as well as our typical struct alignment on a 64-bit machine.
+    static constexpr int64_t kCapacityMultiple = 8;
+
+    // Rounds up capacity to next multiple of kCapacityMultiple and pin to fMaxCapacity.
+    size_t roundUpCapacity(int64_t capacity) const;
+
+    // Grows the capacity by growthFactor being sure to stay with in kMinBytes and fMaxCapacity.
+    size_t growthFactorCapacity(int capacity, double growthFactor) const;
+
+    const size_t fSizeOfT;
+    const int64_t fMaxCapacity;
+};
+
+// sk_allocate_canfail returns the empty span on failure. Parameter size must be > 0.
+SkSpan<std::byte> sk_allocate_canfail(size_t size);
+
+// Returns the empty span if size is 0. sk_allocate_throw aborts on failure.
+SkSpan<std::byte> sk_allocate_throw(size_t size);
+
+SK_SPI void sk_report_container_overflow_and_die();
+#endif  // SkContainers_DEFINED

package/shared/skia/include/private/SkDebug.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkDebug_DEFINED
+#define SkDebug_DEFINED
+
+#include "include/private/SkAPI.h"
+#include "include/private/SkAttributes.h"
+#include "include/private/SkLoadUserConfig.h" // IWYU pragma: keep
+
+#if !defined(SkDebugf)
+    void SK_SPI SkDebugf(const char format[], ...) SK_PRINTF_LIKE(1, 2);
+#endif
+
+#if defined(SK_DEBUG)
+    #define SkDEBUGCODE(...)  __VA_ARGS__
+    #define SkDEBUGF(...)     SkDebugf(__VA_ARGS__)
+#else
+    #define SkDEBUGCODE(...)
+    #define SkDEBUGF(...)
+#endif
+
+#endif