[Extensions API] Remove inline enums

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
 from cpp_namespace_environment import CppNamespaceEnvironment
@@ skipping 130 matching lines @@
 
     return c
 
   def _GenerateInitializersAndBody(self, type_):
     items = []
     for prop in type_.properties.values():
       t = prop.type_
 
       real_t = self._type_helper.FollowRef(t)
       if real_t.property_type == PropertyType.ENUM:
-        items.append('%s(%s)' % (
-            prop.unix_name,
-            self._type_helper.GetEnumNoneValue(t)))
+        namespace_prefix = ('%s::' % real_t.namespace.unix_name
+                            if real_t.namespace != self._namespace
+                            else '')
+        items.append('%s(%s%s)' % (prop.unix_name,
+                                   namespace_prefix,
+                                   self._type_helper.GetEnumNoneValue(t)))
       elif prop.optional:
         continue
       elif t.property_type == PropertyType.INTEGER:
         items.append('%s(0)' % prop.unix_name)
       elif t.property_type == PropertyType.DOUBLE:
         items.append('%s(0.0)' % prop.unix_name)
       elif t.property_type == PropertyType.BOOLEAN:
         items.append('%s(false)' % prop.unix_name)
       elif (t.property_type == PropertyType.ANY or
             t.property_type == PropertyType.ARRAY or
@@ skipping 118 matching lines @@
     c = Code()
     value_var = prop.unix_name + '_value'
     c.Append('const base::Value* %(value_var)s = NULL;')
     if prop.optional:
       (c.Sblock(
           'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false')))
       underlying_type = self._type_helper.FollowRef(prop.type_)
       if underlying_type.property_type == PropertyType.ENUM:
+        namespace_prefix = ('%s::' % underlying_type.namespace.unix_name
+                            if underlying_type.namespace != self._namespace
+                            else '')
         (c.Append('} else {')
-          .Append('%%(dst)s->%%(name)s = %s;' %
-              self._type_helper.GetEnumNoneValue(prop.type_)))
+          .Append('%%(dst)s->%%(name)s = %s%s;' %
+             (namespace_prefix,
+              self._type_helper.GetEnumNoneValue(prop.type_))))
       c.Eblock('}')
     else:
       (c.Sblock(
           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
         .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
         .Append('return false;')
         .Eblock('}')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
       )
@@ skipping 715 matching lines @@
     """Initialize a model.Property to its default value inside an object.
 
     E.g for optional enum "state", generate dst->state = STATE_NONE;
 
     dst: Type*
     """
     c = Code()
     underlying_type = self._type_helper.FollowRef(prop.type_)
     if (underlying_type.property_type == PropertyType.ENUM and
         prop.optional):
-      c.Append('%s->%s = %s;' % (
+      namespace_prefix = ('%s::' % underlying_type.namespace.unix_name
+                          if underlying_type.namespace != self._namespace
+                          else '')
+      c.Append('%s->%s = %s%s;' % (
         dst,
         prop.unix_name,
+        namespace_prefix,
         self._type_helper.GetEnumNoneValue(prop.type_)))
     return c
 
   def _GenerateError(self, body):
     """Generates an error message pertaining to population failure.
 
     E.g 'expected bool, got int'
     """
     c = Code()
     if not self._generate_error_messages:
       return c
     (c.Append('if (error->length())')
       .Append('  error->append(UTF8ToUTF16("; "));')
       .Append('error->append(UTF8ToUTF16(%s));' % body))
     return c
 
   def _GenerateParams(self, params):
     """Builds the parameter list for a function, given an array of parameters.
     """
     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)