Use a class for CodeGeneratorV8

Source/bindings/scripts/unstable/idl_definitions.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 29 matching lines @@
 # pylint: disable=W0232, E0203, W0201
 
 import abc
 import json
 import re
 
 
 # Base classes
 
 
-class BaseIdl:
+class BaseIdl(object):
     """Abstract base class, used for JSON serialization."""
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
     def json_serializable(self):
         """Returns a JSON serializable form of the object.
 
         This should be a dictionary, with keys scoped names of the form
         Class::key, where the scope is the class name.
         This is so we produce identical output to the Perl code, which uses
         the Perl module JSON.pm, which uses this format.
         """
         pass
 
 
-class TypedObject:
+class TypedObject(object):
     """Object with a type, such as an Attribute or Operation (return value).
 
     The type can be an actual type, or can be a typedef, which must be resolved
     before passing data to the code generator.
     """
     __metaclass__ = abc.ABCMeta
     idl_type = None
     extended_attributes = None
 
     def resolve_typedefs(self, typedefs):
@@ skipping 245 matching lines @@
 
 def resolve_typedefs(idl_type, typedefs):
     """Return an IDL type (as string) with typedefs resolved."""
     # Converts a string representation to and from an IdlType object to handle
     # parsing of composite types (arrays and sequences) and encapsulate typedef
     # resolution, e.g., GLint[] -> unsigned long[] requires parsing the '[]'.
     # Use fluent interface to avoid auxiliary variable.
     return str(IdlType.from_string(idl_type).resolve_typedefs(typedefs))
 
 
-class IdlType:
+class IdlType(object):
     # FIXME: replace type strings with these objects,
     # so don't need to parse everywhere types are used.
     # Types are stored internally as strings, not objects,
     # e.g., as 'sequence<Foo>' or 'Foo[]',
     # hence need to parse the string whenever a type is used.
     # FIXME: incorporate Nullable, Variadic, etc.
     # FIXME: properly should nest types
     # Formally types are nested, e.g., short?[] vs. short[]?,
     # but in practice these complex types aren't used and can treat
     # as orthogonal properties.
@@ skipping 89 matching lines @@
 
 
 # JSON export
 
 
 class IdlEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, BaseIdl):
             return obj.json_serializable()
         return json.JSONEncoder.default(self, obj)