minor cleanup in GrGpu.h

src/gpu/GrGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpu_DEFINED
 #define GrGpu_DEFINED
 
@@ skipping 65 matching lines @@
      * the GrGpu that the state was modified and it shouldn't make assumptions
      * about the state.
      */
     void markContextDirty(uint32_t state = kAll_GrBackendState) {
         fResetBits |= state;
     }
 
     void unimpl(const char[]);
 
     /**
-     * Creates a texture object. If desc width or height is not a power of
-     * two but underlying API requires a power of two texture then srcData
-     * will be embedded in a power of two texture. The extra width and height
-     * is filled as though srcData were rendered clamped into the texture.
-     * The exception is when using compressed data formats. In this case, the
-     * desc width and height must be a multiple of the compressed format block
-     * size otherwise this function returns NULL. Similarly, if the underlying
-     * API requires a power of two texture and the source width and height are not
-     * a power of two, then this function returns NULL.
-     *
-     * If kRenderTarget_TextureFlag is specified the GrRenderTarget is
-     * accessible via GrTexture::asRenderTarget(). The texture will hold a ref
-     * on the render target until the texture is destroyed. Compressed textures
-     * cannot have the kRenderTarget_TextureFlag set.
+     * Creates a texture object. If kRenderTarget_GrSurfaceFlag the texture can
+     * be used as a render target by calling GrTexture::asRenderTarget(). Not all
+     * pixel configs can be used as render targets. Support for configs as textures
+     * or render targets can be checked using GrDrawTargetCaps.
      *
      * @param desc        describes the texture to be created.
      * @param srcData     texel data to load texture. Begins with full-size
      *                    palette data for paletted textures. For compressed
      *                    formats it contains the compressed pixel data. Otherwise,
      *                    it contains width*height texels. If NULL texture data
      *                    is uninitialized.
      * @param rowBytes    the number of bytes between consecutive rows. Zero
      *                    means rows are tightly packed. This field is ignored
      *                    for compressed formats.
      *
      * @return    The texture object if successful, otherwise NULL.
      */
-    GrTexture* createTexture(const GrSurfaceDesc& desc,
-                             const void* srcData, size_t rowBytes);
+    GrTexture* createTexture(const GrSurfaceDesc& desc, const void* srcData, size_t rowBytes);
 
     /**
      * Implements GrContext::wrapBackendTexture
      */
     GrTexture* wrapBackendTexture(const GrBackendTextureDesc&);
 
     /**
      * Implements GrContext::wrapBackendTexture
      */
     GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&);
@@ skipping 143 matching lines @@
     bool writeTexturePixels(GrTexture* texture,
                             int left, int top, int width, int height,
                             GrPixelConfig config, const void* buffer,
                             size_t rowBytes);
 
     /**
      * Clear the passed in render target. Ignores the draw state and clip. Clears the whole thing if
      * rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire render target
      * can be optionally cleared.
      */
-    void clear(const SkIRect* rect,
-               GrColor color,
-               bool canIgnoreRect,
-               GrRenderTarget* renderTarget);
+    void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect,GrRenderTarget* renderTarget);
 
 
-    void clearStencilClip(const SkIRect& rect,
-                          bool insideClip,
-                          GrRenderTarget* renderTarget);
+    void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget);
 
     /**
      * Discards the contents render target. NULL indicates that the current render target should
      * be discarded.
      **/
     virtual void discard(GrRenderTarget* = NULL) = 0;
 
     /**
      * This is can be called before allocating a texture to be a dst for copySurface. It will
      * populate the origin, config, and flags fields of the desc such that copySurface is more
      * likely to succeed and be efficient.
      */
     virtual void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc);
 
     // After the client interacts directly with the 3D context state the GrGpu
     // must resync its internal state and assumptions about 3D context state.
     // Each time this occurs the GrGpu bumps a timestamp.
     // state of the 3D context
     // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about
     // a billion years.
     typedef uint64_t ResetTimestamp;
 
     // This timestamp is always older than the current timestamp
     static const ResetTimestamp kExpiredTimestamp = 0;
     // Returns a timestamp based on the number of times the context was reset.
     // This timestamp can be used to lazily detect when cached 3D context state
     // is dirty.
-    ResetTimestamp getResetTimestamp() const {
-        return fResetTimestamp;
-    }
+    ResetTimestamp getResetTimestamp() const { return fResetTimestamp; }
 
     enum DrawType {
         kDrawPoints_DrawType,
         kDrawLines_DrawType,
         kDrawTriangles_DrawType,
         kStencilPath_DrawType,
         kDrawPath_DrawType,
         kDrawPaths_DrawType,
     };
 
@@ skipping 236 matching lines @@
     int                                                                 fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                    fActiveTraceMarkers;
     GrTraceMarkerSet                                                    fStoredTraceMarkers;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif