tree 66a50bba972dd8662c20f5ef0b992218fb9768bb
parent cb40620540db1f21c9efc1990f04434456d06289
author John Stiles <johnstiles@google.com> 1591713837 +0000
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1591713844 +0000

Revert "Add JavaInputStreamAdaptor files into third_party directory."

This reverts commit cf8b723ffdb2334022652a32e69169f97a8967ed.

Reason for revert: reverting and relanding to make the google3
roller happy

Original change's description:
> Add JavaInputStreamAdaptor files into third_party directory.
> 
> This code needs to be migrated out of the main Skia directory due to its
> use of the Apache 2.0 license. A followup CL will remove these files
> from their current home at platform_tools/android/apps/skottie/src/
> main/cpp.
> 
> Change-Id: I939b05afcebb29e1deab1d4ae1b38012f719cf7e
> Bug: skia:10310
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/295082
> Reviewed-by: Ben Wagner <bungeman@google.com>
> Reviewed-by: Weston Tracey <westont@google.com>
> Commit-Queue: John Stiles <johnstiles@google.com>

TBR=bungeman@google.com,westont@google.com,johnstiles@google.com

Change-Id: Ib3cbad92b8c5616735a013d06e3345ac50f78c84
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:10310, skia:10353
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/295200
Reviewed-by: John Stiles <johnstiles@google.com>
Commit-Queue: John Stiles <johnstiles@google.com>
