Android Allows nested namespace in @JNINamespace annotation.

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.
 
 # TODO (qinmin): Need to refactor this file as base should not know about
 # higher level concepts. Currently this file has knowledge about higher level
 # java classes.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
@@ skipping 532 matching lines @@
     script_components = os.path.abspath(sys.argv[0]).split(os.path.sep)
     base_index = script_components.index('base')
     script_name = os.sep.join(script_components[base_index:])
     values = {
         'SCRIPT_NAME': script_name,
         'FULLY_QUALIFIED_CLASS': self.fully_qualified_class,
         'CLASS_PATH_DEFINITIONS': self.GetClassPathDefinitionsString(),
         'FORWARD_DECLARATIONS': self.GetForwardDeclarationsString(),
         'METHOD_STUBS': self.GetMethodStubsString(),
         'OPEN_NAMESPACE': self.GetOpenNamespaceString(),
-        'NAMESPACE': self.GetNamespaceString(),
         'GET_METHOD_IDS_IMPL': self.GetMethodIDsImplString(),
         'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString(),
         'CLOSE_NAMESPACE': self.GetCloseNamespaceString(),
         'HEADER_GUARD': self.header_guard,
     }
     return WrapOutput(template.substitute(values))
 
   def GetClassPathDefinitionsString(self):
     ret = []
     ret += [self.GetClassPathDefinitions()]
@@ skipping 52 matching lines @@
       kmethods = self.GetKMethodsString(clazz)
       if kmethods:
         values = {'JAVA_CLASS': clazz,
                   'KMETHODS': kmethods}
         ret += [template.substitute(values)]
     if not ret: return ''
     return '\n' + '\n'.join(ret)
 
   def GetOpenNamespaceString(self):
     if self.namespace:
-      return 'namespace %s {' % self.namespace
-    return ''
-
-  def GetNamespaceString(self):
-    if self.namespace:
-      return '%s::' % 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:
-      return '}  // namespace %s\n' % self.namespace
+      all_namespaces = ['}  // namespace %s' % ns
+                        for ns in self.namespace.split('::')]
+      all_namespaces.reverse()
+      return '\n'.join(all_namespaces) + '\n'
     return ''
 
   def GetJNIFirstParam(self, native):
     ret = []
     if native.type == 'method':
       ret = ['jobject obj']
     elif native.type == 'function':
       if native.static:
         ret = ['jclass clazz']
       else:
@@ skipping 16 matching lines @@
 
   def GetCalledByNativeParamsInDeclaration(self, called_by_native):
     return ',\n    '.join([JavaDataTypeToC(param.datatype) + ' ' +
                            param.name
                            for param in called_by_native.params])
 
   def GetForwardDeclaration(self, native):
     template = Template("""
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS});
 """)
-    values = {'NAMESPACE': self.GetNamespaceString(),
-              'RETURN': JavaDataTypeToC(native.return_type),
+    values = {'RETURN': JavaDataTypeToC(native.return_type),
               'NAME': native.name,
               'PARAMS': self.GetParamsInDeclaration(native)}
     return template.substitute(values)
 
   def GetNativeMethodStub(self, native):
     """Returns stubs for native methods."""
     template = Template("""\
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS_IN_DECLARATION}) {
   DCHECK(${PARAM0_NAME}) << "${NAME}";
   ${P0_TYPE}* native = reinterpret_cast<${P0_TYPE}*>(${PARAM0_NAME});
   return native->${NAME}(env, obj${PARAMS_IN_CALL})${POST_CALL};
 }
 """)
     params_for_call = ', '.join(p.name for p in native.params[1:])
     if params_for_call:
       params_for_call = ', ' + params_for_call
 
     return_type = JavaDataTypeToC(native.return_type)
     if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
       scoped_return_type = 'ScopedJavaLocalRef<' + return_type + '>'
       post_call = '.Release()'
     else:
       scoped_return_type = return_type
       post_call = ''
     values = {
         'RETURN': return_type,
         'SCOPED_RETURN': scoped_return_type,
-        'NAMESPACE': self.GetNamespaceString(),
         'NAME': native.name,
         'PARAMS_IN_DECLARATION': self.GetParamsInDeclaration(native),
         'PARAM0_NAME': native.params[0].name,
         'P0_TYPE': native.p0_type,
         'PARAMS_IN_CALL': params_for_call,
         'POST_CALL': post_call
     }
     return template.substitute(values)
 
   def GetCalledByNativeMethodStub(self, called_by_native):
@@ skipping 253 matching lines @@
     input_file = options.input_file
   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'
   GenerateJNIHeader(input_file, output_file, options.namespace)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))