Content handler for python.

mojo/public/python/mojo_bindings/reflection.py

 # Copyright 2014 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.
 
 """The metaclasses used by the mojo python bindings."""
 
 import itertools
 import logging
 import sys
 
@@ skipping 164 matching lines @@
     for base in bases:
       if isinstance(base, mcs):
         return type.__new__(mcs, name, bases, dictionary)
 
     descriptor = dictionary.pop('DESCRIPTOR', {})
 
     methods = [_MethodDescriptor(x) for x in descriptor.get('methods', [])]
     for method in methods:
       dictionary[method.name] = _NotImplemented
     client_class_getter = descriptor.get('client', None)
+    fully_qualified_name = descriptor['fully_qualified_name']
 
-    interface_manager = InterfaceManager(name, methods, client_class_getter)
+    interface_manager = InterfaceManager(fully_qualified_name, methods,
+        client_class_getter)
     dictionary.update({
         'client': None,
         'manager': None,
         '_interface_manager': interface_manager,
     })
 
     interface_class = type.__new__(mcs, name, bases, dictionary)
     interface_manager.interface_class = interface_class
     return interface_class
 
@@ skipping 27 matching lines @@
     self._handle = handle
 
   def IsPending(self):
     return self._handle.IsValid()
 
   def PassMessagePipe(self):
     result = self._handle
     self._handle = None
     return result
 
+  def Bind(self, impl):
+    type(impl).manager.Bind(impl, self.PassMessagePipe())
+
 
 class InterfaceManager(object):
   """
   Manager for an interface class. The manager contains the operation that allows
   to bind an implementation to a pipe, or to generate a proxy for an interface
   over a pipe.
   """
 
   def __init__(self, name, methods, client_class_getter):
     self.name = name
@@ skipping 31 matching lines @@
     retainer = _Retainer(router)
     def Cleanup(_):
       retainer.release()
     error_handler.AddCallback(Cleanup)
 
     if self.client_manager:
       impl.client = self.client_manager._InternalProxy(router, error_handler)
 
     # Give an instance manager to the implementation to allow it to close
     # the connection.
-    impl.manager = InstanceManager(router)
+    impl.manager = InstanceManager(router, error_handler)
 
     router.Start()
 
   def _InternalProxy(self, router, error_handler):
     if not self._proxy_class:
       dictionary = {
         '__module__': __name__,
         '__init__': _ProxyInit,
       }
       if self.client_manager:
         dictionary['client'] = property(_ProxyGetClient, _ProxySetClient)
         dictionary['manager'] = None
         dictionary['_client_manager'] = self.client_manager
       for method in self.methods:
         dictionary[method.name] = _ProxyMethodCall(method)
       self._proxy_class = type('%sProxy' % self.name,
                                (self.interface_class, InterfaceProxy),
                                dictionary)
 
     proxy = self._proxy_class(router, error_handler)
     # Give an instance manager to the proxy to allow to close the connection.
-    proxy.manager = InstanceManager(router)
+    proxy.manager = InstanceManager(router, error_handler)
     return proxy
 
   def _Stub(self, impl):
     if not self._stub_class:
       accept_method = _StubAccept(self.methods)
       dictionary = {
         '__module__': __name__,
         '__init__': _StubInit,
         'Accept': accept_method,
         'AcceptWithResponder': accept_method,
       }
       self._stub_class = type('%sStub' % self.name,
                               (messaging.MessageReceiverWithResponder,),
                               dictionary)
     return self._stub_class(impl)
 
 
 class InstanceManager(object):
   """
   Manager for the implementation of an interface or a proxy. The manager allows
   to control the connection over the pipe.
   """
-  def __init__(self, router):
-    self.router = router
+  def __init__(self, router, error_handler):
+    self._router = router
+    self._error_handler = error_handler
 
   def Close(self):
-    self.router.Close()
+    self._router.Close()
 
   def PassMessagePipe(self):
-    return self.router.PassMessagePipe()
+    return self._router.PassMessagePipe()
+
+  def AddOnErrorCallback(self, callback):
+    self._error_handler.AddCallback(lambda _: callback())
 
 
 class _MethodDescriptor(object):
   def __init__(self, descriptor):
     self.name = descriptor['name']
     self.ordinal = descriptor['ordinal']
     self.parameters_struct = _ConstructParameterStruct(
         descriptor['parameters'], self.name, "Parameters")
     self.response_struct = _ConstructParameterStruct(
         descriptor.get('responses'), self.name, "Responses")
@@ skipping 212 matching lines @@
       logging.warning(
           'Error occured in accept method. Connection will be closed.')
       if self.impl.manager:
         self.impl.manager.Close()
       return False
   return Accept
 
 
 def _NotImplemented(*_1, **_2):
   raise NotImplementedError()