tree 5738e1d013e8c4926090c42c4fd548798b9bf014
parent ebd4fc3556ca3127f05ba86d1add3096874537cf
author Brian Sheedy <bsheedy@chromium.org> 1604001396 -0700
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1604004367 +0000

[gold] Fix CL redirection with corpus

Changes the CL redirection handler to use &corpus= instead of
&query=source_type%3D when redirecting to a particular corpus. The
former appears to work correctly, while the latter just goes to the
default corpus. See the associated bug for concrete example links.

Bug: chromium:1143797
Change-Id: I09b1a2e0b98bcd6058f56046665c64c8d86de218
Reviewed-on: https://skia-review.googlesource.com/c/buildbot/+/330579
Reviewed-by: Leandro Lovisolo <lovisolo@google.com>
Commit-Queue: Leandro Lovisolo <lovisolo@google.com>
