tree 80ef64f11c344026dbb1460a3c8470970214a0f0
parent f3560b680e351b4ede610aa071ea8d43790d57b3
author Austin Eng <enga@google.com> 1581038776 +0000
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1581082668 +0000

Revert "Cleanup program building a bit"

This reverts commit 4777e3addec478786dcbb68035c5e11c82479b9f.

Reason for revert: This CL is breaking the build on Linux FYI SkiaRenderer Dawn Release 

Original change's description:
> Cleanup program building a bit
> 
> This CL:
>    now passes the GrProgramDesc as a const&
>    returns GrGLProgram as an sk_sp
>    makes the parameter ordering more consistent
>    makes GrVkPipelineState no longer ref-counted
> 
> This is pulled out of the DDL pre-compile CL which touches this portion of the code.
> 
> Bug: skia:9455
> Change-Id: Id4d06f93450e276de5a2662be330ae9523026244
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/268777
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Commit-Queue: Robert Phillips <robertphillips@google.com>

TBR=egdaniel@google.com,robertphillips@google.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: skia:9455
Change-Id: I7019d9876b68576274e87c3b2e6bbbf9695522ba
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/269261
Reviewed-by: Austin Eng <enga@google.com>
Reviewed-by: Kenneth Russell <kbr@google.com>
Reviewed-by: Stephen White <senorblanco@chromium.org>
Commit-Queue: Stephen White <senorblanco@chromium.org>
Auto-Submit: Austin Eng <enga@google.com>
