tree e46f868328793596643aa94820dbd1e05f63b65c
parent 30390c6ba1909c64a02b8c6d27a34e3ed4f44da1
author Samir Jindel <sjindel@google.com> 1559841179 +0000
committer commit-bot@chromium.org <commit-bot@chromium.org> 1559841179 +0000

Revert "[vm/ffi] Regression test for dartbug.com/36993"

This reverts commit e1a7ef52afbbf4d8978508aa9bec554e88866a21.

Reason for revert:
Caused crash on cross-vm-linux-release-arm64: https://ci.chromium.org/p/dart/builders/ci.sandbox/cross-vm-linux-release-arm64/2036

Original change's description:
> [vm/ffi] Regression test for dartbug.com/36993
> 
> Follow up of: https://dart-review.googlesource.com/c/sdk/+/103136
> Bug: https://github.com/dart-lang/sdk/issues/36993
> Change-Id: Ib5e8308b91b9b5ce5b95362dd79d12e79499a75c
> Cq-Include-Trybots: luci.dart.try:vm-ffi-android-debug-arm-try, app-kernel-linux-debug-x64-try, vm-kernel-linux-debug-simdbc64-try,vm-kernel-mac-debug-simdbc64-try,vm-kernel-reload-mac-debug-simdbc64-try,vm-kernel-linux-debug-ia32-try,vm-dartkb-linux-debug-simarm64-try,vm-kernel-win-debug-x64-try
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/104820
> Commit-Queue: Daco Harkes <dacoharkes@google.com>
> Reviewed-by: Samir Jindel <sjindel@google.com>
> Auto-Submit: Daco Harkes <dacoharkes@google.com>

TBR=sjindel@google.com,dacoharkes@google.com

Change-Id: I51cb94dc4a6046bedb6be0580d0092010992c684
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: https://github.com/dart-lang/sdk/issues/36993
Cq-Include-Trybots: luci.dart.try:vm-ffi-android-debug-arm-try, app-kernel-linux-debug-x64-try, vm-kernel-linux-debug-simdbc64-try, vm-kernel-mac-debug-simdbc64-try, vm-kernel-reload-mac-debug-simdbc64-try, vm-kernel-linux-debug-ia32-try, vm-dartkb-linux-debug-simarm64-try, vm-kernel-win-debug-x64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/105301
Reviewed-by: Samir Jindel <sjindel@google.com>
Commit-Queue: Samir Jindel <sjindel@google.com>
