tree 48c5d20b976b482b52180bc77bd41c79e8f05961
parent 1983734c5962f1253a3ae0d68e408ea75fb6576a
author Leandro Lovisolo <lovisolo@google.com> 1617835296 -0400
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1617836727 +0000

//Makefile: Use a specific revision of the puppeteer-tests Docker image.

Currently the puppeteer-tests Make target uses the image tagged with "latest", which might lead to unintended screenshot differences in Gold if a developer pushes a new image to GCR during development.

This CL pins the image version to the one that is currently tagged with "latest".

In follow-up CLs, I will update the puppeteer-tests and RBE toolchain container images to use the same versions of Chrome and any other necessary assets. This will hopefully reduce diffs between screenshots produced via Webpack vs. Bazel, which is important to judge the correctness of our Bazel build.

Bug: skia:10614
Change-Id: I0c096a93d6afea519fe2aec25f40632aa0a834af
Reviewed-on: https://skia-review.googlesource.com/c/buildbot/+/393716
Reviewed-by: Leandro Lovisolo <lovisolo@google.com>
Commit-Queue: Leandro Lovisolo <lovisolo@google.com>
