GrContext::copyTexture->GrContext::copySurface. Add a flush writes pixel ops flag.

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 579 matching lines @@
      * underlying 3D API.
      * @param flagsBitfield     flags that control the flushing behavior. See
      *                          FlushBits.
      */
     void flush(int flagsBitfield = 0);
 
    /**
     * These flags can be used with the read/write pixels functions below.
     */
     enum PixelOpsFlags {
-        /** The GrContext will not be flushed. This means that the read or write may occur before
-            previous draws have executed. */
+        /** The GrContext will not be flushed before the surface read or write. This means that
+            the read or write may occur before previous draws have executed. */
         kDontFlush_PixelOpsFlag = 0x1,
+        /** Any surface writes should be flushed to the backend 3D API after the surface operation
+            is complete */
+        kFlushWrites_PixelOp = 0x2,
         /** The src for write or dst read is unpremultiplied. This is only respected if both the
             config src and dst configs are an RGBA/BGRA 8888 format. */
-        kUnpremul_PixelOpsFlag  = 0x2,
+        kUnpremul_PixelOpsFlag  = 0x4,
     };
 
     /**
      * Reads a rectangle of pixels from a render target.
      * @param target        the render target to read from. NULL means the current render target.
      * @param left          left edge of the rectangle to read (inclusive)
      * @param top           top edge of the rectangle to read (inclusive)
      * @param width         width of rectangle to read in pixels.
      * @param height        height of rectangle to read in pixels.
      * @param config        the pixel config of the destination buffer
@@ skipping 72 matching lines @@
      * @return true if the write succeeded, false if not. The write can fail because of an
      *         unsupported combination of texture and pixel configs.
      */
     bool writeTexturePixels(GrTexture* texture,
                             int left, int top, int width, int height,
                             GrPixelConfig config, const void* buffer,
                             size_t rowBytes,
                             uint32_t pixelOpsFlags = 0);
 
     /**
-     * Copies a rectangle of texels from src to dst. The size of dst is the size of the rectangle
-     * copied and topLeft is the position of the rect in src. The rectangle is clipped to src's
+     * Copies a rectangle of texels from src to dst.
      * bounds.
-     * @param src           the texture to copy from.
-     * @param dst           the render target to copy to.
-     * @param topLeft       the point in src that will be copied to the top-left of dst. If NULL,
-     *                      (0, 0) will be used.
+     * @param dst           the surface to copy to.
+     * @param src           the surface to copy from.
+     * @param srcRect       the rectangle of the src that should be copied.
+     * @param dstPoint      the translation applied when writing the srcRect's pixels to the dst.
+     * @param pixelOpsFlags see PixelOpsFlags enum above. (kUnpremul_PixelOpsFlag is not allowed).
      */
-    void copyTexture(GrTexture* src, GrRenderTarget* dst, const SkIPoint* topLeft = NULL);
+    void copySurface(GrSurface* dst,
+                     GrSurface* src,
+                     const SkIRect& srcRect,
+                     const SkIPoint& dstPoint,
+                     uint32_t pixelOpsFlags = 0);
+
+    /** Helper that copies the whole surface but fails when the two surfaces are not identically
+        sized. */
+    bool copySurface(GrSurface* dst, GrSurface* src) {
+        if (NULL == dst || NULL == src || dst->width() != src->width() ||
+            dst->height() != src->height()) {
+            return false;
+        }
+        this->copySurface(dst, src, SkIRect::MakeWH(dst->width(), dst->height()),
+                          SkIPoint::Make(0,0));
+        return true;
+    }
+
+    /**
+     * After this returns any pending writes to the surface will have been issued to the backend 3D API.
+     */
+    void flushSurfaceWrites(GrSurface* surface);
 
     /**
      * Resolves a render target that has MSAA. The intermediate MSAA buffer is
      * down-sampled to the associated GrTexture (accessible via
      * GrRenderTarget::asTexture()). Any pending draws to the render target will
      * be executed before the resolve.
      *
      * This is only necessary when a client wants to access the object directly
      * using the backend API directly. GrContext will detect when it must
      * perform a resolve to a GrTexture used as the source of a draw or before
@@ skipping 424 matching lines @@
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif