tree 53b9fcfdcffaaccc9b0b0c170e00b9a317daa6f1
parent 5ef0e71ecd405bea41f7173df9bc7dc69186dc42
author Scott Graham <scottmg@google.com> 1594259854 +0000
committer CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org> 1594259854 +0000

Revert "[check] gn gen --check -> gn gen --check=system"

This reverts commit 08f0b15d72c8c5479ede74ab671bbea105ca5750.

Reason for revert:

Oops, I missed some --check=system in bringup that the recipe side is failing on, so I'm going to revert this until I fix those because otherwise people won't be able to fx set some bringup configs in the meantime.

Original change's description:
> [check] gn gen --check -> gn gen --check=system
> 
> Be stricter.
> See: `gn help check`
> See: https://fuchsia-review.googlesource.com/c/infra/recipes/+/404874
> 
> Bug: 55166
> 
> Change-Id: I0cb95f565a05cc3c29127b767b32d6565e0b2bab
> Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/404809
> Commit-Queue: Shai Barack <shayba@google.com>
> Reviewed-by: Scott Graham <scottmg@google.com>
> Reviewed-by: P.Y. Laligand <pylaligand@google.com>
> Testability-Review: Scott Graham <scottmg@google.com>

TBR=pylaligand@google.com,scottmg@google.com,shayba@google.com,nmulcahey@google.com

Change-Id: Ica62b8361531ed9c5259acd404ab84a3b89fdf7f
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 55166
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/405516
Reviewed-by: Scott Graham <scottmg@google.com>
Commit-Queue: Scott Graham <scottmg@google.com>
