XPFactory lazily initializie in drawstate / GrPaint

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 
@@ skipping 26 matching lines @@
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTraceEvent.h"
 
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrSingleTextureEffect.h"
 
-#ifdef SK_DEBUG
-    // change this to a 1 to see notifications when partial coverage fails
-    #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
-#else
-    #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
-#endif
-
 static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 15;
 static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
 
 static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 1 << 11;
 static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 4;
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 
 class GrContext::AutoCheckFlush {
 public:
@@ skipping 392 matching lines @@
 
 void GrContext::OverBudgetCB(void* data) {
     SkASSERT(data);
 
     GrContext* context = reinterpret_cast<GrContext*>(data);
 
     // Flush the InOrderDrawBuffer to possibly free up some textures
     context->fFlushToReduceCacheSize = true;
 }
 
-
 GrTexture* GrContext::createUncachedTexture(const GrSurfaceDesc& desc,
                                             void* srcData,
                                             size_t rowBytes) {
     return fGpu->createTexture(desc, false, srcData, rowBytes);
 }
 
 void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
     if (maxTextures) {
         *maxTextures = fResourceCache2->getMaxResourceCount();
     }
@@ skipping 1085 matching lines @@
 
 GrDrawTarget* GrContext::prepareToDraw(GrDrawState* ds,
                                        const GrPaint* paint,
                                        const AutoCheckFlush* acf) {
     if (NULL == fGpu) {
         return NULL;
     }
 
     ASSERT_OWNED_RESOURCE(fRenderTarget.get());
     if (ds) {
-        if (paint) {
-            SkASSERT(acf);
-            ds->setFromPaint(*paint, fRenderTarget.get());
-#if GR_DEBUG_PARTIAL_COVERAGE_CHECK
-            if ((paint->hasMask()) &&
-                !fDrawState->canUseFracCoveragePrimProc(paint.getColor(), fGpu->caps())) {
-                SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
-            }
-#endif
-        } else {
-            ds->reset();
-            ds->setRenderTarget(fRenderTarget.get());
-        }
+        SkASSERT(paint && acf);
+        ds->setFromPaint(*paint, fRenderTarget.get());
         ds->setState(GrDrawState::kClip_StateBit, fClip && !fClip->fClipStack->isWideOpen());
     }
     fDrawBuffer->setClip(fClip);
     return fDrawBuffer;
 }
 
 /*
  * This method finds a path renderer that can draw the specified path on
  * the provided target.
  * Due to its expense, the software path renderer has split out so it can
@@ skipping 149 matching lines @@
     fResourceCache2->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif