Update mojo sdk to rev 9fbbc4f0fef1187312316c0ed992342474e139f1

mojo/public/python/mojo_bindings/descriptor.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 descriptors used to define generated elements of the mojo python bindings.
 """
 
 import array
 import itertools
 import struct
 
-import mojo.bindings.reflection as reflection
-import mojo.bindings.serialization as serialization
+import mojo_bindings.reflection as reflection
+import mojo_bindings.serialization as serialization
 
 # pylint: disable=E0611,F0401
-import mojo.system
+import mojo_system
 
 
 class Type(object):
   """Describes the type of a struct field or a method parameter,"""
 
   def Convert(self, value): # pylint: disable=R0201
     """
     Convert the given value into its canonical representation, raising an
     exception if the value cannot be converted.
     """
@@ skipping 205 matching lines @@
           'Trying to serialize null for non nullable type.')
     if not handle.IsValid():
       return (-1, [])
     return (handle_offset, [handle])
 
   def Deserialize(self, value, context):
     if value == -1:
       if not self.nullable:
         raise serialization.DeserializationException(
             'Trying to deserialize null for non nullable type.')
-      return self.FromHandle(mojo.system.Handle())
+      return self.FromHandle(mojo_system.Handle())
     return self.FromHandle(context.ClaimHandle(value))
 
   def FromHandle(self, handle):
     raise NotImplementedError()
 
   def ToHandle(self, value):
     raise NotImplementedError()
 
 
 class HandleType(BaseHandleType):
   """Type object for handles."""
 
   def Convert(self, value):
     if value is None:
-      return mojo.system.Handle()
-    if not isinstance(value, mojo.system.Handle):
+      return mojo_system.Handle()
+    if not isinstance(value, mojo_system.Handle):
       raise TypeError('%r is not a handle' % value)
     return value
 
   def FromHandle(self, handle):
     return handle
 
   def ToHandle(self, value):
     return value
 
 
 class InterfaceRequestType(BaseHandleType):
   """Type object for interface requests."""
 
   def Convert(self, value):
     if value is None:
-      return reflection.InterfaceRequest(mojo.system.Handle())
+      return reflection.InterfaceRequest(mojo_system.Handle())
     if not isinstance(value, reflection.InterfaceRequest):
       raise TypeError('%r is not an interface request' % value)
     return value
 
   def FromHandle(self, handle):
     return reflection.InterfaceRequest(handle)
 
   def ToHandle(self, value):
     return value.PassMessagePipe()
 
@@ skipping 17 matching lines @@
       self._interface = self._interface_getter()
     return self._interface
 
   def FromHandle(self, handle):
     if handle.IsValid():
       return self.interface.manager.Proxy(handle)
     return None
 
   def ToHandle(self, value):
     if not value:
-      return mojo.system.Handle()
+      return mojo_system.Handle()
     if isinstance(value, reflection.InterfaceProxy):
       return value.manager.PassMessagePipe()
-    pipe = mojo.system.MessagePipe()
+    pipe = mojo_system.MessagePipe()
     self.interface.manager.Bind(value, pipe.handle0)
     return pipe.handle1
 
 
 class BaseArrayType(PointerType):
   """Abstract Type object for arrays."""
 
   def __init__(self, nullable=False, length=0):
     PointerType.__init__(self, nullable)
     self.length = length
@@ skipping 360 matching lines @@
 
 
 def _ConvertByteToBooleans(value, min_size=0):
   """Unpack an integer into a list of booleans."""
   res = []
   while value:
     res.append(bool(value&1))
     value = value / 2
   res.extend([False] * (min_size - len(res)))
   return res