tree 7a6b8ada76d0cfafa2a910b1a046d0feeceaa6b5
parent 97bdc453fbedee92ed0fc7687544098efc821622
author Daniel Cheng <dcheng@chromium.org> 1692895805 -0700
committer swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com <swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com> 1692904199 +0000

Don't spam stdout when `git describe` fails.

Currently, a successful Chrome build always prints something like:

  Failed to run "['git', 'describe']" in
  ".../src/third_party/swiftshader/third_party/SPIRV-Tools":
  fatal: No names found, cannot describe anything.

However, it is expected that this command may fail when trying to update
the build version. Don't spam stdout because there's a fallback and this
is not actually a fatal error.

Bug: chromium:1475701
Change-Id: Ie0234b6a6862c9de67246f89333eaa37bdafde1f
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/72288
Commit-Queue: Geoff Lang <geofflang@google.com>
Tested-by: Geoff Lang <geofflang@google.com>
Reviewed-by: Geoff Lang <geofflang@google.com>
