tree 9cdda6d56633d84b2ff82a2e033a2a53467d9f11
parent 878cd3a3f8a6c94571bbc3a2cac7afeeb4bc274e
author Ben Konyi <bkonyi@google.com> 1628098358 +0000
committer commit-bot@chromium.org <commit-bot@chromium.org> 1628098358 +0000

Revert "Reland "[ package:dds ] Add support for caching CPU samples based on UserTag""

This reverts commit 17961606060fa36971fdc40cee8105a13262e97e.

Reason for revert: Still seeing failures.

Original change's description:
> Reland "[ package:dds ] Add support for caching CPU samples based on UserTag"
>
> This reverts commit 4160747ef63d4a7071242b50382a2b8f3c559d1f.
>
> It seems like 9397b8ff055b3b97275e17aaf651bbb176b2b306 should have fixed the original failures we were seeing and the failing bots in question seem to be passing when running try jobs.
>
> TBR=asiva@ (discussed offline)
>
> TEST=Existing service tests + get_cached_cpu_samples_test
> Change-Id: I1c50c0e79375df819a0bd68e68ac28c3064874c8
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/208441
> Reviewed-by: Ben Konyi <bkonyi@google.com>
> Commit-Queue: Ben Konyi <bkonyi@google.com>

TBR=bkonyi@google.com,asiva@google.com

Change-Id: Ic522ab61b430673533c94ecd0c91bee569a0add6
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/208960
Reviewed-by: Ben Konyi <bkonyi@google.com>
Commit-Queue: Ben Konyi <bkonyi@google.com>
