Use draw buffer for texture copy impl.

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 1535 matching lines @@
         return srcPI.convertPixelsTo(&dstPI, width, height);
     }
     return true;
 }
 
 void GrContext::resolveRenderTarget(GrRenderTarget* target) {
     SkASSERT(target);
     ASSERT_OWNED_RESOURCE(target);
     // In the future we may track whether there are any pending draws to this
     // target. We don't today so we always perform a flush. We don't promise
     // this to our clients, though.

[robertphillips, 2014/09/23 13:21:53]

Is this flush on your radar?

[bsalomon, 2014/09/23 15:08:57]

Yes, I think this whole function can be deleted.

     this->flush();
     if (fGpu) {
         fGpu->resolveRenderTarget(target);
     }
 }
 
 void GrContext::discardRenderTarget(GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     ASSERT_OWNED_RESOURCE(renderTarget);
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(NULL, BUFFERED_DRAW, &are, &acf);
     if (NULL == target) {
         return;
     }
     target->discard(renderTarget);
 }
 
 void GrContext::copyTexture(GrTexture* src, GrRenderTarget* dst, const SkIPoint* topLeft) {
     if (NULL == src || NULL == dst) {
         return;
     }

[robertphillips, 2014/09/23 13:21:53]

ASSERT_OWNED_RESOURCE(dst); ?

[bsalomon, 2014/09/23 15:08:57]

Done.

     ASSERT_OWNED_RESOURCE(src);
 
 
     if (src->hasPendingWrite() || dst->hasPendingIO()) {
         this->flush();
     }
 

[robertphillips, 2014/09/23 13:21:53]

So this prepareToDraw call does a bit of work on the DrawState we're not going
to use. Would it make more sense after the ASR?

[bsalomon, 2014/09/23 15:08:57]

I think there is a larger change coming related to not making GrGpu a GrDT
subclass. Right now this function still applies the override to kYes_

I did just realize that this should turn off the clip bit on GrDrawState. Will
fix that.

-    GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit);
-    GrDrawState* drawState = fGpu->drawState();
+    GrDrawTarget* target = this->prepareToDraw(NULL, kYes_BufferedDraw, NULL, NULL);
+    GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kReset_ASRInit);
+    GrDrawState* drawState = target->drawState();
     drawState->setRenderTarget(dst);
     SkMatrix sampleM;
     sampleM.setIDiv(src->width(), src->height());
     SkIRect srcRect = SkIRect::MakeWH(dst->width(), dst->height());
     if (topLeft) {
         srcRect.offset(*topLeft);
     }
     SkIRect srcBounds = SkIRect::MakeWH(src->width(), src->height());
     if (!srcRect.intersect(srcBounds)) {
         return;
     }
     sampleM.preTranslate(SkIntToScalar(srcRect.fLeft), SkIntToScalar(srcRect.fTop));
     drawState->addColorTextureEffect(src, sampleM);
     SkRect dstR = SkRect::MakeWH(SkIntToScalar(srcRect.width()), SkIntToScalar(srcRect.height()));
-    fGpu->drawSimpleRect(dstR);
+    target->drawSimpleRect(dstR);
 }
 
 bool GrContext::writeRenderTargetPixels(GrRenderTarget* target,
                                         int left, int top, int width, int height,
                                         GrPixelConfig srcConfig,
                                         const void* buffer,
                                         size_t rowBytes,
                                         uint32_t flags) {
     ASSERT_OWNED_RESOURCE(target);
 
@@ skipping 119 matching lines @@
 
     drawState->setRenderTarget(target);
 
     fGpu->drawSimpleRect(SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)));
     return true;
 }
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget* GrContext::prepareToDraw(const GrPaint* paint,
                                        BufferedDraw buffered,
                                        AutoRestoreEffects* are,

[robertphillips, 2014/09/23 13:21:53]

Does it still make sense to pass the acf?

[bsalomon, 2014/09/23 15:08:57]

I'm not totally sure. I want to revisit this once the new cache is operational.

                                        AutoCheckFlush* acf) {
     // All users of this draw state should be freeing up all effects when they're done.
     // Otherwise effects that own resources may keep those resources alive indefinitely.
     SkASSERT(0 == fDrawState->numColorStages() && 0 == fDrawState->numCoverageStages() &&
              !fDrawState->hasGeometryProcessor());
 
     if (NULL == fGpu) {
         return NULL;
     }
 
@@ skipping 193 matching lines @@
     fResourceCache->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif