Update how we send draws to gpu backend to reduce state setting.

src/gpu/vk/GrVkProgramBuilder.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "vk/GrVkProgramBuilder.h"
 
 #include "vk/GrVkGpu.h"
 #include "vk/GrVkRenderPass.h"
 #include "vk/GrVkProgram.h"
 
 GrVkProgram* GrVkProgramBuilder::CreateProgram(GrVkGpu* gpu,
-                                               const DrawArgs& args,
+                                               const GrPipeline& pipeline,
+                                               const GrPrimitiveProcessor& primProc,
                                                GrPrimitiveType primitiveType,
+                                               const GrVkProgramDesc& desc,
                                                const GrVkRenderPass& renderPass) {
     // create a builder.  This will be handed off to effects so they can use it to add
     // uniforms, varyings, textures, etc
-    GrVkProgramBuilder builder(gpu, args);
+    GrVkProgramBuilder builder(gpu, pipeline, primProc, desc);
 
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
 
     if (!builder.emitAndInstallProcs(&inputColor, &inputCoverage)) {
         builder.cleanupFragmentProcessors();
         return nullptr;
     }
 
-    return builder.finalize(args, primitiveType, renderPass);
+    return builder.finalize(primitiveType, renderPass);
 }
 
-GrVkProgramBuilder::GrVkProgramBuilder(GrVkGpu* gpu, const DrawArgs& args)
-    : INHERITED(args) 
+GrVkProgramBuilder::GrVkProgramBuilder(GrVkGpu* gpu,
+                                       const GrPipeline& pipeline,
+                                       const GrPrimitiveProcessor& primProc,
+                                       const GrVkProgramDesc& desc)
+    : INHERITED(pipeline, primProc, desc) 
     , fGpu(gpu)
     , fVaryingHandler(this) 
     , fUniformHandler(this) {
 }
 
 const GrCaps* GrVkProgramBuilder::caps() const {
     return fGpu->caps();
 }
 const GrGLSLCaps* GrVkProgramBuilder::glslCaps() const {
     return fGpu->vkCaps().glslCaps();
@@ skipping 83 matching lines @@
     stageInfo->pNext = nullptr;
     stageInfo->flags = 0;
     stageInfo->stage = stage;
     stageInfo->module = *shaderModule;
     stageInfo->pName = "main";
     stageInfo->pSpecializationInfo = nullptr;
 
     return true;
 }
 
-GrVkProgram* GrVkProgramBuilder::finalize(const DrawArgs& args,
-                                          GrPrimitiveType primitiveType,
+GrVkProgram* GrVkProgramBuilder::finalize(GrPrimitiveType primitiveType,
                                           const GrVkRenderPass& renderPass) {
     VkDescriptorSetLayout dsLayout[2];
     VkPipelineLayout pipelineLayout;
     VkShaderModule vertShaderModule;
     VkShaderModule fragShaderModule;
 
     uint32_t numSamplers = fSamplerUniforms.count();
 
     SkAutoTDeleteArray<VkDescriptorSetLayoutBinding> dsSamplerBindings(
                                                      new VkDescriptorSetLayoutBinding[numSamplers]);
@@ skipping 89 matching lines @@
                                         &vertShaderModule,
                                         &shaderStageInfo[0]));
 
     SkAssertResult(CreateVkShaderModule(fGpu,
                                         VK_SHADER_STAGE_FRAGMENT_BIT,
                                         fFS,
                                         &fragShaderModule,
                                         &shaderStageInfo[1]));
 
     GrVkResourceProvider& resourceProvider = fGpu->resourceProvider();
-    GrVkPipeline* pipeline = resourceProvider.createPipeline(*args.fPipeline,
-                                                             *args.fPrimitiveProcessor,
+    GrVkPipeline* pipeline = resourceProvider.createPipeline(fPipeline,
+                                                             fPrimProc,
                                                              shaderStageInfo,
                                                              2,
                                                              primitiveType,
                                                              renderPass,
                                                              pipelineLayout);
     GR_VK_CALL(fGpu->vkInterface(), DestroyShaderModule(fGpu->device(), vertShaderModule,
                                                         nullptr));
     GR_VK_CALL(fGpu->vkInterface(), DestroyShaderModule(fGpu->device(), fragShaderModule,
                                                         nullptr));
 
@@ skipping 36 matching lines @@
                            descriptorSets,
                            fUniformHandles,
                            fUniformHandler.fUniforms,
                            fUniformHandler.fCurrentVertexUBOOffset,
                            fUniformHandler.fCurrentFragmentUBOOffset,
                            numSamplers,
                            fGeometryProcessor,
                            fXferProcessor,
                            fFragmentProcessors);
 }