hack

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 111 matching lines @@
 
     /**
      * Creates a new entry, based on the specified key and texture and returns it. The caller owns a
      * ref on the returned texture which must be balanced by a call to unref.
      *
      * @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.
      * @param desc      Description of the texture properties.
-     * @param cacheID Cache-specific properties (e.g., texture gen ID)
+     * @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.
      * @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 GrCacheID& cacheID,
                              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 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,
                                  const GrCacheID& cacheID,
                                  const GrTextureParams* params);
     /**
      * Determines whether a texture is in the cache. If the texture is found it
@@ skipping 115 matching lines @@
     void setMaxTextureSizeOverride(int maxTextureSizeOverride);
 
     ///////////////////////////////////////////////////////////////////////////
     // Render targets
 
     /**
      * Sets the render target.
      * @param target    the render target to set.
      */
     void setRenderTarget(GrRenderTarget* target) {
-        fRenderTarget.reset(SkSafeRef(target));
+//        SkDebugf("GrContext::setRenderTarget\n");
+        fRenderTarget1.reset(SkSafeRef(target));
     }
 
     /**
      * Gets the current render target.
      * @return the currently bound render target.
      */
-    const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
-    GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); }
+    const GrRenderTarget* getRenderTarget() const { return fRenderTarget1.get(); }
+    GrRenderTarget* getRenderTarget() { return fRenderTarget1.get(); }
 
     GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
 
     /**
      * Can the provided configuration act as a color render target?
      */
     bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const;
 
     /**
      * Return the max width or height of a render target supported by the
@@ skipping 591 matching lines @@
 private:
     // Used to indicate whether a draw should be performed immediately or queued in fDrawBuffer.
     enum BufferedDraw {
         kYes_BufferedDraw,
         kNo_BufferedDraw,
     };
     BufferedDraw fLastDrawWasBuffered;
 
     GrGpu*                          fGpu;
     SkMatrix                        fViewMatrix;
-    SkAutoTUnref<GrRenderTarget>    fRenderTarget;
+    SkAutoTUnref<GrRenderTarget>    fRenderTarget1;
     const GrClipData*               fClip;  // TODO: make this ref counted
     GrDrawState*                    fDrawState;
 
     GrResourceCache*                fTextureCache;
     GrFontCache*                    fFontCache;
     SkAutoTDelete<GrLayerCache>     fLayerCache;
 
     GrPathRendererChain*            fPathRendererChain;
     GrSoftwarePathRenderer*         fSoftwarePathRenderer;
 
@@ skipping 161 matching lines @@
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif