Docserver: Show callback parameters in all callback references.

chrome/common/extensions/docs/server2/api_data_source.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 copy import copy
 import logging
 import os
 import posixpath
 
 from data_source import DataSource
@@ skipping 361 matching lines @@
       self._AddCommonProperties(function_dict, function)
       if function.returns:
         function_dict['returns'] = self._GenerateType(function.returns)
     with self._current_node.Descend(function.simple_name):
       with self._current_node.Descend('parameters'):
         for param in function.params:
           function_dict['parameters'].append(self._GenerateProperty(param))
       if function.callback is not None:
         # Show the callback as an extra parameter.
         function_dict['parameters'].append(
-            self._GenerateCallbackProperty(function.callback))
+            self._GenerateCallbackProperty(function.callback,
+                                           function_dict['callback']))
       if len(function_dict['parameters']) > 0:
         function_dict['parameters'][-1]['last'] = True
       return function_dict
 
   def _GenerateEvents(self, events):
     with self._current_node.Descend('events'):
       return [self._GenerateEvent(e) for e in events.values()
               if not e.supports_dom]
 
   def _GenerateDomEvents(self, events):
@@ skipping 26 matching lines @@
       # information stored in |event|.
       if event.supports_listeners:
         callback_object = model.Function(parent=event,
                                          name='callback',
                                          json={},
                                          namespace=event.parent,
                                          origin='')
         callback_object.params = event.params
         if event.callback:
           callback_object.callback = event.callback
-        callback_parameters = self._GenerateCallbackProperty(callback_object)
+        callback = self._GenerateFunction(callback_object)
+        callback_parameters = self._GenerateCallbackProperty(callback_object,
+                                                             callback)
         callback_parameters['last'] = True
         event_dict['byName']['addListener'] = {
           'name': 'addListener',
-          'callback': self._GenerateFunction(callback_object),
+          'callback': callback,
           'parameters': [callback_parameters]
         }
     with self._current_node.Descend(event.simple_name, ignore=('properties',)):
       if event.supports_dom:
         # Treat params as properties of the custom Event object associated with
         # this DOM Event.
         event_dict['properties'] += [self._GenerateProperty(param)
                                      for param in event.params]
       return event_dict
 
@@ skipping 60 matching lines @@
       if value is not None:
         if isinstance(value, int):
           property_dict['value'] = _FormatValue(value)
         else:
           property_dict['value'] = value
       else:
         self._RenderTypeInformation(type_, property_dict)
 
       return property_dict
 
-  def _GenerateCallbackProperty(self, callback):
+  def _GenerateCallbackProperty(self, callback, callback_dict):

[not at google - send to devlin, 2014/07/23 03:25:03]

kinda weird to be passing in |callback_dict| when you can determine it from
|callback| but it does save doing the same work twice, so worth it in that
respect.

I think this is all because once upon a time a callback was just modelled as a
function. Like, there was no "GenerateCallbackProperty" there was just
"GenerateFunction". However that caused some sort of issue so it was split up?

but that's the funny part - GenerateFunction *does* have a 'callback' property
already, and it actually means a callback to that function. That's not what
it'll mean here, and I'm not sure what that will do.

would it work to have 2 properties, "isCallback" and "asFunction"? is that
enough to get by?

     property_dict = {
       'name': callback.simple_name,
       'description': callback.description,
       'optional': callback.optional,
-      'is_callback': True,
+      'callback': callback_dict,
       'id': _CreateId(callback, 'property'),
       'simple_type': 'function',
     }
     if (callback.parent is not None and
         not isinstance(callback.parent, model.Namespace)):
       property_dict['parentName'] = callback.parent.simple_name
     return property_dict
 
   def _RenderTypeInformation(self, type_, dst_dict):
     with self._current_node.Descend(ignore=('types', 'properties')):
@@ skipping 263 matching lines @@
     getter = lambda: 0
     getter.get = lambda api_name: self._GetImpl(platform, api_name).Get()
     return getter
 
   def Cron(self):
     futures = []
     for platform in GetPlatforms():
       futures += [self._GetImpl(platform, name)
           for name in self._platform_bundle.GetAPIModels(platform).GetNames()]
     return Collect(futures, except_pass=FileNotFoundError)