tree 1d014a70126c990da9bb204c6a01283e600e7959
parent 91d7d1d4ac7ca5e27f6caff24bed943baa9a3493
author Mike Reed <reed@google.com> 1498484788 +0000
committer Mike Reed <reed@google.com> 1498485202 +0000

Revert "remove a bit more dead code"

This reverts commit d9b1fe02a677ec44bc1c99809f3ee7eb08708137.

Reason for revert: try to fix chrome roll

Original change's description:
> remove a bit more dead code
> 
> Change-Id: I61484672e88d6bb4f75833ee89e7178c4f34d610
> Reviewed-on: https://skia-review.googlesource.com/20780
> Commit-Queue: Mike Klein <mtklein@google.com>
> Reviewed-by: Herb Derby <herb@google.com>

TBR=mtklein@chromium.org,mtklein@google.com,herb@google.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Change-Id: I03dcd344dfb138261d9421b0692d12e4ed431100
Reviewed-on: https://skia-review.googlesource.com/20822
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
