rename GrTextureDesc->GrSurfaceDesc, GrTextureFlags->GrSurfaceFlags

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 190 matching lines @@
      *                  texture support). NULL implies clamp wrap modes.
      * @param desc      Description of the texture properties.
      * @param cacheID   Cache-specific properties (e.g., texture gen ID)
      * @param srcData   Pointer to the pixel values.
      * @param rowBytes  The number of bytes between rows of the texture. Zero
      *                  implies tightly packed rows. For compressed pixel configs, this
      *                  field is ignored.
      * @param cacheKey  (optional) If non-NULL, we'll write the cache key we used to cacheKey.
      */
     GrTexture* createTexture(const GrTextureParams* params,
-                             const GrTextureDesc& desc,
+                             const GrSurfaceDesc& desc,
                              const GrCacheID& cacheID,
                              const void* srcData,
                              size_t rowBytes,
                              GrResourceKey* cacheKey = NULL);
     /**
      * Search for an entry based on key and dimensions. If found, ref it and return it. The return
      * value will be NULL if not found. The caller must balance with a call to unref.
      *
      *  @param desc     Description of the texture properties.
      *  @param cacheID Cache-specific properties (e.g., texture gen ID)
      *  @param params   The texture params used to draw a texture may help determine
      *                  the cache entry used. (e.g. different versions may exist
      *                  for different wrap modes on GPUs with limited NPOT
      *                  texture support). NULL implies clamp wrap modes.
      */
-    GrTexture* findAndRefTexture(const GrTextureDesc& desc,
+    GrTexture* findAndRefTexture(const GrSurfaceDesc& desc,
                                  const GrCacheID& cacheID,
                                  const GrTextureParams* params);
     /**
      * Determines whether a texture is in the cache. If the texture is found it
      * will not be locked or returned. This call does not affect the priority of
      * the texture for deletion.
      */
-    bool isTextureInCache(const GrTextureDesc& desc,
+    bool isTextureInCache(const GrSurfaceDesc& desc,
                           const GrCacheID& cacheID,
                           const GrTextureParams* params) const;
 
     /**
      * Enum that determines how closely a returned scratch texture must match
-     * a provided GrTextureDesc.
+     * a provided GrSurfaceDesc.
      */
     enum ScratchTexMatch {
         /**
          * Finds a texture that exactly matches the descriptor.
          */
         kExact_ScratchTexMatch,
         /**
          * Finds a texture that approximately matches the descriptor. Will be
          * at least as large in width and height as desc specifies. If desc
          * specifies that texture is a render target then result will be a
@@ skipping 10 matching lines @@
      * It is guaranteed that the same texture will not be returned in subsequent
      * calls until all refs to the texture are dropped.
      *
      * Textures created by createTexture() hide the complications of
      * tiling non-power-of-two textures on APIs that don't support this (e.g.
      * unextended GLES2). NPOT scratch textures are not tilable on such APIs.
      *
      * internalFlag is a temporary workaround until changes in the internal
      * architecture are complete. Use the default value.
      */
-    GrTexture* refScratchTexture(const GrTextureDesc&, ScratchTexMatch match,
+    GrTexture* refScratchTexture(const GrSurfaceDesc&, ScratchTexMatch match,
                                  bool internalFlag = false);
 
     /**
      * Creates a texture that is outside the cache. Does not count against
      * cache's budget.
      *
      * Textures created by createTexture() hide the complications of
      * tiling non-power-of-two textures on APIs that don't support this (e.g.
      * unextended GLES2). NPOT uncached textures are not tilable on such APIs.
      */
-    GrTexture* createUncachedTexture(const GrTextureDesc& desc,
+    GrTexture* createUncachedTexture(const GrSurfaceDesc& desc,
                                      void* srcData,
                                      size_t rowBytes);
 
     /**
      * Returns true if the specified use of an indexed texture is supported.
      * Support may depend upon whether the texture params indicate that the
      * texture will be tiled. Passing NULL for the texture params indicates
      * clamp mode.
      */
     bool supportsIndex8PixelConfig(const GrTextureParams*,
@@ skipping 700 matching lines @@
 
     class AutoRestoreEffects;
     class AutoCheckFlush;
     /// Sets the paint and returns the target to draw into. The paint can be NULL in which case the
     /// draw state is left unmodified.
     GrDrawTarget* prepareToDraw(const GrPaint*, BufferedDraw, AutoRestoreEffects*, AutoCheckFlush*);
 
     void internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
                           const GrStrokeInfo& stroke);
 
-    GrTexture* createResizedTexture(const GrTextureDesc& desc,
+    GrTexture* createResizedTexture(const GrSurfaceDesc& desc,
                                     const GrCacheID& cacheID,
                                     const void* srcData,
                                     size_t rowBytes,
                                     bool filter);
 
-    GrTexture* createNewScratchTexture(const GrTextureDesc& desc);
+    GrTexture* createNewScratchTexture(const GrSurfaceDesc& desc);
 
     /**
      * These functions create premul <-> unpremul effects if it is possible to generate a pair
      * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they
      * return NULL.
      */
     const GrFragmentProcessor* createPMToUPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
     const GrFragmentProcessor* createUPMToPMEffect(GrTexture*, bool swapRAndB, const SkMatrix&);
 
     /**
      *  This callback allows the resource cache to callback into the GrContext
      *  when the cache is still overbudget after a purge.
      */
     static bool OverbudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif