Make GrGpuCommandBuffer's methods take a GrRenderTargetProxy (rather than a GrRenderTarget)

In https://skia-review.googlesource.com/c/26363/ (Remove origin field from GrSurface) I just passed
an extra GrSurfaceOrigin parameter to all these methods. Besides being verbose this also led to
the "discard" method having an origin (to support the GrVkGpuCommandBuffer). It think this approach
is better and is plausible if the GrGpuCommandBuffer is viewed as an intermediary between the
GrProxy-based Ops and the Gpu.

In isolation this CL doesn't really show why we want to percolate the Proxy down. Once GrSurface
no longer has an origin a lot of the GrGpu methods need it passed in explicitly. By having the
GrGpuCommandBuffer get the proxy it can then pass the origin to GrGpu and removes a layer of
functions with an extra origin parameter.

Change-Id: Ie223fdee930171a32a5923155a0322e9a9c2aaa9
Reviewed-on: https://skia-review.googlesource.com/27980
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/GrGpuCommandBuffer.cpp b/src/gpu/GrGpuCommandBuffer.cpp
index fd6c4bd..e240068 100644
--- a/src/gpu/GrGpuCommandBuffer.cpp
+++ b/src/gpu/GrGpuCommandBuffer.cpp
@@ -21,19 +21,20 @@
     this->onSubmit();
 }
 
-void GrGpuCommandBuffer::clear(GrRenderTarget* rt, const GrFixedClip& clip, GrColor color) {
+void GrGpuCommandBuffer::clear(GrRenderTargetProxy* proxy, const GrFixedClip& clip, GrColor color) {
 #ifdef SK_DEBUG
+    GrRenderTarget* rt = proxy->priv().peekRenderTarget();
     SkASSERT(rt);
     SkASSERT(!clip.scissorEnabled() ||
              (SkIRect::MakeWH(rt->width(), rt->height()).contains(clip.scissorRect()) &&
               SkIRect::MakeWH(rt->width(), rt->height()) != clip.scissorRect()));
 #endif
-    this->onClear(rt, clip, color);
+    this->onClear(proxy, clip, color);
 }
 
-void GrGpuCommandBuffer::clearStencilClip(GrRenderTarget* rt, const GrFixedClip& clip,
+void GrGpuCommandBuffer::clearStencilClip(GrRenderTargetProxy* proxy, const GrFixedClip& clip,
                                           bool insideStencilMask) {
-    this->onClearStencilClip(rt, clip, insideStencilMask);
+    this->onClearStencilClip(proxy, clip, insideStencilMask);
 }
 
 bool GrGpuCommandBuffer::draw(const GrPipeline& pipeline,
diff --git a/src/gpu/GrGpuCommandBuffer.h b/src/gpu/GrGpuCommandBuffer.h
index 3a6a3e7..3fb12bf 100644
--- a/src/gpu/GrGpuCommandBuffer.h
+++ b/src/gpu/GrGpuCommandBuffer.h
@@ -75,22 +75,22 @@
               const SkRect& bounds);
 
     // Performs an upload of vertex data in the middle of a set of a set of draws
-    virtual void inlineUpload(GrOpFlushState* state, GrDrawOp::DeferredUploadFn& upload,
-                              GrRenderTarget* rt) = 0;
+    virtual void inlineUpload(GrOpFlushState*, GrDrawOp::DeferredUploadFn&,
+                              GrRenderTargetProxy*) = 0;
 
     /**
      * Clear the passed in render target. Ignores the draw state and clip.
      */
-    void clear(GrRenderTarget*, const GrFixedClip&, GrColor);
+    void clear(GrRenderTargetProxy*, const GrFixedClip&, GrColor);
 
-    void clearStencilClip(GrRenderTarget*, const GrFixedClip&, bool insideStencilMask);
+    void clearStencilClip(GrRenderTargetProxy*, const GrFixedClip&, bool insideStencilMask);
 
     /**
      * Discards the contents render target. nullptr indicates that the current render target should
      * be discarded.
      */
     // TODO: This should be removed in the future to favor using the load and store ops for discard
-    virtual void discard(GrRenderTarget*) = 0;
+    virtual void discard(GrRenderTargetProxy*) = 0;
 
 private:
     virtual GrGpu* gpu() = 0;
@@ -107,9 +107,9 @@
                         const SkRect& bounds) = 0;
 
     // overridden by backend-specific derived class to perform the clear.
-    virtual void onClear(GrRenderTarget*, const GrFixedClip&, GrColor) = 0;
+    virtual void onClear(GrRenderTargetProxy*, const GrFixedClip&, GrColor) = 0;
 
-    virtual void onClearStencilClip(GrRenderTarget*, const GrFixedClip&,
+    virtual void onClearStencilClip(GrRenderTargetProxy*, const GrFixedClip&,
                                     bool insideStencilMask) = 0;
 
 };
diff --git a/src/gpu/gl/GrGLGpuCommandBuffer.h b/src/gpu/gl/GrGLGpuCommandBuffer.h
index 5ca211a..a430494 100644
--- a/src/gpu/gl/GrGLGpuCommandBuffer.h
+++ b/src/gpu/gl/GrGLGpuCommandBuffer.h
@@ -30,8 +30,8 @@
 
     void end() override {}
 
-    void discard(GrRenderTarget* rt) override {
-        GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(rt);
+    void discard(GrRenderTargetProxy* proxy) override {
+        GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(proxy->priv().peekRenderTarget());
         if (!fRenderTarget) {
             fRenderTarget = target;
         }
@@ -39,7 +39,7 @@
     }
 
     void inlineUpload(GrOpFlushState* state, GrDrawOp::DeferredUploadFn& upload,
-                      GrRenderTarget*) override {
+                      GrRenderTargetProxy*) override {
         state->doUpload(upload);
     }
 
@@ -63,8 +63,8 @@
         fGpu->draw(pipeline, primProc, mesh, dynamicStates, meshCount);
     }
 
-    void onClear(GrRenderTarget* rt, const GrFixedClip& clip, GrColor color) override {
-        GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(rt);
+    void onClear(GrRenderTargetProxy* proxy, const GrFixedClip& clip, GrColor color) override {
+        GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(proxy->priv().peekRenderTarget());
         if (!fRenderTarget) {
             fRenderTarget = target;
         }
@@ -72,9 +72,9 @@
         fGpu->clear(clip, color, fRenderTarget);
     }
 
-    void onClearStencilClip(GrRenderTarget* rt, const GrFixedClip& clip,
+    void onClearStencilClip(GrRenderTargetProxy* proxy, const GrFixedClip& clip,
                             bool insideStencilMask) override {
-        GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(rt);
+        GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(proxy->priv().peekRenderTarget());
         if (!fRenderTarget) {
             fRenderTarget = target;
         }
diff --git a/src/gpu/mock/GrMockGpuCommandBuffer.h b/src/gpu/mock/GrMockGpuCommandBuffer.h
index c5719a5..d923903 100644
--- a/src/gpu/mock/GrMockGpuCommandBuffer.h
+++ b/src/gpu/mock/GrMockGpuCommandBuffer.h
@@ -16,8 +16,9 @@
     GrMockGpuCommandBuffer(GrMockGpu* gpu) : fGpu(gpu) {}
 
     GrGpu* gpu() override { return fGpu; }
-    void inlineUpload(GrOpFlushState*, GrDrawOp::DeferredUploadFn&, GrRenderTarget*) override {}
-    void discard(GrRenderTarget*) override {}
+    void inlineUpload(GrOpFlushState*, GrDrawOp::DeferredUploadFn&,
+                      GrRenderTargetProxy*) override {}
+    void discard(GrRenderTargetProxy*) override {}
     void end() override {}
 
     int numDraws() const { return fNumDraws; }
@@ -28,8 +29,9 @@
                 const GrPipeline::DynamicState[], int meshCount, const SkRect& bounds) override {
         ++fNumDraws;
     }
-    void onClear(GrRenderTarget*, const GrFixedClip&, GrColor) override {}
-    void onClearStencilClip(GrRenderTarget*, const GrFixedClip&, bool insideStencilMask) override {}
+    void onClear(GrRenderTargetProxy*, const GrFixedClip&, GrColor) override {}
+    void onClearStencilClip(GrRenderTargetProxy*, const GrFixedClip&,
+                            bool insideStencilMask) override {}
     GrRenderTarget* renderTarget() override { return nullptr; }
 
     GrMockGpu* fGpu;
diff --git a/src/gpu/ops/GrClearOp.cpp b/src/gpu/ops/GrClearOp.cpp
index 722d169..4cc2bf2 100644
--- a/src/gpu/ops/GrClearOp.cpp
+++ b/src/gpu/ops/GrClearOp.cpp
@@ -34,5 +34,5 @@
 void GrClearOp::onExecute(GrOpFlushState* state) {
     SkASSERT(state->drawOpArgs().renderTarget());
 
-    state->commandBuffer()->clear(state->drawOpArgs().renderTarget(), fClip, fColor);
+    state->commandBuffer()->clear(state->drawOpArgs().fProxy, fClip, fColor);
 }
diff --git a/src/gpu/ops/GrClearStencilClipOp.h b/src/gpu/ops/GrClearStencilClipOp.h
index ac7b0a8..2b60f02 100644
--- a/src/gpu/ops/GrClearStencilClipOp.h
+++ b/src/gpu/ops/GrClearStencilClipOp.h
@@ -57,8 +57,8 @@
     void onExecute(GrOpFlushState* state) override {
         SkASSERT(state->drawOpArgs().renderTarget());
 
-        GrRenderTarget* rt = state->drawOpArgs().renderTarget();
-        state->commandBuffer()->clearStencilClip(rt, fClip, fInsideStencilMask);
+        GrRenderTargetProxy* proxy = state->drawOpArgs().fProxy;
+        state->commandBuffer()->clearStencilClip(proxy, fClip, fInsideStencilMask);
     }
 
     const GrFixedClip fClip;
diff --git a/src/gpu/ops/GrDiscardOp.h b/src/gpu/ops/GrDiscardOp.h
index dd707e3..6f8ff5e 100644
--- a/src/gpu/ops/GrDiscardOp.h
+++ b/src/gpu/ops/GrDiscardOp.h
@@ -42,7 +42,7 @@
     void onExecute(GrOpFlushState* state) override {
         SkASSERT(state->drawOpArgs().renderTarget());
 
-        state->commandBuffer()->discard(state->drawOpArgs().renderTarget());
+        state->commandBuffer()->discard(state->drawOpArgs().fProxy);
     }
 
     typedef GrOp INHERITED;
diff --git a/src/gpu/ops/GrMeshDrawOp.cpp b/src/gpu/ops/GrMeshDrawOp.cpp
index 110f6e5..04a3096 100644
--- a/src/gpu/ops/GrMeshDrawOp.cpp
+++ b/src/gpu/ops/GrMeshDrawOp.cpp
@@ -70,7 +70,7 @@
         while (currUploadIdx < fInlineUploads.count() &&
                fInlineUploads[currUploadIdx].fUploadBeforeToken == drawToken) {
             state->commandBuffer()->inlineUpload(state, fInlineUploads[currUploadIdx++].fUpload,
-                                                 state->drawOpArgs().renderTarget());
+                                                 state->drawOpArgs().fProxy);
         }
         const QueuedDraw& draw = fQueuedDraws[currDrawIdx];
         SkASSERT(draw.fPipeline->proxy() == state->drawOpArgs().fProxy);
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.cpp b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
index 6cb1d5b..4c1ad8e 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
@@ -57,6 +57,7 @@
                                            const LoadAndStoreInfo& stencilInfo)
     : fGpu(gpu)
     , fRenderTarget(nullptr)
+    , fOrigin(kTopLeft_GrSurfaceOrigin)
     , fClearColor(GrColor4f::FromGrColor(colorInfo.fClearColor))
     , fLastPipelineState(nullptr) {
 
@@ -67,9 +68,10 @@
     fCurrentCmdInfo = -1;
 }
 
-void GrVkGpuCommandBuffer::init(GrVkRenderTarget* target) {
+void GrVkGpuCommandBuffer::init(GrVkRenderTarget* target, GrSurfaceOrigin origin) {
     SkASSERT(!fRenderTarget);
     fRenderTarget = target;
+    fOrigin = origin;
 
     GrVkRenderPass::LoadStoreOps vkColorOps(fVkColorLoadOp, fVkColorStoreOp);
     GrVkRenderPass::LoadStoreOps vkStencilOps(fVkStencilLoadOp, fVkStencilStoreOp);
@@ -181,10 +183,10 @@
     }
 }
 
-void GrVkGpuCommandBuffer::discard(GrRenderTarget* rt) {
-    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(rt);
+void GrVkGpuCommandBuffer::discard(GrRenderTargetProxy* proxy) {
+    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(proxy->priv().peekRenderTarget());
     if (!fRenderTarget) {
-        this->init(target);
+        this->init(target, proxy->origin());
     }
     SkASSERT(target == fRenderTarget);
 
@@ -217,13 +219,13 @@
     }
 }
 
-void GrVkGpuCommandBuffer::onClearStencilClip(GrRenderTarget* rt, const GrFixedClip& clip,
+void GrVkGpuCommandBuffer::onClearStencilClip(GrRenderTargetProxy* proxy, const GrFixedClip& clip,
                                               bool insideStencilMask) {
     SkASSERT(!clip.hasWindowRectangles());
 
-    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(rt);
+    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(proxy->priv().peekRenderTarget());
     if (!fRenderTarget) {
-        this->init(target);
+        this->init(target, proxy->origin());
     }
     SkASSERT(target == fRenderTarget);
 
@@ -251,7 +253,7 @@
     SkIRect vkRect;
     if (!clip.scissorEnabled()) {
         vkRect.setXYWH(0, 0, fRenderTarget->width(), fRenderTarget->height());
-    } else if (kBottomLeft_GrSurfaceOrigin != fRenderTarget->origin()) {
+    } else if (kBottomLeft_GrSurfaceOrigin != fOrigin) {
         vkRect = clip.scissorRect();
     } else {
         const SkIRect& scissor = clip.scissorRect();
@@ -284,13 +286,14 @@
     }
 }
 
-void GrVkGpuCommandBuffer::onClear(GrRenderTarget* rt, const GrFixedClip& clip, GrColor color) {
+void GrVkGpuCommandBuffer::onClear(GrRenderTargetProxy* proxy, const GrFixedClip& clip,
+                                   GrColor color) {
     // parent class should never let us get here with no RT
     SkASSERT(!clip.hasWindowRectangles());
 
-    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(rt);
+    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(proxy->priv().peekRenderTarget());
     if (!fRenderTarget) {
-        this->init(target);
+        this->init(target, proxy->origin());
     }
     SkASSERT(target == fRenderTarget);
 
@@ -337,7 +340,7 @@
     SkIRect vkRect;
     if (!clip.scissorEnabled()) {
         vkRect.setXYWH(0, 0, fRenderTarget->width(), fRenderTarget->height());
-    } else if (kBottomLeft_GrSurfaceOrigin != fRenderTarget->origin()) {
+    } else if (kBottomLeft_GrSurfaceOrigin != fOrigin) {
         vkRect = clip.scissorRect();
     } else {
         const SkIRect& scissor = clip.scissorRect();
@@ -411,10 +414,10 @@
 }
 
 void GrVkGpuCommandBuffer::inlineUpload(GrOpFlushState* state, GrDrawOp::DeferredUploadFn& upload,
-                                        GrRenderTarget* rt) {
-    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(rt);
+                                        GrRenderTargetProxy* proxy) {
+    GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(proxy->priv().peekRenderTarget());
     if (!fRenderTarget) {
-        this->init(target);
+        this->init(target, proxy->origin());
     }
     if (!fCommandBufferInfos[fCurrentCmdInfo].fIsEmpty) {
         this->addAdditionalRenderPass();
@@ -551,7 +554,7 @@
                                   const SkRect& bounds) {
     GrVkRenderTarget* target = static_cast<GrVkRenderTarget*>(pipeline.renderTarget());
     if (!fRenderTarget) {
-        this->init(target);
+        this->init(target, pipeline.proxy()->origin());
     }
     SkASSERT(target == fRenderTarget);
 
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.h b/src/gpu/vk/GrVkGpuCommandBuffer.h
index 9ef166e..06fb953 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.h
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.h
@@ -31,14 +31,14 @@
 
     void end() override;
 
-    void discard(GrRenderTarget*) override;
+    void discard(GrRenderTargetProxy*) override;
 
     void inlineUpload(GrOpFlushState* state, GrDrawOp::DeferredUploadFn& upload,
-                      GrRenderTarget*) override;
+                      GrRenderTargetProxy*) override;
 
 private:
     // Performs lazy initialization on the first operation seen by the command buffer.
-    void init(GrVkRenderTarget* rt);
+    void init(GrVkRenderTarget*, GrSurfaceOrigin);
 
     GrGpu* gpu() override;
     GrRenderTarget* renderTarget() override;
@@ -90,9 +90,10 @@
                                        const GrBuffer* instanceBuffer, int instanceCount,
                                        int baseInstance) final;
 
-    void onClear(GrRenderTarget*, const GrFixedClip&, GrColor color) override;
+    void onClear(GrRenderTargetProxy*, const GrFixedClip&, GrColor color) override;
 
-    void onClearStencilClip(GrRenderTarget*, const GrFixedClip&, bool insideStencilMask) override;
+    void onClearStencilClip(GrRenderTargetProxy*, const GrFixedClip&,
+                            bool insideStencilMask) override;
 
     void addAdditionalCommandBuffer();
     void addAdditionalRenderPass();
@@ -124,6 +125,7 @@
 
     GrVkGpu*                    fGpu;
     GrVkRenderTarget*           fRenderTarget;
+    GrSurfaceOrigin             fOrigin;
     VkAttachmentLoadOp          fVkColorLoadOp;
     VkAttachmentStoreOp         fVkColorStoreOp;
     VkAttachmentLoadOp          fVkStencilLoadOp;