Use the Errorprone Compiler

build/android/gyp/find_sun_tools_jar.py

+#!/usr/bin/env python
+#
+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""This finds the java distribution's tools.jar and copies it somewhere.
+"""
+
+import optparse
+import os
+import re
+import shutil
+import sys
+
+from util import build_utils
+
+def main(argv):
+  parser = optparse.OptionParser()
+  build_utils.AddDepfileOption(parser)
+  parser.add_option('--output', help='Path to copy the tools.jar to.')

[jbudorick, 2015/05/07 18:49:26]

There has got to be a better way to do this than copying a jar out of the JRE.

[cjhopman, 2015/05/07 19:15:18]

That would be nice. You need to use the tools.jar from the JRE. Then, I really
think you want to have a java_prebuilt/host_prebuilt_jar.gypi for it. To do
that, you need to know the path at gyp/gn time. I can think of a couple ways to
do that:

1. At build time, make sure that the jar is at a specific path. That's this
approach where you copy it into the place you want it.

2. Find it at gyp/gn time and use whatever path it has then. We really want to
avoid doing work like that at gyp/gn time. This also has a problem that it might
be wrong if you change your java version in-between gyp and building (though
that probably breaks other things too).

3. Find it at gclient sync time and copy it into your tree somewhere. This
wouldn't be too bad, but it's not really much better than (1).

4. Find it at gclient sync time and write its path somewhere. Then use that path
at gyp/gn time...

5. Include a jre in our checkout and use that when building. Then you know where
the tools.jar is. This is actually what I think we should be doing and not using
your system one at all... but I definitely wouldn't want to take on that project
for this change.

6. Make java_prebuilt/host_jar_prebuilt.gypi (or new versions of them) that work
with just a build-time string value so that gyp/gn doesn't actually know the
path. I don't know if this is actually possible (I think in gn it would be, but
not in gyp).


Then, another possibility I guess is to not use
java_prebuilt/host_jar_prebuilt.gypi, but I expect that that would get really
complicated... you would essentially have to duplicate all the stuff that those
things already handle for you.

[raywilliams_chromium, 2015/05/11 19:52:24]

From cjhopman's answer, it sounds like this is the least messy way to do it. We
can talk if you still want this to change...

+  options, _ = parser.parse_args(argv)
+
+  # This works with at least openjdk 1.6, 1.7 and sun java 1.6, 1.7
+  stdout = build_utils.CheckOutput(
+      ["java", "-verbose", "-version"], print_stderr=False, print_stdout=False)
+  rt_jar_finder = re.compile(r'\[Opened (.*)/jre/lib/rt.jar\]')
+  sun_tools_jar_path = None
+  for ln in stdout.split('\n'):
+    match = re.match(rt_jar_finder, ln)
+    if match:
+      sun_tools_jar_path = os.path.join(match.group(1), 'lib', 'tools.jar')
+      break
+
+  if sun_tools_jar_path is None:
+    raise Exception('Couldn\'t find tools.jar')
+
+  shutil.copy(sun_tools_jar_path, options.output)
+
+  if options.depfile:
+    build_utils.WriteDepfile(
+        options.depfile,
+        [sun_tools_jar_path] + build_utils.GetPythonDependencies())
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))