1/*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef GrGpu_DEFINED
9#define GrGpu_DEFINED
10
11#include "GrPipelineBuilder.h"
12#include "GrProgramDesc.h"
13#include "GrStencil.h"
14#include "GrSwizzle.h"
15#include "GrTextureParamsAdjuster.h"
16#include "GrXferProcessor.h"
17#include "SkPath.h"
18
19class GrBatchTracker;
20class GrContext;
21class GrGLContext;
22class GrIndexBuffer;
23class GrNonInstancedVertices;
24class GrPath;
25class GrPathRange;
26class GrPathRenderer;
27class GrPathRendererChain;
28class GrPathRendering;
29class GrPipeline;
30class GrPrimitiveProcessor;
31class GrRenderTarget;
32class GrStencilAttachment;
33class GrSurface;
34class GrTexture;
35class GrTransferBuffer;
36class GrVertexBuffer;
37class GrVertices;
38
39class GrGpu : public SkRefCnt {
40public:
41    /**
42     * Create an instance of GrGpu that matches the specified backend. If the requested backend is
43     * not supported (at compile-time or run-time) this returns nullptr. The context will not be
44     * fully constructed and should not be used by GrGpu until after this function returns.
45     */
46    static GrGpu* Create(GrBackend, GrBackendContext, const GrContextOptions&, GrContext* context);
47
48    ////////////////////////////////////////////////////////////////////////////
49
50    GrGpu(GrContext* context);
51    ~GrGpu() override;
52
53    GrContext* getContext() { return fContext; }
54    const GrContext* getContext() const { return fContext; }
55
56    /**
57     * Gets the capabilities of the draw target.
58     */
59    const GrCaps* caps() const { return fCaps.get(); }
60
61    GrPathRendering* pathRendering() { return fPathRendering.get();  }
62
63    // Called by GrContext when the underlying backend context has been destroyed.
64    // GrGpu should use this to ensure that no backend API calls will be made from
65    // here onward, including in its destructor. Subclasses should call
66    // INHERITED::contextAbandoned() if they override this.
67    virtual void contextAbandoned();
68
69    /**
70     * The GrGpu object normally assumes that no outsider is setting state
71     * within the underlying 3D API's context/device/whatever. This call informs
72     * the GrGpu that the state was modified and it shouldn't make assumptions
73     * about the state.
74     */
75    void markContextDirty(uint32_t state = kAll_GrBackendState) { fResetBits |= state; }
76
77    /**
78     * Creates a texture object. If kRenderTarget_GrSurfaceFlag the texture can
79     * be used as a render target by calling GrTexture::asRenderTarget(). Not all
80     * pixel configs can be used as render targets. Support for configs as textures
81     * or render targets can be checked using GrCaps.
82     *
83     * @param desc        describes the texture to be created.
84     * @param budgeted    does this texture count against the resource cache budget?
85     * @param srcData     texel data to load texture. Begins with full-size
86     *                    palette data for paletted textures. For compressed
87     *                    formats it contains the compressed pixel data. Otherwise,
88     *                    it contains width*height texels. If nullptr texture data
89     *                    is uninitialized.
90     * @param rowBytes    the number of bytes between consecutive rows. Zero
91     *                    means rows are tightly packed. This field is ignored
92     *                    for compressed formats.
93     *
94     * @return    The texture object if successful, otherwise nullptr.
95     */
96    GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
97                             const void* srcData, size_t rowBytes);
98
99    /**
100     * Implements GrTextureProvider::wrapBackendTexture
101     */
102    GrTexture* wrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership);
103
104    /**
105     * Implements GrTextureProvider::wrapBackendRenderTarget
106     */
107    GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&, GrWrapOwnership);
108
109    /**
110     * Implements GrTextureProvider::wrapBackendTextureAsRenderTarget
111     */
112    GrRenderTarget* wrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&, GrWrapOwnership);
113
114    /**
115     * Creates a vertex buffer.
116     *
117     * @param size    size in bytes of the vertex buffer
118     * @param dynamic hints whether the data will be frequently changed
119     *                by either GrVertexBuffer::map() or
120     *                GrVertexBuffer::updateData().
121     *
122     * @return    The vertex buffer if successful, otherwise nullptr.
123     */
124    GrVertexBuffer* createVertexBuffer(size_t size, bool dynamic);
125
126    /**
127     * Creates an index buffer.
128     *
129     * @param size    size in bytes of the index buffer
130     * @param dynamic hints whether the data will be frequently changed
131     *                by either GrIndexBuffer::map() or
132     *                GrIndexBuffer::updateData().
133     *
134     * @return The index buffer if successful, otherwise nullptr.
135     */
136    GrIndexBuffer* createIndexBuffer(size_t size, bool dynamic);
137
138    /**
139     * Creates a transfer buffer.
140     *
141     * @param size      size in bytes of the index buffer
142     * @param toGpu     true if used to transfer from the cpu to the gpu
143     *                  otherwise to be used to transfer from the gpu to the cpu
144     *
145     * @return The transfer buffer if successful, otherwise nullptr.
146     */
147    GrTransferBuffer* createTransferBuffer(size_t size, TransferType type);
148
149    /**
150     * Resolves MSAA.
151     */
152    void resolveRenderTarget(GrRenderTarget* target);
153
154    /** Info struct returned by getReadPixelsInfo about performing intermediate draws before
155        reading pixels for performance or correctness. */
156    struct ReadPixelTempDrawInfo {
157        /** If the GrGpu is requesting that the caller do a draw to an intermediate surface then
158            this is descriptor for the temp surface. The draw should always be a rect with
159            dst 0,0,w,h. */
160        GrSurfaceDesc   fTempSurfaceDesc;
161        /** Indicates whether there is a performance advantage to using an exact match texture
162            (in terms of width and height) for the intermediate texture instead of approximate. */
163        bool            fUseExactScratch;
164        /** Swizzle to apply during the draw. This is used to compensate for either feature or
165            performance limitations in the underlying 3D API. */
166        GrSwizzle       fSwizzle;
167        /** The config that should be used to read from the temp surface after the draw. This may be
168            different than the original read config in order to compensate for swizzling. The
169            read data will effectively be in the original read config. */
170        GrPixelConfig   fReadConfig;
171    };
172
173    /** Describes why an intermediate draw must/should be performed before readPixels. */
174    enum DrawPreference {
175        /** On input means that the caller would proceed without draw if the GrGpu doesn't request
176            one.
177            On output means that the GrGpu is not requesting a draw. */
178        kNoDraw_DrawPreference,
179        /** Means that the client would prefer a draw for performance of the readback but
180            can satisfy a straight readPixels call on the inputs without an intermediate draw.
181            getReadPixelsInfo will never set the draw preference to this value but may leave
182            it set. */
183        kCallerPrefersDraw_DrawPreference,
184        /** On output means that GrGpu would prefer a draw for performance of the readback but
185            can satisfy a straight readPixels call on the inputs without an intermediate draw. The
186            caller of getReadPixelsInfo should never specify this on intput. */
187        kGpuPrefersDraw_DrawPreference,
188        /** On input means that the caller requires a draw to do a transformation and there is no
189            CPU fallback.
190            On output means that GrGpu can only satisfy the readPixels request if the intermediate
191            draw is performed.
192          */
193        kRequireDraw_DrawPreference
194    };
195
196    /**
197     * Used to negotiate whether and how an intermediate draw should or must be performed before
198     * a readPixels call. If this returns false then GrGpu could not deduce an intermediate draw
199     * that would allow a successful readPixels call. The passed width, height, and rowBytes,
200     * must be non-zero and already reflect clipping to the src bounds.
201     */
202    bool getReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
203                           GrPixelConfig readConfig, DrawPreference*, ReadPixelTempDrawInfo*);
204
205    /** Info struct returned by getWritePixelsInfo about performing an intermediate draw in order
206        to write pixels to a GrSurface for either performance or correctness reasons. */
207    struct WritePixelTempDrawInfo {
208        /** If the GrGpu is requesting that the caller upload to an intermediate surface and draw
209            that to the dst then this is the descriptor for the intermediate surface. The caller
210            should upload the pixels such that the upper left pixel of the upload rect is at 0,0 in
211            the intermediate surface.*/
212        GrSurfaceDesc   fTempSurfaceDesc;
213        /** Swizzle to apply during the draw. This is used to compensate for either feature or
214            performance limitations in the underlying 3D API. */
215        GrSwizzle       fSwizzle;
216        /** The config that should be specified when uploading the *original* data to the temp
217            surface before the draw. This may be different than the original src data config in
218            order to compensate for swizzling that will occur when drawing. */
219        GrPixelConfig   fWriteConfig;
220    };
221
222    /**
223     * Used to negotiate whether and how an intermediate surface should be used to write pixels to
224     * a GrSurface. If this returns false then GrGpu could not deduce an intermediate draw
225     * that would allow a successful transfer of the src pixels to the dst. The passed width,
226     * height, and rowBytes, must be non-zero and already reflect clipping to the dst bounds.
227     */
228    bool getWritePixelsInfo(GrSurface* dstSurface, int width, int height,
229                            GrPixelConfig srcConfig, DrawPreference*, WritePixelTempDrawInfo*);
230
231    /**
232     * Reads a rectangle of pixels from a render target.
233     *
234     * @param surface       The surface to read from
235     * @param left          left edge of the rectangle to read (inclusive)
236     * @param top           top edge of the rectangle to read (inclusive)
237     * @param width         width of rectangle to read in pixels.
238     * @param height        height of rectangle to read in pixels.
239     * @param config        the pixel config of the destination buffer
240     * @param buffer        memory to read the rectangle into.
241     * @param rowBytes      the number of bytes between consecutive rows. Zero
242     *                      means rows are tightly packed.
243     * @param invertY       buffer should be populated bottom-to-top as opposed
244     *                      to top-to-bottom (skia's usual order)
245     *
246     * @return true if the read succeeded, false if not. The read can fail
247     *              because of a unsupported pixel config or because no render
248     *              target is currently set.
249     */
250    bool readPixels(GrSurface* surface,
251                    int left, int top, int width, int height,
252                    GrPixelConfig config, void* buffer, size_t rowBytes);
253
254    /**
255     * Updates the pixels in a rectangle of a surface.
256     *
257     * @param surface       The surface to write to.
258     * @param left          left edge of the rectangle to write (inclusive)
259     * @param top           top edge of the rectangle to write (inclusive)
260     * @param width         width of rectangle to write in pixels.
261     * @param height        height of rectangle to write in pixels.
262     * @param config        the pixel config of the source buffer
263     * @param buffer        memory to read pixels from
264     * @param rowBytes      number of bytes between consecutive rows. Zero
265     *                      means rows are tightly packed.
266     */
267    bool writePixels(GrSurface* surface,
268                     int left, int top, int width, int height,
269                     GrPixelConfig config, const void* buffer,
270                     size_t rowBytes);
271
272    /**
273     * Updates the pixels in a rectangle of a surface using a GrTransferBuffer
274     *
275     * @param surface       The surface to write to.
276     * @param left          left edge of the rectangle to write (inclusive)
277     * @param top           top edge of the rectangle to write (inclusive)
278     * @param width         width of rectangle to write in pixels.
279     * @param height        height of rectangle to write in pixels.
280     * @param config        the pixel config of the source buffer
281     * @param buffer        GrTransferBuffer to read pixels from
282     * @param offset        offset from the start of the buffer
283     * @param rowBytes      number of bytes between consecutive rows. Zero
284     *                      means rows are tightly packed.
285     */
286    bool transferPixels(GrSurface* surface,
287                        int left, int top, int width, int height,
288                        GrPixelConfig config, GrTransferBuffer* buffer,
289                        size_t offset, size_t rowBytes);
290
291    /**
292     * Clear the passed in render target. Ignores the draw state and clip.
293     */
294    void clear(const SkIRect& rect, GrColor color, GrRenderTarget* renderTarget);
295
296
297    void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget);
298
299    /**
300     * Discards the contents render target. nullptr indicates that the current render target should
301     * be discarded.
302     **/
303    virtual void discard(GrRenderTarget* = nullptr) = 0;
304
305    /**
306     * This is can be called before allocating a texture to be a dst for copySurface. It will
307     * populate the origin, config, and flags fields of the desc such that copySurface can
308     * efficiently succeed. It should only succeed if it can allow copySurface to perform a copy
309     * that would be more effecient than drawing the src to a dst render target.
310     */
311    virtual bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const = 0;
312
313    // After the client interacts directly with the 3D context state the GrGpu
314    // must resync its internal state and assumptions about 3D context state.
315    // Each time this occurs the GrGpu bumps a timestamp.
316    // state of the 3D context
317    // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about
318    // a billion years.
319    typedef uint64_t ResetTimestamp;
320
321    // This timestamp is always older than the current timestamp
322    static const ResetTimestamp kExpiredTimestamp = 0;
323    // Returns a timestamp based on the number of times the context was reset.
324    // This timestamp can be used to lazily detect when cached 3D context state
325    // is dirty.
326    ResetTimestamp getResetTimestamp() const { return fResetTimestamp; }
327
328    virtual void buildProgramDesc(GrProgramDesc*,
329                                  const GrPrimitiveProcessor&,
330                                  const GrPipeline&) const = 0;
331
332    // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst
333    // take place at the GrDrawTarget level and this function implement faster copy paths. The rect
334    // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
335    // src/dst bounds and non-empty.
336    bool copySurface(GrSurface* dst,
337                     GrSurface* src,
338                     const SkIRect& srcRect,
339                     const SkIPoint& dstPoint);
340
341    struct DrawArgs {
342        DrawArgs(const GrPrimitiveProcessor* primProc,
343                 const GrPipeline* pipeline,
344                 const GrProgramDesc* desc)
345            : fPrimitiveProcessor(primProc)
346            , fPipeline(pipeline)
347            , fDesc(desc) {
348            SkASSERT(primProc && pipeline && desc);
349        }
350        const GrPrimitiveProcessor* fPrimitiveProcessor;
351        const GrPipeline* fPipeline;
352        const GrProgramDesc* fDesc;
353    };
354
355    void draw(const DrawArgs&, const GrVertices&);
356
357    // Called by drawtarget when flushing.
358    // Provides a hook for post-flush actions (e.g. PLS reset and Vulkan command buffer submits).
359    virtual void finishDrawTarget() {}
360
361    ///////////////////////////////////////////////////////////////////////////
362    // Debugging and Stats
363
364    class Stats {
365    public:
366#if GR_GPU_STATS
367        Stats() { this->reset(); }
368
369        void reset() {
370            fRenderTargetBinds = 0;
371            fShaderCompilations = 0;
372            fTextureCreates = 0;
373            fTextureUploads = 0;
374            fTransfersToTexture = 0;
375            fStencilAttachmentCreates = 0;
376            fNumDraws = 0;
377        }
378
379        int renderTargetBinds() const { return fRenderTargetBinds; }
380        void incRenderTargetBinds() { fRenderTargetBinds++; }
381        int shaderCompilations() const { return fShaderCompilations; }
382        void incShaderCompilations() { fShaderCompilations++; }
383        int textureCreates() const { return fTextureCreates; }
384        void incTextureCreates() { fTextureCreates++; }
385        int textureUploads() const { return fTextureUploads; }
386        void incTextureUploads() { fTextureUploads++; }
387        int transfersToTexture() const { return fTransfersToTexture; }
388        void incTransfersToTexture() { fTransfersToTexture++; }
389        void incStencilAttachmentCreates() { fStencilAttachmentCreates++; }
390        void incNumDraws() { fNumDraws++; }
391        void dump(SkString*);
392        void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values);
393
394    private:
395        int fRenderTargetBinds;
396        int fShaderCompilations;
397        int fTextureCreates;
398        int fTextureUploads;
399        int fTransfersToTexture;
400        int fStencilAttachmentCreates;
401        int fNumDraws;
402#else
403        void dump(SkString*) {}
404        void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {}
405        void incRenderTargetBinds() {}
406        void incShaderCompilations() {}
407        void incTextureCreates() {}
408        void incTextureUploads() {}
409        void incTransfersToTexture() {}
410        void incStencilAttachmentCreates() {}
411        void incNumDraws() {}
412#endif
413    };
414
415    Stats* stats() { return &fStats; }
416
417    /** Creates a texture directly in the backend API without wrapping it in a GrTexture. This is
418        only to be used for testing (particularly for testing the methods that import an externally
419        created texture into Skia. Must be matched with a call to deleteTestingOnlyTexture(). */
420    virtual GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
421                                                            GrPixelConfig config) = 0;
422    /** Check a handle represents an actual texture in the backend API that has not been freed. */
423    virtual bool isTestingOnlyBackendTexture(GrBackendObject) const = 0;
424    /** If ownership of the backend texture has been transferred pass true for abandonTexture. This
425        will do any necessary cleanup of the handle without freeing the texture in the backend
426        API. */
427    virtual void deleteTestingOnlyBackendTexture(GrBackendObject,
428                                                 bool abandonTexture = false) = 0;
429
430    // width and height may be larger than rt (if underlying API allows it).
431    // Returns nullptr if compatible sb could not be created, otherwise the caller owns the ref on
432    // the GrStencilAttachment.
433    virtual GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
434                                                                        int width,
435                                                                        int height) = 0;
436    // clears target's entire stencil buffer to 0
437    virtual void clearStencil(GrRenderTarget* target) = 0;
438
439    // draws an outline rectangle for debugging/visualization purposes.
440    virtual void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) = 0;
441
442    // Determines whether a texture will need to be rescaled in order to be used with the
443    // GrTextureParams. This variation is called when the caller will create a new texture using the
444    // texture provider from a non-texture src (cpu-backed image, ...).
445    bool makeCopyForTextureParams(int width, int height, const GrTextureParams&,
446                                 GrTextureProducer::CopyParams*) const;
447
448    // Like the above but this variation should be called when the caller is not creating the
449    // original texture but rather was handed the original texture. It adds additional checks
450    // relevant to original textures that were created external to Skia via
451    // GrTextureProvider::wrap methods.
452    bool makeCopyForTextureParams(GrTexture* texture, const GrTextureParams& params,
453                                  GrTextureProducer::CopyParams* copyParams) const {
454        if (this->makeCopyForTextureParams(texture->width(), texture->height(), params,
455                                           copyParams)) {
456            return true;
457        }
458        return this->onMakeCopyForTextureParams(texture, params, copyParams);
459    }
460
461    // This is only to be used in GL-specific tests.
462    virtual const GrGLContext* glContextForTesting() const { return nullptr; }
463
464    // This is only to be used by testing code
465    virtual void resetShaderCacheForTesting() const {}
466
467protected:
468    // Functions used to map clip-respecting stencil tests into normal
469    // stencil funcs supported by GPUs.
470    static GrStencilFunc ConvertStencilFunc(bool stencilInClip,
471                                            GrStencilFunc func);
472    static void ConvertStencilFuncAndMask(GrStencilFunc func,
473                                          bool clipInStencil,
474                                          unsigned int clipBit,
475                                          unsigned int userBits,
476                                          unsigned int* ref,
477                                          unsigned int* mask);
478
479    static void ElevateDrawPreference(GrGpu::DrawPreference* preference,
480                                      GrGpu::DrawPreference elevation) {
481        GR_STATIC_ASSERT(GrGpu::kCallerPrefersDraw_DrawPreference > GrGpu::kNoDraw_DrawPreference);
482        GR_STATIC_ASSERT(GrGpu::kGpuPrefersDraw_DrawPreference >
483                         GrGpu::kCallerPrefersDraw_DrawPreference);
484        GR_STATIC_ASSERT(GrGpu::kRequireDraw_DrawPreference >
485                         GrGpu::kGpuPrefersDraw_DrawPreference);
486        *preference = SkTMax(*preference, elevation);
487    }
488
489    void handleDirtyContext() {
490        if (fResetBits) {
491            this->resetContext();
492        }
493    }
494
495    Stats                                   fStats;
496    SkAutoTDelete<GrPathRendering>          fPathRendering;
497    // Subclass must initialize this in its constructor.
498    SkAutoTUnref<const GrCaps>    fCaps;
499
500private:
501    // called when the 3D context state is unknown. Subclass should emit any
502    // assumed 3D context state and dirty any state cache.
503    virtual void onResetContext(uint32_t resetBits) = 0;
504
505    // Called before certain draws in order to guarantee coherent results from dst reads.
506    virtual void xferBarrier(GrRenderTarget*, GrXferBarrierType) = 0;
507
508    // overridden by backend-specific derived class to create objects.
509    // Texture size and sample size will have already been validated in base class before
510    // onCreateTexture/CompressedTexture are called.
511    virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc,
512                                       GrGpuResource::LifeCycle lifeCycle,
513                                       const void* srcData, size_t rowBytes) = 0;
514    virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
515                                                 GrGpuResource::LifeCycle lifeCycle,
516                                                 const void* srcData) = 0;
517    virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) = 0;
518    virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
519                                                      GrWrapOwnership) = 0;
520    virtual GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&,
521                                                               GrWrapOwnership) = 0;
522    virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) = 0;
523    virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) = 0;
524    virtual GrTransferBuffer* onCreateTransferBuffer(size_t size, TransferType type) = 0;
525
526    // overridden by backend-specific derived class to perform the clear.
527    virtual void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) = 0;
528
529
530    // Overridden by backend specific classes to perform a clear of the stencil clip bits.  This is
531    // ONLY used by the the clip target
532    virtual void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) = 0;
533
534    // overridden by backend-specific derived class to perform the draw call.
535    virtual void onDraw(const DrawArgs&, const GrNonInstancedVertices&) = 0;
536
537    virtual bool onMakeCopyForTextureParams(GrTexture* texture, const GrTextureParams&,
538                                            GrTextureProducer::CopyParams*) const { return false; }
539
540    virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight,
541                                     size_t rowBytes, GrPixelConfig readConfig, DrawPreference*,
542                                     ReadPixelTempDrawInfo*) = 0;
543    virtual bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
544                                      GrPixelConfig srcConfig, DrawPreference*,
545                                      WritePixelTempDrawInfo*) = 0;
546
547    // overridden by backend-specific derived class to perform the surface read
548    virtual bool onReadPixels(GrSurface*,
549                              int left, int top,
550                              int width, int height,
551                              GrPixelConfig,
552                              void* buffer,
553                              size_t rowBytes) = 0;
554
555    // overridden by backend-specific derived class to perform the surface write
556    virtual bool onWritePixels(GrSurface*,
557                               int left, int top, int width, int height,
558                               GrPixelConfig config, const void* buffer,
559                               size_t rowBytes) = 0;
560
561    // overridden by backend-specific derived class to perform the surface write
562    virtual bool onTransferPixels(GrSurface*,
563                                  int left, int top, int width, int height,
564                                  GrPixelConfig config, GrTransferBuffer* buffer,
565                                  size_t offset, size_t rowBytes) = 0;
566
567    // overridden by backend-specific derived class to perform the resolve
568    virtual void onResolveRenderTarget(GrRenderTarget* target) = 0;
569
570    // overridden by backend specific derived class to perform the copy surface
571    virtual bool onCopySurface(GrSurface* dst,
572                               GrSurface* src,
573                               const SkIRect& srcRect,
574                               const SkIPoint& dstPoint) = 0;
575
576    void resetContext() {
577        this->onResetContext(fResetBits);
578        fResetBits = 0;
579        ++fResetTimestamp;
580    }
581
582    ResetTimestamp                                                      fResetTimestamp;
583    uint32_t                                                            fResetBits;
584    // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
585    GrContext*                                                          fContext;
586
587    friend class GrPathRendering;
588    typedef SkRefCnt INHERITED;
589};
590
591#endif
592