Fix problem with non void return types in extension API IDL.

tools/json_schema_compiler/dart_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.
 """
 Generator language component for compiler.py that adds Dart language support.
 """
 
 from code import Code
 from model import *
 from schema_util import *
@@ skipping 206 matching lines @@
         .Sblock("for (var o in JS('List', '#.%s', this._jsObject)) {" %
                 prop.name)
         .Append('__proxy_%s.add(new %s._proxy(o));' % (prop.name,
              self._GetDartType(prop.type_.item_type)))
         .Eblock('}')
         .Append('return __proxy_%s;' % prop.name)
         .Eblock('}')
       )
     elif self._IsObjectType(prop.type_):
       # TODO(sashab): Think of a way to serialize generic Dart objects.
-      c.Append("%s get %s => JS('%s', '#.%s', this._jsObject);" %
-          (type_name, prop.name, type_name, prop.name))
+      if type_name in self._types:
+        c.Append("%s get %s => new %s._proxy(JS('%s', '#.%s', "
+                 "this._jsObject));" %
+            (type_name, prop.name, type_name, type_name, prop.name))
+      else:
+        c.Append("%s get %s => JS('%s', '#.%s', this._jsObject);" %
+            (type_name, prop.name, type_name, prop.name))
     else:
       raise Exception(
           "Could not generate wrapper for %s.%s: unserializable type %s" %
           (type_.name, prop.name, type_name)
       )
     return c
 
   def _GenerateSetter(self, type_, prop):
     """Given a Type and Property, returns the Code object for the setter for
     that property.
@@ skipping 127 matching lines @@
     is this._jsObject.
 
     e.g.
         JS('void', '#.resizeTo(#, #)', this._jsObject, width, height)
         JS('void', '#.setBounds(#)', this._jsObject, convertArgument(bounds))
     """
     n_params = len(function.params)
     if function.callback:
       n_params += 1
 
-    params = ["'%s'" % self._GetDartType(function.returns),
-              "'#.%s(%s)'" % (function.name, ', '.join(['#'] * n_params)),
-              call_target]
+    return_type_str = self._GetDartType(function.returns)
+    params = []
+
+    # If this object is serializable, don't convert the type from JS - pass the
+    # JS object straight into the proxy.
+    if self._IsSerializableObjectType(function.returns):
+      params.append("''")
+    else:
+      params.append("'%s'" % return_type_str)
+
+    params.append("'#.%s(%s)'" % (function.name, ', '.join(['#'] * n_params)))
+    params.append(call_target)
 
     for param in function.params:
       if not self._IsBaseType(param.type_):
         params.append('convertArgument(%s)' % param.name)
       else:
         params.append(param.name)
     if function.callback:
       # If this isn't a base type, we need a proxied callback.
       callback_name = function.callback.name
       if self._NeedsProxiedCallback(function):
         callback_name = "__proxy_callback"
       params.append('convertDartClosureToJS(%s, %s)' % (callback_name,
                     len(function.callback.params)))
 
-    return 'JS(%s)' % ', '.join(params)
+    # If the object is serializable, call the proxy constructor for this type.
+    proxy_call = 'JS(%s)' % ', '.join(params)
+    if self._IsSerializableObjectType(function.returns):
+      proxy_call = 'new %s._proxy(%s)' % (return_type_str, proxy_call)
+
+    return proxy_call
 
   def _GenerateEvent(self, event):
     """Given a Function object, returns the Code with the .dart for this event,
     represented by the function.
 
     All events extend the Event base type.
     """
     c = Code()
 
     # Add documentation for this event.
@@ skipping 198 matching lines @@
       return None
 
     if document_with is not None:
       c.Concat(self._GenerateDocumentation(document_with))
     for line in contents.strip('\n').split('\n'):
       c.Append(line)
     return c
 
   def _AddPrefix(self, name):
     """Given the name of a type, prefixes the namespace (as camelcase) and
-    return the new name.
+    returns the new name.
     """
     # TODO(sashab): Split the dart library into multiple files, avoiding the
     # need for this prefixing.
     return ('%s%s' % (
         ''.join(s.capitalize() for s in self._namespace.name.split('.')),
         name))
 
   def _IsFunction(self, type_):
     """Given a model.Type, returns whether this type is a function.
     """
     return type_.property_type == PropertyType.FUNCTION
 
   def _IsSerializableObjectType(self, type_):
     """Given a model.Type, returns whether this type is a serializable object.
     Serializable objects are custom types defined in this namespace.
 
     If this object is a reference to something not in this namespace, assumes
     its a serializable object.
     """
+    if type_ is None:
+      return False
     if type_.property_type is PropertyType.CHOICES:
       return all(self._IsSerializableObjectType(c) for c in type_.choices)
     if type_.property_type is PropertyType.REF:
       if type_.ref_type in self._types:
         return self._IsObjectType(self._types[type_.ref_type])
       return True
     if (type_.property_type == PropertyType.OBJECT
         and type_.instance_of in self._types):
       return self._IsObjectType(self._types[type_.instance_of])
     return False
@@ skipping 88 matching lines @@
       return 'Object'
     elif prop_type is PropertyType.FUNCTION:
       return 'Function'
     elif prop_type is PropertyType.ARRAY:
       return 'List<%s>' % self._GetDartType(type_.item_type)
     elif prop_type is PropertyType.BINARY:
       return 'String'
     else:
       raise NotImplementedError(prop_type)