jni_generator: remove obsolete/unused features.

base/android/jni_generator/jni_generator.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
 If you change this, please run and update the tests."""
 
 import collections
 import errno
@@ skipping 159 matching lines @@
       'void': ''
   }
   return java_pod_type_map.get(java_type, 'NULL')
 
 
 class JniParams(object):
   _imports = []
   _fully_qualified_class = ''
   _package = ''
   _inner_classes = []
-  _remappings = []
   _implicit_imports = []
 
   @staticmethod
   def SetFullyQualifiedClass(fully_qualified_class):
     JniParams._fully_qualified_class = 'L' + fully_qualified_class
     JniParams._package = '/'.join(fully_qualified_class.split('/')[:-1])
 
   @staticmethod
   def AddAdditionalImport(class_name):
     assert class_name.endswith('.class')
@@ skipping 70 matching lines @@
     while param[-2:] == '[]':
       prefix += '['
       param = param[:-2]
     # Generic?
     if '<' in param:
       param = param[:param.index('<')]
     if param in pod_param_map:
       return prefix + pod_param_map[param]
     if '/' in param:
       # Coming from javap, use the fully qualified param directly.
-      return prefix + 'L' + JniParams.RemapClassName(param) + ';'
+      return prefix + 'L' + param + ';'
 
     for qualified_name in (object_param_list +
                            [JniParams._fully_qualified_class] +
                            JniParams._inner_classes):
       if (qualified_name.endswith('/' + param) or
           qualified_name.endswith('$' + param.replace('.', '$')) or
           qualified_name == 'L' + param):
-        return prefix + JniParams.RemapClassName(qualified_name) + ';'
+        return prefix + qualified_name + ';'
 
     # Is it from an import? (e.g. referecing Class from import pkg.Class;
     # note that referencing an inner class Inner from import pkg.Class.Inner
     # is not supported).
     for qualified_name in JniParams._imports:
       if qualified_name.endswith('/' + param):
         # Ensure it's not an inner class.
         components = qualified_name.split('/')
         if len(components) > 2 and components[-2][0].isupper():
           raise SyntaxError('Inner class (%s) can not be imported '
                             'and used by JNI (%s). Please import the outer '
                             'class and use Outer.Inner instead.' %
                             (qualified_name, param))
-        return prefix + JniParams.RemapClassName(qualified_name) + ';'
+        return prefix + qualified_name + ';'
 
     # Is it an inner class from an outer class import? (e.g. referencing
     # Class.Inner from import pkg.Class).
     if '.' in param:
       components = param.split('.')
       outer = '/'.join(components[:-1])
       inner = components[-1]
       for qualified_name in JniParams._imports:
         if qualified_name.endswith('/' + outer):
-          return (prefix + JniParams.RemapClassName(qualified_name) +
-                  '$' + inner + ';')
+          return (prefix + qualified_name + '$' + inner + ';')
       raise SyntaxError('Inner class (%s) can not be '
                         'used directly by JNI. Please import the outer '
                         'class, probably:\n'
                         'import %s.%s;' %
                         (param, JniParams._package.replace('/', '.'),
                          outer.replace('/', '.')))
 
     JniParams._CheckImplicitImports(param)
 
     # Type not found, falling back to same package as this class.
-    return (prefix + 'L' +
-            JniParams.RemapClassName(JniParams._package + '/' + param) + ';')
+    return (prefix + 'L' + JniParams._package + '/' + param + ';')
 
   @staticmethod
   def _CheckImplicitImports(param):
     # Ensure implicit imports, such as java.lang.*, are not being treated
     # as being in the same package.
     if not JniParams._implicit_imports:
       # This file was generated from android.jar and lists
       # all classes that are implicitly imported.
       with file(os.path.join(os.path.dirname(sys.argv[0]),
                              'android_jar.classes'), 'r') as f:
@@ skipping 30 matching lines @@
       items = p.split(' ')
       if 'final' in items:
         items.remove('final')
       param = Param(
           datatype=items[0],
           name=(items[1] if len(items) > 1 else 'p%s' % len(ret)),
       )
       ret += [param]
     return ret
 
-  @staticmethod
-  def RemapClassName(class_name):
-    """Remaps class names using the jarjar mapping table."""
-    for old, new in JniParams._remappings:
-      if old.endswith('**') and old[:-2] in class_name:
-        return class_name.replace(old[:-2], new, 1)
-      if '*' not in old and class_name.endswith(old):
-        return class_name.replace(old, new, 1)
-
-    return class_name
-
-  @staticmethod
-  def SetJarJarMappings(mappings):
-    """Parse jarjar mappings from a string."""
-    JniParams._remappings = []
-    for line in mappings.splitlines():
-      rule = line.split()
-      if rule[0] != 'rule':
-        continue
-      _, src, dest = rule
-      src = src.replace('.', '/')
-      dest = dest.replace('.', '/')
-      if src.endswith('**'):
-        src_real_name = src[:-2]
-      else:
-        assert not '*' in src
-        src_real_name = src
-
-      if dest.endswith('@0'):
-        JniParams._remappings.append((src, dest[:-2] + src_real_name))
-      elif dest.endswith('@1'):
-        assert '**' in src
-        JniParams._remappings.append((src, dest[:-2]))
-      else:
-        assert not '@' in dest
-        JniParams._remappings.append((src, dest))
-
 
 def ExtractJNINamespace(contents):
   re_jni_namespace = re.compile('.*?@JNINamespace\("(.*?)"\)')
   m = re.findall(re_jni_namespace, contents)
   if not m:
     return ''
   return m[0]
 
 
 def ExtractFullyQualifiedJavaClassName(java_file_name, contents):
@@ skipping 322 matching lines @@
   def __init__(self, namespace, fully_qualified_class, natives,
                called_by_natives, constant_fields, options):
     self.namespace = namespace
     self.fully_qualified_class = fully_qualified_class
     self.class_name = self.fully_qualified_class.split('/')[-1]
     self.natives = natives
     self.called_by_natives = called_by_natives
     self.header_guard = fully_qualified_class.replace('/', '_') + '_JNI'
     self.constant_fields = constant_fields
     self.options = options
-    self.init_native = self.ExtractInitNative(options)
 
-  def ExtractInitNative(self, options):
-    for native in self.natives:
-      if options.jni_init_native_name == 'native' + native.name:
-        self.natives.remove(native)
-        return native
-    return None
 
   def GetContent(self):
     """Returns the content of the JNI binding file."""
     template = Template("""\
 // 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 file is autogenerated by
 //     ${SCRIPT_NAME}
 // For
 //     ${FULLY_QUALIFIED_CLASS}
 
 #ifndef ${HEADER_GUARD}
 #define ${HEADER_GUARD}
 
 #include <jni.h>
 
 ${INCLUDES}
 
 #include "base/android/jni_int_wrapper.h"
 
 // Step 1: forward declarations.
 namespace {
 $CLASS_PATH_DEFINITIONS
-$METHOD_ID_DEFINITIONS
+
 }  // namespace
 
 $OPEN_NAMESPACE
 
 $CONSTANT_FIELDS
 
 // Step 2: method stubs.
 $METHOD_STUBS
 
 // Step 3: RegisterNatives.
 $JNI_NATIVE_METHODS
 $REGISTER_NATIVES
 $CLOSE_NAMESPACE
-$JNI_REGISTER_NATIVES
+
 #endif  // ${HEADER_GUARD}
 """)
     values = {
         'SCRIPT_NAME': self.options.script_name,
         'FULLY_QUALIFIED_CLASS': self.fully_qualified_class,
         'CLASS_PATH_DEFINITIONS': self.GetClassPathDefinitionsString(),
-        'METHOD_ID_DEFINITIONS': self.GetMethodIDDefinitionsString(),
         'CONSTANT_FIELDS': self.GetConstantFieldsString(),
         'METHOD_STUBS': self.GetMethodStubsString(),
         'OPEN_NAMESPACE': self.GetOpenNamespaceString(),
         'JNI_NATIVE_METHODS': self.GetJNINativeMethodsString(),
         'REGISTER_NATIVES': self.GetRegisterNativesString(),
         'CLOSE_NAMESPACE': self.GetCloseNamespaceString(),
         'HEADER_GUARD': self.header_guard,
         'INCLUDES': self.GetIncludesString(),
-        'JNI_REGISTER_NATIVES': self.GetJNIRegisterNativesString()
     }
     return WrapOutput(template.substitute(values))
 
   def GetClassPathDefinitionsString(self):
     ret = []
     ret += [self.GetClassPathDefinitions()]
     return '\n'.join(ret)
 
-  def GetMethodIDDefinitionsString(self):
-    """Returns the definition of method ids for the called by native methods."""
-    if not self.options.eager_called_by_natives:
-      return ''
-    template = Template("""\
-jmethodID g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = NULL;""")
-    ret = []
-    for called_by_native in self.called_by_natives:
-      values = {
-          'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
-          'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
-      }
-      ret += [template.substitute(values)]
-    return '\n'.join(ret)
-
   def GetConstantFieldsString(self):
     if not self.constant_fields:
       return ''
     ret = ['enum Java_%s_constant_fields {' % self.class_name]
     for c in self.constant_fields:
       ret += ['  %s = %s,' % (c.name, c.value)]
     ret += ['};']
     return '\n'.join(ret)
 
   def GetMethodStubsString(self):
     """Returns the code corresponding to method stubs."""
     ret = []
     for native in self.natives:
       ret += [self.GetNativeStub(native)]
-    if self.options.eager_called_by_natives:
-      ret += self.GetEagerCalledByNativeMethodStubs()
-    else:
-      ret += self.GetLazyCalledByNativeMethodStubs()
+    ret += self.GetLazyCalledByNativeMethodStubs()
     return '\n'.join(ret)
 
   def GetLazyCalledByNativeMethodStubs(self):
     return [self.GetLazyCalledByNativeMethodStub(called_by_native)
             for called_by_native in self.called_by_natives]
 
-  def GetEagerCalledByNativeMethodStubs(self):
-    ret = []
-    if self.called_by_natives:
-      ret += ['namespace {']
-      for called_by_native in self.called_by_natives:
-        ret += [self.GetEagerCalledByNativeMethodStub(called_by_native)]
-      ret += ['}  // namespace']
-    return ret
-
   def GetIncludesString(self):
     if not self.options.includes:
       return ''
     includes = self.options.includes.split(',')
     return '\n'.join('#include "%s"' % x for x in includes)
 
   def GetKMethodsString(self, clazz):
     ret = []
     for native in self.natives:
       if (native.java_class_name == clazz or
@@ skipping 19 matching lines @@
     """Returns the implementation of the array of native methods."""
     if self.options.native_exports and not self.options.native_exports_optional:
       return ''
     template = Template("""\
 static const JNINativeMethod kMethods${JAVA_CLASS}[] = {
 ${KMETHODS}
 };
 """)
     return self.SubstituteNativeMethods(template)
 
-  def GetRegisterCalledByNativesImplString(self):
-    """Returns the code for registering the called by native methods."""
-    if not self.options.eager_called_by_natives:
-      return ''
-    template = Template("""\
-  g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = ${GET_METHOD_ID_IMPL}
-  if (g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} == NULL) {
-    return false;
-  }
-    """)
-    ret = []
-    for called_by_native in self.called_by_natives:
-      values = {
-          'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
-          'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
-          'GET_METHOD_ID_IMPL': self.GetMethodIDImpl(called_by_native),
-      }
-      ret += [template.substitute(values)]
-    return '\n'.join(ret)
-
   def GetRegisterNativesString(self):
     """Returns the code for RegisterNatives."""
     template = Template("""\
 ${REGISTER_NATIVES_SIGNATURE} {
 ${EARLY_EXIT}
 ${CLASSES}
 ${NATIVES}
-${CALLED_BY_NATIVES}
   return true;
 }
 """)
-    signature = 'static bool RegisterNativesImpl(JNIEnv* env'
-    if self.init_native:
-      signature += ', jclass clazz)'
-    else:
-      signature += ')'
-
+    signature = 'static bool RegisterNativesImpl(JNIEnv* env)'
     early_exit = ''
     if self.options.native_exports_optional:
       early_exit = """\
   if (base::android::IsManualJniRegistrationDisabled()) return true;
 """
 
     natives = self.GetRegisterNativesImplString()
-    called_by_natives = self.GetRegisterCalledByNativesImplString()
     values = {'REGISTER_NATIVES_SIGNATURE': signature,
               'EARLY_EXIT': early_exit,
               'CLASSES': self.GetFindClasses(),
               'NATIVES': natives,
-              'CALLED_BY_NATIVES': called_by_natives,
              }
     return template.substitute(values)
 
   def GetRegisterNativesImplString(self):
     """Returns the shared implementation for RegisterNatives."""
     if self.options.native_exports and not self.options.native_exports_optional:
       return ''
 
     template = Template("""\
   const int kMethods${JAVA_CLASS}Size = arraysize(kMethods${JAVA_CLASS});
 
   if (env->RegisterNatives(${JAVA_CLASS}_clazz(env),
                            kMethods${JAVA_CLASS},
                            kMethods${JAVA_CLASS}Size) < 0) {
     jni_generator::HandleRegistrationError(
         env, ${JAVA_CLASS}_clazz(env), __FILE__);
     return false;
   }
 """)
     return self.SubstituteNativeMethods(template)
 
-  def GetJNIRegisterNativesString(self):
-    """Returns the implementation for the JNI registration of native methods."""
-    if not self.init_native:
-      return ''
-
-    template = Template("""\
-extern "C" JNIEXPORT bool JNICALL
-Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) {
-  return ${NAMESPACE}RegisterNativesImpl(env, clazz);
-}
-""")
-
-    if self.options.native_exports:
-      java_name = JniParams.RemapClassName(self.fully_qualified_class)
-      java_name = java_name.replace('_', '_1').replace('/', '_')
-    else:
-      java_name = self.fully_qualified_class.replace('/', '_')
-
-    namespace = ''
-    if self.namespace:
-      namespace = self.namespace + '::'
-    values = {'FULLY_QUALIFIED_CLASS': java_name,
-              'INIT_NATIVE_NAME': 'native' + self.init_native.name,
-              'NAMESPACE': namespace,
-              'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString()
-             }
-    return template.substitute(values)
-
   def GetOpenNamespaceString(self):
     if self.namespace:
       all_namespaces = ['namespace %s {' % ns
                         for ns in self.namespace.split('::')]
       return '\n'.join(all_namespaces)
     return ''
 
   def GetCloseNamespaceString(self):
     if self.namespace:
       all_namespaces = ['}  // namespace %s' % ns
@@ skipping 55 matching lines @@
     """Return the name of the stub function for this native method.
 
     Args:
       native: the native dictionary describing the method.
 
     Returns:
       A string with the stub function name (used by the JVM).
     """
     template = Template("Java_${JAVA_NAME}_native${NAME}")
 
-    java_name = JniParams.RemapClassName(self.fully_qualified_class)
-    java_name = java_name.replace('_', '_1').replace('/', '_')
+    java_name = self.fully_qualified_class.replace('_', '_1').replace('/', '_')
     if native.java_class_name:
       java_name += '_00024' + native.java_class_name
 
     values = {'NAME': native.name,
               'JAVA_NAME': java_name}
     return template.substitute(values)
 
   def GetJavaParamRefForCall(self, c_type, name):
     return Template('JavaParamRef<${TYPE}>(env, ${NAME})').substitute({
         'TYPE': c_type,
         'NAME': name,
     })
 
   def GetJNIFirstParamForCall(self, native):
     c_type = self.GetJNIFirstParamType(native)
     return [self.GetJavaParamRefForCall(c_type, 'jcaller')]
 
   def GetNativeStub(self, native):
     is_method = native.type == 'method'
 
     if is_method:
       params = native.params[1:]
     else:
       params = native.params
-    params_in_call = []
-    if not self.options.pure_native_methods:
-      params_in_call = ['env'] + self.GetJNIFirstParamForCall(native)
+    params_in_call = ['env'] + self.GetJNIFirstParamForCall(native)
     for p in params:
       c_type = JavaDataTypeToC(p.datatype)
       if re.match(RE_SCOPED_JNI_TYPES, c_type):
         params_in_call.append(self.GetJavaParamRefForCall(c_type, p.name))
       else:
         params_in_call.append(p.name)
     params_in_call = ', '.join(params_in_call)
 
     if self.options.native_exports:
       stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
@@ skipping 101 matching lines @@
         'PRE_CALL': pre_call,
         'POST_CALL': post_call,
         'ENV_CALL': called_by_native.env_call,
         'FIRST_PARAM_IN_CALL': first_param_in_call,
         'PARAMS_IN_CALL': params_in_call,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'CHECK_EXCEPTION': check_exception,
         'GET_METHOD_ID_IMPL': self.GetMethodIDImpl(called_by_native)
     }
 
-  def GetEagerCalledByNativeMethodStub(self, called_by_native):
-    """Returns the implementation of the called by native method."""
-    template = Template("""
-static ${RETURN_TYPE} ${METHOD_ID_VAR_NAME}(\
-JNIEnv* env${FIRST_PARAM_IN_DECLARATION}${PARAMS_IN_DECLARATION}) {
-  ${RETURN_DECLARATION}${PRE_CALL}env->${ENV_CALL}(${FIRST_PARAM_IN_CALL},
-      g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}${PARAMS_IN_CALL})${POST_CALL};
-  ${RETURN_CLAUSE}
-}""")
-    values = self.GetCalledByNativeValues(called_by_native)
-    return template.substitute(values)
 
   def GetLazyCalledByNativeMethodStub(self, called_by_native):
     """Returns a string."""
     function_signature_template = Template("""\
 static ${RETURN_TYPE} Java_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}(\
 JNIEnv* env${FIRST_PARAM_IN_DECLARATION}${PARAMS_IN_DECLARATION})""")
     function_header_template = Template("""\
 ${FUNCTION_SIGNATURE} {""")
     function_header_with_unused_template = Template("""\
 ${FUNCTION_SIGNATURE} __attribute__ ((unused));
@@ skipping 52 matching lines @@
     called_by_native_classes = self.GetUniqueClasses(self.called_by_natives)
     if self.options.native_exports:
       all_classes = called_by_native_classes
     else:
       all_classes = native_classes
       all_classes.update(called_by_native_classes)
 
     for clazz in all_classes:
       values = {
           'JAVA_CLASS': clazz,
-          'JNI_CLASS_PATH': JniParams.RemapClassName(all_classes[clazz]),
+          'JNI_CLASS_PATH': all_classes[clazz],
       }
       ret += [template.substitute(values)]
     ret += ''
 
     class_getter_methods = []
     if self.options.native_exports:
       template = Template("""\
 // Leaking this jclass as we cannot use LazyInstance from some threads.
 base::subtle::AtomicWord g_${JAVA_CLASS}_clazz __attribute__((unused)) = 0;
 #define ${JAVA_CLASS}_clazz(env) \
 base::android::LazyGetClass(env, k${JAVA_CLASS}ClassPath, \
 &g_${JAVA_CLASS}_clazz)""")
     else:
       template = Template("""\
 // Leaking this jclass as we cannot use LazyInstance from some threads.
 jclass g_${JAVA_CLASS}_clazz = NULL;
 #define ${JAVA_CLASS}_clazz(env) g_${JAVA_CLASS}_clazz""")
 
     for clazz in called_by_native_classes:
       values = {
           'JAVA_CLASS': clazz,
       }
       ret += [template.substitute(values)]
 
     return '\n'.join(ret)
 
   def GetFindClasses(self):
     """Returns the imlementation of FindClass for all known classes."""
-    if self.init_native:
-      if self.options.native_exports:
-        template = Template("""\
-  base::subtle::Release_Store(&g_${JAVA_CLASS}_clazz,
-      static_cast<base::subtle::AtomicWord>(env->NewWeakGlobalRef(clazz));""")
-      else:
-        template = Template("""\
-  g_${JAVA_CLASS}_clazz = static_cast<jclass>(env->NewWeakGlobalRef(clazz));""")
-    else:
-      if self.options.native_exports:
-        return '\n'
-      template = Template("""\
+    if self.options.native_exports:
+      return '\n'
+    template = Template("""\
   g_${JAVA_CLASS}_clazz = reinterpret_cast<jclass>(env->NewGlobalRef(
       base::android::GetClass(env, k${JAVA_CLASS}ClassPath).obj()));""")
     ret = []
     for clazz in self.GetUniqueClasses(self.called_by_natives):
       values = {'JAVA_CLASS': clazz}
       ret += [template.substitute(values)]
     return '\n'.join(ret)
 
   def GetMethodIDImpl(self, called_by_native):
     """Returns the implementation of GetMethodID."""
-    if self.options.eager_called_by_natives:
-      template = Template("""\
-env->Get${STATIC_METHOD_PART}MethodID(
-      ${JAVA_CLASS}_clazz(env),
-      "${JNI_NAME}", ${JNI_SIGNATURE});""")
-    else:
-      template = Template("""\
+    template = Template("""\
   base::android::MethodID::LazyGet<
       base::android::MethodID::TYPE_${STATIC}>(
       env, ${JAVA_CLASS}_clazz(env),
       "${JNI_NAME}",
       ${JNI_SIGNATURE},
       &g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
 """)
     jni_name = called_by_native.name
     jni_return_type = called_by_native.return_type
     if called_by_native.is_constructor:
       jni_name = '<init>'
       jni_return_type = 'void'
     if called_by_native.signature:
       signature = called_by_native.signature
     else:
       signature = JniParams.Signature(called_by_native.params,
                                       jni_return_type,
                                       True)
     values = {
         'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
         'JNI_NAME': jni_name,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'STATIC': 'STATIC' if called_by_native.static else 'INSTANCE',
-        'STATIC_METHOD_PART': 'Static' if called_by_native.static else '',
         'JNI_SIGNATURE': signature,
     }
     return template.substitute(values)
 
 
 def WrapOutput(output):
   ret = []
   for line in output.splitlines():
     # Do not wrap lines under 80 characters or preprocessor directives.
     if len(line) < 80 or line.lstrip()[:1] == '#':
@@ skipping 101 matching lines @@
                            help='Single input file name. The output file name '
                            'will be derived from it. Must be used with '
                            '--output_dir.')
   option_parser.add_option('--output_dir',
                            help='The output directory. Must be used with '
                            '--input')
   option_parser.add_option('--optimize_generation', type="int",
                            default=0, help='Whether we should optimize JNI '
                            'generation by not regenerating files if they have '
                            'not changed.')
-  option_parser.add_option('--jarjar',
-                           help='Path to optional jarjar rules file.')
   option_parser.add_option('--script_name', default=GetScriptName(),
                            help='The name of this script in the generated '
                            'header.')
   option_parser.add_option('--includes',
                            help='The comma-separated list of header files to '
                            'include in the generated header.')
-  option_parser.add_option('--pure_native_methods',
-                           action='store_true', dest='pure_native_methods',
-                           help='When true, the native methods will be called '
-                           'without any JNI-specific arguments.')
   option_parser.add_option('--ptr_type', default='int',
                            type='choice', choices=['int', 'long'],
                            help='The type used to represent native pointers in '
                            'Java code. For 32-bit, use int; '
                            'for 64-bit, use long.')
-  option_parser.add_option('--jni_init_native_name', default='',
-                           help='The name of the JNI registration method that '
-                           'is used to initialize all native methods. If a '
-                           'method with this name is not present in the Java '
-                           'source file, setting this option is a no-op. When '
-                           'a method with this name is found however, the '
-                           'naming convention Java_<packageName>_<className> '
-                           'will limit the initialization to only the '
-                           'top-level class.')
-  option_parser.add_option('--eager_called_by_natives',
-                           action='store_true', dest='eager_called_by_natives',
-                           help='When true, the called-by-native methods will '
-                           'be initialized in a non-atomic way.')
   option_parser.add_option('--cpp', default='cpp',
                            help='The path to cpp command.')
   option_parser.add_option('--javap', default='javap',
                            help='The path to javap command.')
   option_parser.add_option('--native_exports', action='store_true',
                            help='Native method registration through .so '
                            'exports.')
   option_parser.add_option('--native_exports_optional', action='store_true',
                            help='Support both explicit and native method'
                            'registration.')
   options, args = option_parser.parse_args(argv)
   if options.native_exports_optional:
     options.native_exports = True
   if options.jar_file:
     input_file = ExtractJarInputFile(options.jar_file, options.input_file,
                                      options.output_dir)
   elif options.input_file:
     input_file = options.input_file
   else:
     option_parser.print_help()
     print '\nError: Must specify --jar_file or --input_file.'
     return 1
   output_file = None
   if options.output_dir:
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
-  if options.jarjar:
-    with open(options.jarjar) as f:
-      JniParams.SetJarJarMappings(f.read())
   GenerateJNIHeader(input_file, output_file, options)
 
   if options.depfile:
     build_utils.WriteDepfile(
         options.depfile,
         build_utils.GetPythonDependencies())
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))