tree 7158d1a8a2b248062e5d44da912c52d43ad1ad11
parent 81aa20a99d189418dc3639a4026a61bf158098ad
author Andrew Grieve <agrieve@chromium.org> 1506388345 +0000
committer Andrew Grieve <agrieve@chromium.org> 1506388370 +0000

Revert "Add CHROMIUM_CXX_TWEAK_INLINES to reduce binary size"

This reverts commit 81aa20a99d189418dc3639a4026a61bf158098ad.

Reason for revert: Doesn't work in component builds

Original change's description:
> Add CHROMIUM_CXX_TWEAK_INLINES to reduce binary size
> 
> Experimented with std::vector & std::string, and ended up shrinking
> libchrome.so by 728kb (2% of .text)
> 
> Used system health trybots and found no difference in the
> (fairly noisy) metrics:
> https://docs.google.com/document/d/11v5NDuk_CgG7b3rxWdxt-LZu8QDWgfTa3NuWg3i7mmc/edit
> 
> Bug: 738155
> Change-Id: Ib3962e3a9d3ca11c51f4815fa8e26182300a9905
> Reviewed-on: https://chromium-review.googlesource.com/676666
> Reviewed-by: Andrew Grieve <agrieve@chromium.org>
> Tested-by: Andrew Grieve <agrieve@chromium.org>

TBR=agrieve@chromium.org,dskiba@chromium.org,jbudorick@chromium.org

Change-Id: Id3068444193ad148ef9c40dca6c0579430964157
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 738155
Reviewed-on: https://chromium-review.googlesource.com/683554
Reviewed-by: Andrew Grieve <agrieve@chromium.org>
Tested-by: Andrew Grieve <agrieve@chromium.org>
