Revert[3] "move some public headers into private"

This reverts commit 9d20ee57d72a3850a6b51f2f2b00e00978be3864.

BUG=skia:
TBR=

failures here: https://codereview.chromium.org/1286103004

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

3 files changed, 0 insertions, 461 deletions

diff --git a/include/private/SkFloatBits.h b/include/private/SkFloatBits.h
deleted file mode 100644
index 3ddb9ef564..0000000000
--- a/include/private/SkFloatBits.h
+++ /dev/null
@@ -1,132 +0,0 @@
-
-/*
- * Copyright 2008 The Android Open Source Project
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#ifndef SkFloatBits_DEFINED
-#define SkFloatBits_DEFINED
-
-#include "SkTypes.h"
-
-/** Convert a sign-bit int (i.e. float interpreted as int) into a 2s compliement
-    int. This also converts -0 (0x80000000) to 0. Doing this to a float allows
-    it to be compared using normal C operators (<, <=, etc.)
-*/
-static inline int32_t SkSignBitTo2sCompliment(int32_t x) {
-    if (x < 0) {
-        x &= 0x7FFFFFFF;
-        x = -x;
-    }
-    return x;
-}
-
-/** Convert a 2s compliment int to a sign-bit (i.e. int interpreted as float).
-    This undoes the result of SkSignBitTo2sCompliment().
- */
-static inline int32_t Sk2sComplimentToSignBit(int32_t x) {
-    int sign = x >> 31;
-    // make x positive
-    x = (x ^ sign) - sign;
-    // set the sign bit as needed
-    x |= sign << 31;
-    return x;
-}
-
-/** Given the bit representation of a float, return its value cast to an int.
-    If the value is out of range, or NaN, return return +/- SK_MaxS32
-*/
-int32_t SkFloatBits_toIntCast(int32_t floatBits);
-
-/** Given the bit representation of a float, return its floor as an int.
-    If the value is out of range, or NaN, return return +/- SK_MaxS32
- */
-SK_API int32_t SkFloatBits_toIntFloor(int32_t floatBits);
-
-/** Given the bit representation of a float, return it rounded to an int.
-    If the value is out of range, or NaN, return return +/- SK_MaxS32
- */
-SK_API int32_t SkFloatBits_toIntRound(int32_t floatBits);
-
-/** Given the bit representation of a float, return its ceiling as an int.
-    If the value is out of range, or NaN, return return +/- SK_MaxS32
- */
-SK_API int32_t SkFloatBits_toIntCeil(int32_t floatBits);
-
-
-union SkFloatIntUnion {
-    float   fFloat;
-    int32_t fSignBitInt;
-};
-
-// Helper to see a float as its bit pattern (w/o aliasing warnings)
-static inline int32_t SkFloat2Bits(float x) {
-    SkFloatIntUnion data;
-    data.fFloat = x;
-    return data.fSignBitInt;
-}
-
-// Helper to see a bit pattern as a float (w/o aliasing warnings)
-static inline float SkBits2Float(int32_t floatAsBits) {
-    SkFloatIntUnion data;
-    data.fSignBitInt = floatAsBits;
-    return data.fFloat;
-}
-
-/** Return the float as a 2s compliment int. Just to be used to compare floats
-    to each other or against positive float-bit-constants (like 0). This does
-    not return the int equivalent of the float, just something cheaper for
-    compares-only.
- */
-static inline int32_t SkFloatAs2sCompliment(float x) {
-    return SkSignBitTo2sCompliment(SkFloat2Bits(x));
-}
-
-/** Return the 2s compliment int as a float. This undos the result of
-    SkFloatAs2sCompliment
- */
-static inline float Sk2sComplimentAsFloat(int32_t x) {
-    return SkBits2Float(Sk2sComplimentToSignBit(x));
-}
-
-/** Return x cast to a float (i.e. (float)x)
-*/
-float SkIntToFloatCast(int x);
-
-/** Return the float cast to an int.
-    If the value is out of range, or NaN, return +/- SK_MaxS32
-*/
-static inline int32_t SkFloatToIntCast(float x) {
-    return SkFloatBits_toIntCast(SkFloat2Bits(x));
-}
-
-/** Return the floor of the float as an int.
-    If the value is out of range, or NaN, return +/- SK_MaxS32
-*/
-static inline int32_t SkFloatToIntFloor(float x) {
-    return SkFloatBits_toIntFloor(SkFloat2Bits(x));
-}
-
-/** Return the float rounded to an int.
-    If the value is out of range, or NaN, return +/- SK_MaxS32
-*/
-static inline int32_t SkFloatToIntRound(float x) {
-    return SkFloatBits_toIntRound(SkFloat2Bits(x));
-}
-
-/** Return the ceiling of the float as an int.
-    If the value is out of range, or NaN, return +/- SK_MaxS32
-*/
-static inline int32_t SkFloatToIntCeil(float x) {
-    return SkFloatBits_toIntCeil(SkFloat2Bits(x));
-}
-
-//  Scalar wrappers for float-bit routines
-
-#define SkScalarAs2sCompliment(x)    SkFloatAs2sCompliment(x)
-#define Sk2sComplimentAsScalar(x)    Sk2sComplimentAsFloat(x)
-
-#endif
diff --git a/include/private/SkFloatingPoint.h b/include/private/SkFloatingPoint.h
deleted file mode 100644
index f7ee816b12..0000000000
--- a/include/private/SkFloatingPoint.h
+++ /dev/null
@@ -1,170 +0,0 @@
-
-/*
- * Copyright 2006 The Android Open Source Project
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#ifndef SkFloatingPoint_DEFINED
-#define SkFloatingPoint_DEFINED
-
-#include "SkTypes.h"
-
-#include <math.h>
-#include <float.h>
-
-// For _POSIX_VERSION
-#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-#include <unistd.h>
-#endif
-
-#include "SkFloatBits.h"
-
-// C++98 cmath std::pow seems to be the earliest portable way to get float pow.
-// However, on Linux including cmath undefines isfinite.
-// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14608
-static inline float sk_float_pow(float base, float exp) {
-    return powf(base, exp);
-}
-
-static inline float sk_float_copysign(float x, float y) {
-// c++11 contains a 'float copysign(float, float)' function in <cmath>.
-// clang-cl reports __cplusplus for clang, not the __cplusplus vc++ version _MSC_VER would report.
-#if (defined(_MSC_VER) && defined(__clang__))
-#    define SK_BUILD_WITH_CLANG_CL 1
-#else
-#    define SK_BUILD_WITH_CLANG_CL 0
-#endif
-#if (!SK_BUILD_WITH_CLANG_CL && __cplusplus >= 201103L) || (_MSC_VER >= 1800)
-    return copysignf(x, y);
-
-// Posix has demanded 'float copysignf(float, float)' (from C99) since Issue 6.
-#elif defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
-    return copysignf(x, y);
-
-// Visual studio prior to 13 only has 'double _copysign(double, double)'.
-#elif defined(_MSC_VER)
-    return (float)_copysign(x, y);
-
-// Otherwise convert to bits and extract sign.
-#else
-    int32_t xbits = SkFloat2Bits(x);
-    int32_t ybits = SkFloat2Bits(y);
-    return SkBits2Float((xbits & 0x7FFFFFFF) | (ybits & 0x80000000));
-#endif
-}
-
-#define sk_float_sqrt(x)        sqrtf(x)
-#define sk_float_sin(x)         sinf(x)
-#define sk_float_cos(x)         cosf(x)
-#define sk_float_tan(x)         tanf(x)
-#define sk_float_floor(x)       floorf(x)
-#define sk_float_ceil(x)        ceilf(x)
-#ifdef SK_BUILD_FOR_MAC
-#    define sk_float_acos(x)    static_cast<float>(acos(x))
-#    define sk_float_asin(x)    static_cast<float>(asin(x))
-#else
-#    define sk_float_acos(x)    acosf(x)
-#    define sk_float_asin(x)    asinf(x)
-#endif
-#define sk_float_atan2(y,x)     atan2f(y,x)
-#define sk_float_abs(x)         fabsf(x)
-#define sk_float_mod(x,y)       fmodf(x,y)
-#define sk_float_exp(x)         expf(x)
-#define sk_float_log(x)         logf(x)
-
-#define sk_float_round(x) sk_float_floor((x) + 0.5f)
-
-// can't find log2f on android, but maybe that just a tool bug?
-#ifdef SK_BUILD_FOR_ANDROID
-    static inline float sk_float_log2(float x) {
-        const double inv_ln_2 = 1.44269504088896;
-        return (float)(log(x) * inv_ln_2);
-    }
-#else
-    #define sk_float_log2(x)        log2f(x)
-#endif
-
-#ifdef SK_BUILD_FOR_WIN
-    #define sk_float_isfinite(x)    _finite(x)
-    #define sk_float_isnan(x)       _isnan(x)
-    static inline int sk_float_isinf(float x) {
-        int32_t bits = SkFloat2Bits(x);
-        return (bits << 1) == (0xFF << 24);
-    }
-#else
-    #define sk_float_isfinite(x)    isfinite(x)
-    #define sk_float_isnan(x)       isnan(x)
-    #define sk_float_isinf(x)       isinf(x)
-#endif
-
-#define sk_double_isnan(a)          sk_float_isnan(a)
-
-#ifdef SK_USE_FLOATBITS
-    #define sk_float_floor2int(x)   SkFloatToIntFloor(x)
-    #define sk_float_round2int(x)   SkFloatToIntRound(x)
-    #define sk_float_ceil2int(x)    SkFloatToIntCeil(x)
-#else
-    #define sk_float_floor2int(x)   (int)sk_float_floor(x)
-    #define sk_float_round2int(x)   (int)sk_float_floor((x) + 0.5f)
-    #define sk_float_ceil2int(x)    (int)sk_float_ceil(x)
-#endif
-
-#define sk_double_floor(x)          floor(x)
-#define sk_double_round(x)          floor((x) + 0.5)
-#define sk_double_ceil(x)           ceil(x)
-#define sk_double_floor2int(x)      (int)floor(x)
-#define sk_double_round2int(x)      (int)floor((x) + 0.5f)
-#define sk_double_ceil2int(x)       (int)ceil(x)
-
-extern const uint32_t gIEEENotANumber;
-extern const uint32_t gIEEEInfinity;
-extern const uint32_t gIEEENegativeInfinity;
-
-#define SK_FloatNaN                 (*SkTCast<const float*>(&gIEEENotANumber))
-#define SK_FloatInfinity            (*SkTCast<const float*>(&gIEEEInfinity))
-#define SK_FloatNegativeInfinity    (*SkTCast<const float*>(&gIEEENegativeInfinity))
-
-// We forward declare this to break an #include cycle.
-// (SkScalar -> SkFloatingPoint -> SkOpts.h -> SkXfermode -> SkColor -> SkScalar)
-namespace SkOpts { extern float (*rsqrt)(float); }
-
-// Fast, approximate inverse square root.
-// Compare to name-brand "1.0f / sk_float_sqrt(x)".  Should be around 10x faster on SSE, 2x on NEON.
-static inline float sk_float_rsqrt(const float x) {
-// We want all this inlined, so we'll inline SIMD and just take the hit when we don't know we've got
-// it at compile time.  This is going to be too fast to productively hide behind a function pointer.
-//
-// We do one step of Newton's method to refine the estimates in the NEON and null paths.  No
-// refinement is faster, but very innacurate.  Two steps is more accurate, but slower than 1/sqrt.
-//
-// Optimized constants in the null path courtesy of http://rrrola.wz.cz/inv_sqrt.html
-#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
-    return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x)));
-#elif defined(SK_ARM_HAS_NEON)
-    // Get initial estimate.
-    const float32x2_t xx = vdup_n_f32(x);  // Clever readers will note we're doing everything 2x.
-    float32x2_t estimate = vrsqrte_f32(xx);
-
-    // One step of Newton's method to refine.
-    const float32x2_t estimate_sq = vmul_f32(estimate, estimate);
-    estimate = vmul_f32(estimate, vrsqrts_f32(xx, estimate_sq));
-    return vget_lane_f32(estimate, 0);  // 1 will work fine too; the answer's in both places.
-#else
-    // Perhaps runtime-detected NEON, or a portable fallback.
-    return SkOpts::rsqrt(x);
-#endif
-}
-
-// This is the number of significant digits we can print in a string such that when we read that
-// string back we get the floating point number we expect.  The minimum value C requires is 6, but
-// most compilers support 9
-#ifdef FLT_DECIMAL_DIG
-#define SK_FLT_DECIMAL_DIG FLT_DECIMAL_DIG
-#else
-#define SK_FLT_DECIMAL_DIG 9
-#endif
-
-#endif
diff --git a/include/private/SkWeakRefCnt.h b/include/private/SkWeakRefCnt.h
deleted file mode 100644
index a550951970..0000000000
--- a/include/private/SkWeakRefCnt.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkWeakRefCnt_DEFINED
-#define SkWeakRefCnt_DEFINED
-
-#include "SkRefCnt.h"
-#include "SkAtomics.h"
-
-/** \class SkWeakRefCnt
-
-    SkWeakRefCnt is the base class for objects that may be shared by multiple
-    objects. When an existing strong owner wants to share a reference, it calls
-    ref(). When a strong owner wants to release its reference, it calls
-    unref(). When the shared object's strong reference count goes to zero as
-    the result of an unref() call, its (virtual) weak_dispose method is called.
-    It is an error for the destructor to be called explicitly (or via the
-    object going out of scope on the stack or calling delete) if
-    getRefCnt() > 1.
-
-    In addition to strong ownership, an owner may instead obtain a weak
-    reference by calling weak_ref(). A call to weak_ref() must be balanced by a
-    call to weak_unref(). To obtain a strong reference from a weak reference,
-    call try_ref(). If try_ref() returns true, the owner's pointer is now also
-    a strong reference on which unref() must be called. Note that this does not
-    affect the original weak reference, weak_unref() must still be called. When
-    the weak reference count goes to zero, the object is deleted. While the
-    weak reference count is positive and the strong reference count is zero the
-    object still exists, but will be in the disposed state. It is up to the
-    object to define what this means.
-
-    Note that a strong reference implicitly implies a weak reference. As a
-    result, it is allowable for the owner of a strong ref to call try_ref().
-    This will have the same effect as calling ref(), but may be more expensive.
-
-    Example:
-
-    SkWeakRefCnt myRef = strongRef.weak_ref();
-    ... // strongRef.unref() may or may not be called
-    if (myRef.try_ref()) {
-        ... // use myRef
-        myRef.unref();
-    } else {
-        // myRef is in the disposed state
-    }
-    myRef.weak_unref();
-*/
-class SK_API SkWeakRefCnt : public SkRefCnt {
-public:
-    /** Default construct, initializing the reference counts to 1.
-        The strong references collectively hold one weak reference. When the
-        strong reference count goes to zero, the collectively held weak
-        reference is released.
-    */
-    SkWeakRefCnt() : SkRefCnt(), fWeakCnt(1) {}
-
-    /** Destruct, asserting that the weak reference count is 1.
-    */
-    virtual ~SkWeakRefCnt() {
-#ifdef SK_DEBUG
-        SkASSERT(fWeakCnt == 1);
-        fWeakCnt = 0;
-#endif
-    }
-
-    /** Return the weak reference count.
-    */
-    int32_t getWeakCnt() const { return fWeakCnt; }
-
-#ifdef SK_DEBUG
-    void validate() const {
-        this->INHERITED::validate();
-        SkASSERT(fWeakCnt > 0);
-    }
-#endif
-
-    /** Creates a strong reference from a weak reference, if possible. The
-        caller must already be an owner. If try_ref() returns true the owner
-        is in posession of an additional strong reference. Both the original
-        reference and new reference must be properly unreferenced. If try_ref()
-        returns false, no strong reference could be created and the owner's
-        reference is in the same state as before the call.
-    */
-    bool SK_WARN_UNUSED_RESULT try_ref() const {
-        if (sk_atomic_conditional_inc(&fRefCnt) != 0) {
-            // Acquire barrier (L/SL), if not provided above.
-            // Prevents subsequent code from happening before the increment.
-            sk_membar_acquire__after_atomic_conditional_inc();
-            return true;
-        }
-        return false;
-    }
-
-    /** Increment the weak reference count. Must be balanced by a call to
-        weak_unref().
-    */
-    void weak_ref() const {
-        SkASSERT(fRefCnt > 0);
-        SkASSERT(fWeakCnt > 0);
-        sk_atomic_inc(&fWeakCnt);  // No barrier required.
-    }
-
-    /** Decrement the weak reference count. If the weak reference count is 1
-        before the decrement, then call delete on the object. Note that if this
-        is the case, then the object needs to have been allocated via new, and
-        not on the stack.
-    */
-    void weak_unref() const {
-        SkASSERT(fWeakCnt > 0);
-        // Release barrier (SL/S), if not provided below.
-        if (sk_atomic_dec(&fWeakCnt) == 1) {
-            // Acquire barrier (L/SL), if not provided above.
-            // Prevents code in destructor from happening before the decrement.
-            sk_membar_acquire__after_atomic_dec();
-#ifdef SK_DEBUG
-            // so our destructor won't complain
-            fWeakCnt = 1;
-#endif
-            this->INHERITED::internal_dispose();
-        }
-    }
-
-    /** Returns true if there are no strong references to the object. When this
-        is the case all future calls to try_ref() will return false.
-    */
-    bool weak_expired() const {
-        return fRefCnt == 0;
-    }
-
-protected:
-    /** Called when the strong reference count goes to zero. This allows the
-        object to free any resources it may be holding. Weak references may
-        still exist and their level of allowed access to the object is defined
-        by the object's class.
-    */
-    virtual void weak_dispose() const {
-    }
-
-private:
-    /** Called when the strong reference count goes to zero. Calls weak_dispose
-        on the object and releases the implicit weak reference held
-        collectively by the strong references.
-    */
-    void internal_dispose() const override {
-        weak_dispose();
-        weak_unref();
-    }
-
-    /* Invariant: fWeakCnt = #weak + (fRefCnt > 0 ? 1 : 0) */
-    mutable int32_t fWeakCnt;
-
-    typedef SkRefCnt INHERITED;
-};
-
-#endif