tree 6a0bf33b7ec86bcc0e7bcdfa0d5ce9d7fc13561c
parent 74c6ffb74c1f66c726a40ffa516ecc6438c90933
author khushalsagar <khushalsagar@chromium.org> 1467143728 -0700
committer Commit bot <commit-bot@chromium.org> 1467143824 +0000

Revert of Refactor //tools/gn/bin/gyp_flag_compare.py to be usable in interactive Python. (patchset #1 id:1 of https://codereview.chromium.org/2108683002/ )

Reason for revert:
A significant number of bots are broken after this landed. This is a speculative revert. Please re-land in case this was not the error.

Original issue's description:
> Refactor //tools/gn/bin/gyp_flag_compare.py to be usable in interactive Python.
>
> When comparing large targets like //chrome, it is nearly impossible to deal with
> the mountainous 46,000 lines of output the executable script produces. With an
> interactive environment, it is much easier to compare differences and drill-down
> into specific issues.
>
> BUG=622889
> R=scottmg@chromium.org
>
> Committed: https://chromium.googlesource.com/chromium/src/+/9f1375ea1bfb9f35e48b69f4c10c8ffa3233ca2a

TBR=scottmg@chromium.org,rsesek@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=622889

Review-Url: https://codereview.chromium.org/2104083002
Cr-Original-Commit-Position: refs/heads/master@{#402514}
Cr-Mirrored-From: https://chromium.googlesource.com/chromium/src
Cr-Mirrored-Commit: 74af4d66235496370bd173c6139314e8adfecb2e
