Revert "Move the rest of src headers used by include to include/private."

This reverts commit d12e6ffa5cc1c1af47bf73c7c127d8d7f7443058.

Our Chrome roll canaries are failing with the dreaded
Ninja-says-there's-more-work-to-do message.  I will break this up
smaller (if possible) and try again tomorrow.

BUG=skia:4126

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

5 files changed, 628 insertions, 0 deletions

diff --git a/src/core/SkFunction.h b/src/core/SkFunction.h
new file mode 100644
index 0000000000..8e41cba929
--- /dev/null
+++ b/src/core/SkFunction.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFunction_DEFINED
+#define SkFunction_DEFINED
+
+// TODO: document, more pervasive move support in constructors, small-Fn optimization
+
+#include "SkTemplates.h"
+#include "SkTypes.h"
+
+template <typename> class SkFunction;
+
+template <typename R, typename... Args>
+class SkFunction<R(Args...)> {
+public:
+    SkFunction() {}
+
+    template <typename Fn>
+    SkFunction(const Fn& fn) : fFunction(SkNEW_ARGS(LambdaImpl<Fn>, (fn))) {}
+
+    SkFunction(R (*fn)(Args...)) : fFunction(SkNEW_ARGS(FnPtrImpl, (fn))) {}
+
+    SkFunction(const SkFunction& other) { *this = other; }
+    SkFunction& operator=(const SkFunction& other) {
+        if (this != &other) {
+            fFunction.reset(other.fFunction ? other.fFunction->clone() : nullptr);
+        }
+        return *this;
+    }
+
+    R operator()(Args... args) const {
+        SkASSERT(fFunction.get());
+        return fFunction->call(Forward(args)...);
+    }
+
+private:
+    // ~= std::forward.  This moves its argument if possible, falling back to a copy if not.
+    template <typename T> static T&& Forward(T& v) { return (T&&)v; }
+
+    struct Interface {
+        virtual ~Interface() {}
+        virtual R call(Args...) const = 0;
+        virtual Interface* clone() const = 0;
+    };
+
+    template <typename Fn>
+    class LambdaImpl final : public Interface {
+    public:
+        LambdaImpl(const Fn& fn) : fFn(fn) {}
+
+        R call(Args... args) const override { return fFn(Forward(args)...); }
+        Interface* clone() const override { return SkNEW_ARGS(LambdaImpl<Fn>, (fFn)); }
+    private:
+        Fn fFn;
+    };
+
+    class FnPtrImpl final : public Interface {
+    public:
+        FnPtrImpl(R (*fn)(Args...)) : fFn(fn) {}
+
+        R call(Args... args) const override { return fFn(Forward(args)...); }
+        Interface* clone() const override { return SkNEW_ARGS(FnPtrImpl, (fFn)); }
+    private:
+        R (*fFn)(Args...);
+    };
+
+    SkAutoTDelete<Interface> fFunction;
+};
+
+#endif//SkFunction_DEFINED
diff --git a/src/core/SkMiniRecorder.h b/src/core/SkMiniRecorder.h
new file mode 100644
index 0000000000..5b68fc22f8
--- /dev/null
+++ b/src/core/SkMiniRecorder.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkMiniRecorder_DEFINED
+#define SkMiniRecorder_DEFINED
+
+#include "SkRecords.h"
+#include "SkScalar.h"
+#include "SkTypes.h"
+class SkCanvas;
+
+// Records small pictures, but only a limited subset of the canvas API, and may fail.
+class SkMiniRecorder : SkNoncopyable {
+public:
+    SkMiniRecorder();
+    ~SkMiniRecorder();
+
+    // Try to record an op.  Returns false on failure.
+    bool drawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst,
+                        const SkPaint*, SkCanvas::SrcRectConstraint);
+    bool drawPath(const SkPath&, const SkPaint&);
+    bool drawRect(const SkRect&, const SkPaint&);
+    bool drawTextBlob(const SkTextBlob*, SkScalar x, SkScalar y, const SkPaint&);
+
+    // Detach anything we've recorded as a picture, resetting this SkMiniRecorder.
+    SkPicture* detachAsPicture(const SkRect& cull);
+
+    // Flush anything we've recorded to the canvas, resetting this SkMiniRecorder.
+    // This is logically the same as but rather more efficient than:
+    //    SkAutoTUnref<SkPicture> pic(this->detachAsPicture(SkRect::MakeEmpty()));
+    //    pic->playback(canvas);
+    void flushAndReset(SkCanvas*);
+
+private:
+    enum class State {
+        kEmpty,
+        kDrawBitmapRectFixedSize,
+        kDrawPath,
+        kDrawRect,
+        kDrawTextBlob,
+    };
+
+    State fState;
+
+    template <size_t A, size_t B>
+    struct Max { static const size_t val = A > B ? A : B; };
+
+    static const size_t kInlineStorage =
+        Max<sizeof(SkRecords::DrawBitmapRectFixedSize),
+        Max<sizeof(SkRecords::DrawPath),
+        Max<sizeof(SkRecords::DrawRect),
+            sizeof(SkRecords::DrawTextBlob)>::val>::val>::val;
+    SkAlignedSStorage<kInlineStorage> fBuffer;
+};
+
+#endif//SkMiniRecorder_DEFINED
diff --git a/src/core/SkPathPriv.h b/src/core/SkPathPriv.h
new file mode 100644
index 0000000000..934c730660
--- /dev/null
+++ b/src/core/SkPathPriv.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathPriv_DEFINED
+#define SkPathPriv_DEFINED
+
+#include "SkPath.h"
+
+class SkPathPriv {
+public:
+    enum FirstDirection {
+        kCW_FirstDirection,         // == SkPath::kCW_Direction
+        kCCW_FirstDirection,        // == SkPath::kCCW_Direction
+        kUnknown_FirstDirection,
+    };
+
+    static FirstDirection AsFirstDirection(SkPath::Direction dir) {
+        // since we agree numerically for the values in Direction, we can just cast.
+        return (FirstDirection)dir;
+    }
+
+    /**
+     *  Return the opposite of the specified direction. kUnknown is its own
+     *  opposite.
+     */
+    static FirstDirection OppositeFirstDirection(FirstDirection dir) {
+        static const FirstDirection gOppositeDir[] = {
+            kCCW_FirstDirection, kCW_FirstDirection, kUnknown_FirstDirection, 
+        };
+        return gOppositeDir[dir];
+    }
+
+    /**
+     *  Tries to quickly compute the direction of the first non-degenerate
+     *  contour. If it can be computed, return true and set dir to that
+     *  direction. If it cannot be (quickly) determined, return false and ignore
+     *  the dir parameter. If the direction was determined, it is cached to make
+     *  subsequent calls return quickly.
+     */
+    static bool CheapComputeFirstDirection(const SkPath&, FirstDirection* dir);
+
+    /**
+     *  Returns true if the path's direction can be computed via
+     *  cheapComputDirection() and if that computed direction matches the
+     *  specified direction. If dir is kUnknown, returns true if the direction
+     *  cannot be computed.
+     */
+    static bool CheapIsFirstDirection(const SkPath& path, FirstDirection dir) {
+        FirstDirection computedDir = kUnknown_FirstDirection;
+        (void)CheapComputeFirstDirection(path, &computedDir);
+        return computedDir == dir;
+    }
+
+    static bool LastVerbIsClose(const SkPath& path) {
+        int count = path.countVerbs();
+        return count >= 1 && path.fPathRef->verbs()[~(count - 1)] == SkPath::Verb::kClose_Verb;
+    }
+};
+
+#endif
diff --git a/src/core/SkRecords.h b/src/core/SkRecords.h
new file mode 100644
index 0000000000..9ab04c91e4
--- /dev/null
+++ b/src/core/SkRecords.h
@@ -0,0 +1,400 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkRecords_DEFINED
+#define SkRecords_DEFINED
+
+#include "SkCanvas.h"
+#include "SkDrawable.h"
+#include "SkMatrix.h"
+#include "SkPathPriv.h"
+#include "SkPicture.h"
+#include "SkRSXform.h"
+#include "SkTextBlob.h"
+
+namespace SkRecords {
+
+// A list of all the types of canvas calls we can record.
+// Each of these is reified into a struct below.
+//
+// (We're using the macro-of-macro trick here to do several different things with the same list.)
+//
+// We leave this SK_RECORD_TYPES macro defined for use by code that wants to operate on SkRecords
+// types polymorphically.  (See SkRecord::Record::{visit,mutate} for an example.)
+//
+// Order doesn't technically matter here, but the compiler can generally generate better code if
+// you keep them semantically grouped, especially the Draws.  It's also nice to leave NoOp at 0.
+#define SK_RECORD_TYPES(M)                                          \
+    M(NoOp)                                                         \
+    M(Restore)                                                      \
+    M(Save)                                                         \
+    M(SaveLayer)                                                    \
+    M(SetMatrix)                                                    \
+    M(ClipPath)                                                     \
+    M(ClipRRect)                                                    \
+    M(ClipRect)                                                     \
+    M(ClipRegion)                                                   \
+    M(DrawBitmap)                                                   \
+    M(DrawBitmapNine)                                               \
+    M(DrawBitmapRect)                                               \
+    M(DrawBitmapRectFast)                                           \
+    M(DrawBitmapRectFixedSize)                                      \
+    M(DrawDrawable)                                                 \
+    M(DrawImage)                                                    \
+    M(DrawImageRect)                                                \
+    M(DrawImageNine)                                                \
+    M(DrawDRRect)                                                   \
+    M(DrawOval)                                                     \
+    M(DrawPaint)                                                    \
+    M(DrawPath)                                                     \
+    M(DrawPatch)                                                    \
+    M(DrawPicture)                                                  \
+    M(DrawPoints)                                                   \
+    M(DrawPosText)                                                  \
+    M(DrawPosTextH)                                                 \
+    M(DrawText)                                                     \
+    M(DrawTextOnPath)                                               \
+    M(DrawRRect)                                                    \
+    M(DrawRect)                                                     \
+    M(DrawSprite)                                                   \
+    M(DrawTextBlob)                                                 \
+    M(DrawAtlas)                                                    \
+    M(DrawVertices)
+
+// Defines SkRecords::Type, an enum of all record types.
+#define ENUM(T) T##_Type,
+enum Type { SK_RECORD_TYPES(ENUM) };
+#undef ENUM
+
+// Macros to make it easier to define a record for a draw call with 0 args, 1 args, 2 args, etc.
+// These should be clearer when you look at their use below.
+#define RECORD0(T)                      \
+struct T {                              \
+    static const Type kType = T##_Type; \
+};
+
+// Instead of requring the exact type A here, we take any type Z which implicitly casts to A.
+// This lets our wrappers like ImmutableBitmap work seamlessly.
+
+#define RECORD1(T, A, a)                \
+struct T {                              \
+    static const Type kType = T##_Type; \
+    T() {}                              \
+    template <typename Z>               \
+    T(const Z& a) : a(a) {}             \
+    A a;                                \
+};
+
+#define RECORD2(T, A, a, B, b)                \
+struct T {                                    \
+    static const Type kType = T##_Type;       \
+    T() {}                                    \
+    template <typename Z, typename Y>         \
+    T(const Z& a, const Y& b) : a(a), b(b) {} \
+    A a; B b;                                 \
+};
+
+#define RECORD3(T, A, a, B, b, C, c)                            \
+struct T {                                                      \
+    static const Type kType = T##_Type;                         \
+    T() {}                                                      \
+    template <typename Z, typename Y, typename X>               \
+    T(const Z& a, const Y& b, const X& c) : a(a), b(b), c(c) {} \
+    A a; B b; C c;                                              \
+};
+
+#define RECORD4(T, A, a, B, b, C, c, D, d)                                        \
+struct T {                                                                        \
+    static const Type kType = T##_Type;                                           \
+    T() {}                                                                        \
+    template <typename Z, typename Y, typename X, typename W>                     \
+    T(const Z& a, const Y& b, const X& c, const W& d) : a(a), b(b), c(c), d(d) {} \
+    A a; B b; C c; D d;                                                           \
+};
+
+#define RECORD5(T, A, a, B, b, C, c, D, d, E, e)                          \
+struct T {                                                                \
+    static const Type kType = T##_Type;                                   \
+    T() {}                                                                \
+    template <typename Z, typename Y, typename X, typename W, typename V> \
+    T(const Z& a, const Y& b, const X& c, const W& d, const V& e)         \
+        : a(a), b(b), c(c), d(d), e(e) {}                                 \
+    A a; B b; C c; D d; E e;                                              \
+};
+
+#define RECORD8(T, A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h) \
+struct T {                                                         \
+    static const Type kType = T##_Type;                            \
+    T() {}                                                         \
+    template <typename Z, typename Y, typename X, typename W,      \
+              typename V, typename U, typename S, typename R>      \
+    T(const Z& a, const Y& b, const X& c, const W& d,              \
+      const V& e, const U& f, const S& g, const R& h)              \
+        : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {}        \
+    A a; B b; C c; D d; E e; F f; G g; H h;                        \
+};
+
+#define ACT_AS_PTR(ptr)                 \
+    operator T*() const { return ptr; } \
+    T* operator->() const { return ptr; }
+
+template <typename T>
+class RefBox : SkNoncopyable {
+public:
+    RefBox() {}
+    RefBox(T* obj) : fObj(SkSafeRef(obj)) {}
+    ~RefBox() { SkSafeUnref(fObj); }
+
+    ACT_AS_PTR(fObj);
+
+private:
+    T* fObj;
+};
+
+// An Optional doesn't own the pointer's memory, but may need to destroy non-POD data.
+template <typename T>
+class Optional : SkNoncopyable {
+public:
+    Optional() : fPtr(nullptr) {}
+    Optional(T* ptr) : fPtr(ptr) {}
+    ~Optional() { if (fPtr) fPtr->~T(); }
+
+    ACT_AS_PTR(fPtr);
+private:
+    T* fPtr;
+};
+
+// Like Optional, but ptr must not be NULL.
+template <typename T>
+class Adopted : SkNoncopyable {
+public:
+    Adopted(T* ptr) : fPtr(ptr) { SkASSERT(fPtr); }
+    Adopted(Adopted* source) {
+        // Transfer ownership from source to this.
+        fPtr = source->fPtr;
+        source->fPtr = NULL;
+    }
+    ~Adopted() { if (fPtr) fPtr->~T(); }
+
+    ACT_AS_PTR(fPtr);
+private:
+    T* fPtr;
+};
+
+// PODArray doesn't own the pointer's memory, and we assume the data is POD.
+template <typename T>
+class PODArray {
+public:
+    PODArray() {}
+    PODArray(T* ptr) : fPtr(ptr) {}
+    // Default copy and assign.
+
+    ACT_AS_PTR(fPtr);
+private:
+    T* fPtr;
+};
+
+#undef ACT_AS_PTR
+
+// Like SkBitmap, but deep copies pixels if they're not immutable.
+// Using this, we guarantee the immutability of all bitmaps we record.
+class ImmutableBitmap : SkNoncopyable {
+public:
+    ImmutableBitmap() {}
+    explicit ImmutableBitmap(const SkBitmap& bitmap) {
+        if (bitmap.isImmutable()) {
+            fBitmap = bitmap;
+        } else {
+            bitmap.copyTo(&fBitmap);
+        }
+        fBitmap.setImmutable();
+    }
+
+    int width()  const { return fBitmap.width();  }
+    int height() const { return fBitmap.height(); }
+
+    // While the pixels are immutable, SkBitmap itself is not thread-safe, so return a copy.
+    SkBitmap shallowCopy() const { return fBitmap; }
+private:
+    SkBitmap fBitmap;
+};
+
+// SkPath::getBounds() isn't thread safe unless we precache the bounds in a singlethreaded context.
+// SkPath::cheapComputeDirection() is similar.
+// Recording is a convenient time to cache these, or we can delay it to between record and playback.
+struct PreCachedPath : public SkPath {
+    PreCachedPath() {}
+    explicit PreCachedPath(const SkPath& path) : SkPath(path) {
+        this->updateBoundsCache();
+#if 0  // Disabled to see if we ever really race on this.  It costs time, chromium:496982.
+        SkPathPriv::FirstDirection junk;
+        (void)SkPathPriv::CheapComputeFirstDirection(*this, &junk);
+#endif
+    }
+};
+
+// Like SkPath::getBounds(), SkMatrix::getType() isn't thread safe unless we precache it.
+// This may not cover all SkMatrices used by the picture (e.g. some could be hiding in a shader).
+struct TypedMatrix : public SkMatrix {
+    TypedMatrix() {}
+    explicit TypedMatrix(const SkMatrix& matrix) : SkMatrix(matrix) {
+        (void)this->getType();
+    }
+};
+
+RECORD0(NoOp);
+
+RECORD2(Restore, SkIRect, devBounds, TypedMatrix, matrix);
+RECORD0(Save);
+RECORD3(SaveLayer, Optional<SkRect>, bounds, Optional<SkPaint>, paint, SkCanvas::SaveFlags, flags);
+
+RECORD1(SetMatrix, TypedMatrix, matrix);
+
+struct RegionOpAndAA {
+    RegionOpAndAA() {}
+    RegionOpAndAA(SkRegion::Op op, bool aa) : op(op), aa(aa) {}
+    SkRegion::Op op : 31;  // This really only needs to be 3, but there's no win today to do so.
+    unsigned     aa :  1;  // MSVC won't pack an enum with an bool, so we call this an unsigned.
+};
+SK_COMPILE_ASSERT(sizeof(RegionOpAndAA) == 4, RegionOpAndAASize);
+
+RECORD3(ClipPath,   SkIRect, devBounds, PreCachedPath,  path, RegionOpAndAA, opAA);
+RECORD3(ClipRRect,  SkIRect, devBounds, SkRRect,       rrect, RegionOpAndAA, opAA);
+RECORD3(ClipRect,   SkIRect, devBounds, SkRect,         rect, RegionOpAndAA, opAA);
+RECORD3(ClipRegion, SkIRect, devBounds, SkRegion,     region, SkRegion::Op,    op);
+
+// While not strictly required, if you have an SkPaint, it's fastest to put it first.
+RECORD4(DrawBitmap, Optional<SkPaint>, paint,
+                    ImmutableBitmap, bitmap,
+                    SkScalar, left,
+                    SkScalar, top);
+RECORD4(DrawBitmapNine, Optional<SkPaint>, paint,
+                        ImmutableBitmap, bitmap,
+                        SkIRect, center,
+                        SkRect, dst);
+RECORD4(DrawBitmapRect, Optional<SkPaint>, paint,
+                        ImmutableBitmap, bitmap,
+                        Optional<SkRect>, src,
+                        SkRect, dst);
+RECORD4(DrawBitmapRectFast, Optional<SkPaint>, paint,
+                            ImmutableBitmap, bitmap,
+                            Optional<SkRect>, src,
+                            SkRect, dst);
+RECORD5(DrawBitmapRectFixedSize, SkPaint, paint,
+                                 ImmutableBitmap, bitmap,
+                                 SkRect, src,
+                                 SkRect, dst,
+                                 SkCanvas::SrcRectConstraint, constraint);
+RECORD3(DrawDRRect, SkPaint, paint, SkRRect, outer, SkRRect, inner);
+RECORD3(DrawDrawable, Optional<SkMatrix>, matrix, SkRect, worstCaseBounds, int32_t, index);
+RECORD4(DrawImage, Optional<SkPaint>, paint,
+                   RefBox<const SkImage>, image,
+                   SkScalar, left,
+                   SkScalar, top);
+RECORD5(DrawImageRect, Optional<SkPaint>, paint,
+                       RefBox<const SkImage>, image,
+                       Optional<SkRect>, src,
+                       SkRect, dst,
+                       SkCanvas::SrcRectConstraint, constraint);
+RECORD4(DrawImageNine, Optional<SkPaint>, paint,
+                       RefBox<const SkImage>, image,
+                       SkIRect, center,
+                       SkRect, dst);
+RECORD2(DrawOval, SkPaint, paint, SkRect, oval);
+RECORD1(DrawPaint, SkPaint, paint);
+RECORD2(DrawPath, SkPaint, paint, PreCachedPath, path);
+RECORD3(DrawPicture, Optional<SkPaint>, paint,
+                     RefBox<const SkPicture>, picture,
+                     TypedMatrix, matrix);
+RECORD4(DrawPoints, SkPaint, paint, SkCanvas::PointMode, mode, unsigned, count, SkPoint*, pts);
+RECORD4(DrawPosText, SkPaint, paint,
+                     PODArray<char>, text,
+                     size_t, byteLength,
+                     PODArray<SkPoint>, pos);
+RECORD5(DrawPosTextH, SkPaint, paint,
+                      PODArray<char>, text,
+                      unsigned, byteLength,
+                      SkScalar, y,
+                      PODArray<SkScalar>, xpos);
+RECORD2(DrawRRect, SkPaint, paint, SkRRect, rrect);
+RECORD2(DrawRect, SkPaint, paint, SkRect, rect);
+RECORD4(DrawSprite, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, int, left, int, top);
+RECORD5(DrawText, SkPaint, paint,
+                  PODArray<char>, text,
+                  size_t, byteLength,
+                  SkScalar, x,
+                  SkScalar, y);
+RECORD4(DrawTextBlob, SkPaint, paint,
+                      RefBox<const SkTextBlob>, blob,
+                      SkScalar, x,
+                      SkScalar, y);
+RECORD5(DrawTextOnPath, SkPaint, paint,
+                        PODArray<char>, text,
+                        size_t, byteLength,
+                        PreCachedPath, path,
+                        TypedMatrix, matrix);
+
+RECORD5(DrawPatch, SkPaint, paint,
+                   PODArray<SkPoint>, cubics,
+                   PODArray<SkColor>, colors,
+                   PODArray<SkPoint>, texCoords,
+                   RefBox<SkXfermode>, xmode);
+
+RECORD8(DrawAtlas,  Optional<SkPaint>, paint,
+                    RefBox<const SkImage>, atlas,
+                    PODArray<SkRSXform>, xforms,
+                    PODArray<SkRect>, texs,
+                    PODArray<SkColor>, colors,
+                    int, count,
+                    SkXfermode::Mode, mode,
+                    Optional<SkRect>, cull);
+
+// This guy is so ugly we just write it manually.
+struct DrawVertices {
+    static const Type kType = DrawVertices_Type;
+
+    DrawVertices(const SkPaint& paint,
+                 SkCanvas::VertexMode vmode,
+                 int vertexCount,
+                 SkPoint* vertices,
+                 SkPoint* texs,
+                 SkColor* colors,
+                 SkXfermode* xmode,
+                 uint16_t* indices,
+                 int indexCount)
+        : paint(paint)
+        , vmode(vmode)
+        , vertexCount(vertexCount)
+        , vertices(vertices)
+        , texs(texs)
+        , colors(colors)
+        , xmode(SkSafeRef(xmode))
+        , indices(indices)
+        , indexCount(indexCount) {}
+
+    SkPaint paint;
+    SkCanvas::VertexMode vmode;
+    int vertexCount;
+    PODArray<SkPoint> vertices;
+    PODArray<SkPoint> texs;
+    PODArray<SkColor> colors;
+    SkAutoTUnref<SkXfermode> xmode;
+    PODArray<uint16_t> indices;
+    int indexCount;
+};
+
+#undef RECORD0
+#undef RECORD1
+#undef RECORD2
+#undef RECORD3
+#undef RECORD4
+#undef RECORD5
+#undef RECORD8
+
+}  // namespace SkRecords
+
+#endif//SkRecords_DEFINED
diff --git a/src/gpu/SkGpuFenceSync.h b/src/gpu/SkGpuFenceSync.h
new file mode 100644
index 0000000000..b78398fed8
--- /dev/null
+++ b/src/gpu/SkGpuFenceSync.h
@@ -0,0 +1,29 @@
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkGpuFenceSync_DEFINED
+#define SkGpuFenceSync_DEFINED
+
+#include "SkTypes.h"
+
+typedef void* SkPlatformGpuFence;
+
+/*
+ * This class provides an interface to interact with fence syncs. A fence sync is an object that the
+ * client can insert into the GPU command stream, and then at any future time, wait until all
+ * commands that were issued before the fence have completed.
+ */
+class SkGpuFenceSync {
+public:
+    virtual SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const = 0;
+    virtual bool flushAndWaitFence(SkPlatformGpuFence) const = 0;
+    virtual void deleteFence(SkPlatformGpuFence) const = 0;
+
+    virtual ~SkGpuFenceSync() {}
+};
+
+#endif