tree bfb1599f49a18557cd5d416c7f8fff67750d71a7
parent 9c2421512e5747c7952601564676bf1fcbb08906
author Christopher Fujino <fujino@google.com> 1655841984 +0000
committer CQ Bot Account <flutter-scoped@luci-project-accounts.iam.gserviceaccount.com> 1655841984 +0000

Reland "Support recovering macOS bots from unsynced ios debug symbols"

This is a reland of commit 9f8c1b9d63be482163379e3c53e62568d7154661
with 4 total retries, each time increasing the timeout duration (the last retry lasting 16 minutes).

Original change's description:
> Support recovering macOS bots from unsynced ios debug symbols
>
> A LED run that actually recovered bot flutter-devicelab-mac-2 https://luci-milo.appspot.com/raw/build/logs.chromium.org/flutter/led/fujino_google.com/11662c93a361a4f7d9cd41e7531d0f635612080296d6caf1a4125507fc5d34d6/+/build.proto
>
> Bug: https://github.com/flutter/flutter/issues/103511
> Change-Id: Ic89b27e25b5267f2c85a47641d7dbb1dc52b5c34
> Reviewed-on: https://flutter-review.googlesource.com/c/recipes/+/31281
> Commit-Queue: Christopher Fujino <fujino@google.com>
> Reviewed-by: Keyong Han <keyonghan@google.com>
> Reviewed-by: Yusuf Mohsinally <mohsinally@google.com>

Bug: https://github.com/flutter/flutter/issues/103511
Change-Id: I330f12fcfdffb1dac959be1e8a58af6daece5961
Reviewed-on: https://flutter-review.googlesource.com/c/recipes/+/31420
Reviewed-by: Keyong Han <keyonghan@google.com>
Commit-Queue: Christopher Fujino <fujino@google.com>
