Support scoped types in PPAPI IDL.

tools/json_schema_compiler/cc_generator.py

 # 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.
 
 from code import Code
 from model import PropertyType
 import cpp_util
 import schema_util
 import util_cc_helper
 
@@ skipping 700 matching lines @@
           .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
             ('*%(src_var)s', 'temp.get()')))
           .Append('  return %(failure_value)s;')
           .Append('%(dst_var)s = temp.Pass();')
         )
       else:
         (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
             ('*%(src_var)s', '&%(dst_var)s')))
           .Append('  return %(failure_value)s;'))
     elif underlying_type.property_type == PropertyType.ENUM:
-      c.Concat(self._GenerateStringToEnumConversion(type_,
+      c.Concat(self._GenerateStringToEnumConversion(underlying_type,
                                                     src_var,
                                                     dst_var,
                                                     failure_value))
     elif underlying_type.property_type == PropertyType.BINARY:
       (c.Append('const base::BinaryValue* binary_value = NULL;')
         .Sblock('if (!%(src_var)s->IsType(base::Value::TYPE_BINARY)) {')
         .Concat(self._GenerateError(
           '"\'%%(key)s\': expected binary, got " + ' +
           self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
       )
@@ skipping 58 matching lines @@
 
   def _GenerateStringToEnumConversion(self,
                                       type_,
                                       src_var,
                                       dst_var,
                                       failure_value):
     """Returns Code that converts a string type in |src_var| to an enum with
     type |type_| in |dst_var|. In the generated code, if |src_var| is not
     a valid enum name then the function will return |failure_value|.
     """
+    if type_.property_type != PropertyType.ENUM:
+      raise TypeError(type_)
     c = Code()
     enum_as_string = '%s_as_string' % type_.unix_name
+    cpp_type_namespace = ''
+    if type_.namespace != self._namespace:
+      cpp_type_namespace = '%s::' % type_.namespace.unix_name
+    cpp_type_name = self._type_helper.GetCppType(type_)
     (c.Append('std::string %s;' % enum_as_string)
       .Sblock('if (!%s->GetAsString(&%s)) {' % (src_var, enum_as_string))
       .Concat(self._GenerateError(
         '"\'%%(key)s\': expected string, got " + ' +
         self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
       .Append('return %s;' % failure_value)
       .Eblock('}')
-      .Append('%s = Parse%s(%s);' % (dst_var,
-                                     self._type_helper.GetCppType(type_),
-                                     enum_as_string))
-      .Sblock('if (%s == %s) {' % (dst_var,
-                                 self._type_helper.GetEnumNoneValue(type_)))
+      .Append('%s = %sParse%s(%s);' % (dst_var,
+                                       cpp_type_namespace,
+                                       cpp_util.Classname(type_.name),
+                                       enum_as_string))
+      .Sblock('if (%s == %s%s) {' % (dst_var,
+                                     cpp_type_namespace,
+                                     self._type_helper.GetEnumNoneValue(type_)))
       .Concat(self._GenerateError(
         '\"\'%%(key)s\': expected \\"' +
         '\\" or \\"'.join(
             enum_value.name
             for enum_value in self._type_helper.FollowRef(type_).enum_values) +
         '\\", got \\"" + %s + "\\""' % enum_as_string))
       .Append('return %s;' % failure_value)
       .Eblock('}')
       .Substitute({'src_var': src_var, 'key': type_.name})
     )
@@ skipping 145 matching lines @@
     if self._generate_error_messages:
       params = list(params) + ['base::string16* error']
     return ', '.join(str(p) for p in params)
 
   def _GenerateArgs(self, args):
     """Builds the argument list for a function, given an array of arguments.
     """
     if self._generate_error_messages:
       args = list(args) + ['error']
     return ', '.join(str(a) for a in args)