tree 8b5c349511d344f9ca2abec6413060c583305537
parent 329c5bc7b2f6fda2f491c66d043dd71c7d6b1796
author Yunlian Jiang <yunlian@chromium.org> 1539705744 +0000
committer chrome-bot <chrome-bot@chromium.org> 1539780911 -0700

Revert "ebuild: hack the chost check for armv7a-cros-linux-gnueabihf"

This reverts commit 329c5bc7b2f6fda2f491c66d043dd71c7d6b1796.

Reason for revert: We have finished the transition for all the live board and we just cleared the prebuilts, so this can be reverted now.

Original change's description:
> ebuild: hack the chost check for armv7a-cros-linux-gnueabihf
>
> We are in the process of rename armv7a-cros-linux-gnueabi to
> armv7a-cros-linux-gnueabihf. See crbug.com/711369
> We created two sets to toolchains, namely armv7a-cros-linux-gnueabi
> and armv7a-cros-linux-gnueabihf, they are basically then same with
> different names.
> When changing the CHOST for one board from armv7a-cros-linux-gnueabi
> to armv7a-cros-linux-gnueabihf, it failed on pre-cq. Because in the
> build_package stage, it calls function VerifyBinpkg to verify that
> an binary package exists for chromeos-chrome. The check requires the
> CHOST from board configure and prebuilt packages are the same, and the
> change broke that.
> This patch silence the error to make pre-cq pass.
>
> BUG=chromium:711369
> TEST=emerge-daisy -G zlib succeeded with new CHOST set.
>
> Change-Id: I6ae231ebc663b2afc0c3773418258daa4f78d984
> Reviewed-on: https://chromium-review.googlesource.com/1055211
> Commit-Ready: Yunlian Jiang <yunlian@chromium.org>
> Tested-by: Yunlian Jiang <yunlian@chromium.org>
> Reviewed-by: Yunlian Jiang <yunlian@chromium.org>
> Reviewed-by: Mike Frysinger <vapier@chromium.org>

Bug: chromium:711369
Change-Id: I2480113073fe5e15d5ed2f2ea96f05c8e9538b9d
Reviewed-on: https://chromium-review.googlesource.com/1283434
Commit-Ready: Yunlian Jiang <yunlian@chromium.org>
Tested-by: Yunlian Jiang <yunlian@chromium.org>
Reviewed-by: Mike Frysinger <vapier@chromium.org>
