Move //mojo/{public, edk} underneath //third_party

This CL move //mojo/public and //mojo/edk to live in the following locations:
- //third_party/mojo/src/mojo/public
- //third_party/mojo/src/mojo/edk

It moves the related gypfiles from //mojo to //third_party/mojo and updates
them as necessary to account for the file moves. It also updates clients of the
mojo SDK and EDK targets in both GYP and GN. (Note that for GN, the mojo SDK
and EDK build systems are maintained in the Mojo repo and designed to be
flexible wrt the location of the SDK/EDK in a client repo, so no changes are
needed.

This CL does not update include paths to the code being moved to limit the
number of moving parts, instead relying on the include_dirs that the SDK and
EDK targets supply to their direct dependents to ensure that include paths
continue to resolve correctly.

NOPRESUBMIT=true

Review URL: https://codereview.chromium.org/814543006

Cr-Commit-Position: refs/heads/master@{#312129}

1 files changed, 0 insertions, 804 deletions

diff --git a/mojo/public/python/mojo_system.pyx b/mojo/public/python/mojo_system.pyx
deleted file mode 100644
index 4e684af..0000000
--- a/mojo/public/python/mojo_system.pyx
+++ /dev/null
@@ -1,804 +0,0 @@
-# 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.
-
-# distutils language = c++
-
-cimport c_core
-cimport c_export  # needed so the init function gets exported
-cimport c_thunks
-
-
-from cpython.buffer cimport PyBUF_CONTIG
-from cpython.buffer cimport PyBUF_CONTIG_RO
-from cpython.buffer cimport Py_buffer
-from cpython.buffer cimport PyBuffer_FillInfo
-from cpython.buffer cimport PyBuffer_Release
-from cpython.buffer cimport PyObject_GetBuffer
-from cpython.mem cimport PyMem_Malloc, PyMem_Free
-from cpython.object cimport Py_EQ, Py_NE
-from libc.stdint cimport int32_t, int64_t, uint32_t, uint64_t, uintptr_t
-
-import ctypes
-import threading
-
-import mojo_system_impl
-
-def SetSystemThunks(system_thunks_as_object):
-  """Bind the basic Mojo Core functions.
-
-  This should only be used by the embedder.
-  """
-  cdef const c_thunks.MojoSystemThunks* system_thunks = (
-      <const c_thunks.MojoSystemThunks*><uintptr_t>system_thunks_as_object)
-  c_thunks.MojoSetSystemThunks(system_thunks)
-
-HANDLE_INVALID = c_core.MOJO_HANDLE_INVALID
-RESULT_OK = c_core.MOJO_RESULT_OK
-RESULT_CANCELLED = c_core.MOJO_RESULT_CANCELLED
-RESULT_UNKNOWN = c_core.MOJO_RESULT_UNKNOWN
-RESULT_INVALID_ARGUMENT = c_core.MOJO_RESULT_INVALID_ARGUMENT
-RESULT_DEADLINE_EXCEEDED = c_core.MOJO_RESULT_DEADLINE_EXCEEDED
-RESULT_NOT_FOUND = c_core.MOJO_RESULT_NOT_FOUND
-RESULT_ALREADY_EXISTS = c_core.MOJO_RESULT_ALREADY_EXISTS
-RESULT_PERMISSION_DENIED = c_core.MOJO_RESULT_PERMISSION_DENIED
-RESULT_RESOURCE_EXHAUSTED = c_core.MOJO_RESULT_RESOURCE_EXHAUSTED
-RESULT_FAILED_PRECONDITION = c_core.MOJO_RESULT_FAILED_PRECONDITION
-RESULT_ABORTED = c_core.MOJO_RESULT_ABORTED
-RESULT_OUT_OF_RANGE = c_core.MOJO_RESULT_OUT_OF_RANGE
-RESULT_UNIMPLEMENTED = c_core.MOJO_RESULT_UNIMPLEMENTED
-RESULT_INTERNAL = c_core.MOJO_RESULT_INTERNAL
-RESULT_UNAVAILABLE = c_core.MOJO_RESULT_UNAVAILABLE
-RESULT_DATA_LOSS = c_core.MOJO_RESULT_DATA_LOSS
-RESULT_BUSY = c_core.MOJO_RESULT_BUSY
-RESULT_SHOULD_WAIT = c_core.MOJO_RESULT_SHOULD_WAIT
-DEADLINE_INDEFINITE = c_core.MOJO_DEADLINE_INDEFINITE
-HANDLE_SIGNAL_NONE = c_core.MOJO_HANDLE_SIGNAL_NONE
-HANDLE_SIGNAL_READABLE = c_core.MOJO_HANDLE_SIGNAL_READABLE
-HANDLE_SIGNAL_WRITABLE = c_core.MOJO_HANDLE_SIGNAL_WRITABLE
-HANDLE_SIGNAL_PEER_CLOSED = c_core.MOJO_HANDLE_SIGNAL_PEER_CLOSED
-WRITE_MESSAGE_FLAG_NONE = c_core.MOJO_WRITE_MESSAGE_FLAG_NONE
-READ_MESSAGE_FLAG_NONE = c_core.MOJO_READ_MESSAGE_FLAG_NONE
-READ_MESSAGE_FLAG_MAY_DISCARD = c_core.MOJO_READ_MESSAGE_FLAG_MAY_DISCARD
-WRITE_DATA_FLAG_NONE = c_core.MOJO_WRITE_DATA_FLAG_NONE
-WRITE_DATA_FLAG_ALL_OR_NONE = c_core.MOJO_WRITE_DATA_FLAG_ALL_OR_NONE
-READ_DATA_FLAG_NONE = c_core.MOJO_READ_DATA_FLAG_NONE
-READ_DATA_FLAG_ALL_OR_NONE = c_core.MOJO_READ_DATA_FLAG_ALL_OR_NONE
-READ_DATA_FLAG_DISCARD = c_core.MOJO_READ_DATA_FLAG_DISCARD
-READ_DATA_FLAG_QUERY = c_core.MOJO_READ_DATA_FLAG_QUERY
-READ_DATA_FLAG_PEEK = c_core.MOJO_READ_DATA_FLAG_PEEK
-MAP_BUFFER_FLAG_NONE = c_core.MOJO_MAP_BUFFER_FLAG_NONE
-
-_WAITMANY_NO_SIGNAL_STATE_ERRORS = [RESULT_INVALID_ARGUMENT,
-                                    RESULT_RESOURCE_EXHAUSTED]
-
-def GetTimeTicksNow():
-  """Monotonically increasing tick count representing "right now."
-
-  See mojo/public/c/system/functions.h
-  """
-  return c_core.MojoGetTimeTicksNow()
-
-cdef class _ScopedMemory:
-  """Allocate memory at creation, and deallocate it at destruction."""
-  cdef void* memory
-  def __init__(self, size):
-    self.memory = PyMem_Malloc(size)
-
-  def __dealloc__(self):
-    PyMem_Free(self.memory)
-
-cdef class _ScopedBuffer:
-  """Retrieve pointer to a buffer a creation, and release it at destruction.
-  """
-  cdef Py_buffer _buf
-  cdef void* buf
-  cdef Py_ssize_t len
-
-  def __init__(self, obj, flags=PyBUF_CONTIG_RO):
-    if obj:
-      if PyObject_GetBuffer(obj, &self._buf, flags) < 0:
-        raise TypeError('Unable to read buffer.')
-      self.buf = self._buf.buf
-      self.len = self._buf.len
-    else:
-      self.buf = NULL
-      self.len = 0
-
-  def __dealloc__(self):
-    if self.buf:
-      PyBuffer_Release(&self._buf)
-
-def _SliceBuffer(buffer, size):
-  """Slice the given buffer, reducing it to the given size.
-
-  Return None if None is passed in.
-  """
-  if not buffer:
-    return buffer
-  return buffer[:size]
-
-cdef class _NativeMemoryView(object):
-  """Create a python buffer wrapping the given memory.
-
-  Will also retain the given handle until this object is deallocated.
-  """
-  cdef void* _memory
-  cdef uint32_t _size
-  cdef char _read_only
-  cdef char _wrapped
-  cdef object _handle
-
-  def __init__(self, handle):
-    self._handle = handle
-
-  def __cinit__(self):
-    self._memory = NULL
-    self._size = 0
-    self._read_only = True
-    self._wrapped = False
-
-  cdef Wrap(self,
-            const void* memory,
-            uint32_t size,
-            read_only=True):
-    """Makes this buffer wraps the given memory.
-
-    Must be called before using this buffer, and must only be called once.
-    """
-    assert not self._wrapped
-    self._wrapped = True
-    self._memory = <void*>memory
-    self._size = size
-    self._read_only = read_only
-
-  # buffer interface (PEP 3118)
-  def __getbuffer__(self, Py_buffer *view, int flags):
-    assert self._wrapped
-    if view == NULL:
-      return
-    PyBuffer_FillInfo(view,
-                      self,
-                      self._memory,
-                      self._size,
-                      self._read_only,
-                      flags)
-
-  def __releasebuffer__(self, Py_buffer *view):
-    assert self._wrapped
-    pass
-
-  # legacy buffer interface
-  def __getsegcount__(self, Py_ssize_t *sizes):
-    assert self._wrapped
-    if sizes != NULL:
-      sizes[0] = self._size
-    return 1
-
-  def __getreadbuffer__(self, Py_ssize_t index, void **data):
-    assert self._wrapped
-    if index != 0:
-      raise SystemError('Index out of bounds: %d' % index)
-    data[0] = self._memory
-    return self._size
-
-  def __getwritebuffer__(self, Py_ssize_t index, void **data):
-    assert self._wrapped
-    if index != 0:
-      raise SystemError('Index out of bounds: %d' % index)
-    if self._read_only:
-      raise TypeError('Buffer is read-only.')
-    data[0] = self._memory
-    return self._size
-
-class MojoException(Exception):
-  """Exception wrapping a mojo result error code."""
-
-  def __init__(self, mojo_result):
-    self.mojo_result = mojo_result
-
-def WaitMany(handles_and_signals, deadline):
-  """Waits on a list of handles.
-
-  Args:
-    handles_and_signals: list of tuples of handle and signal.
-
-  See mojo/public/c/system/functions.h
-  """
-  cdef uint32_t length = len(handles_and_signals)
-  cdef uint32_t result_index = <uint32_t>(-1)
-
-  cdef _ScopedMemory handles_alloc = _ScopedMemory(
-      sizeof(c_core.MojoHandle) * length)
-  cdef _ScopedMemory signals_alloc = _ScopedMemory(
-      sizeof(c_core.MojoHandleSignals) * length)
-  cdef _ScopedMemory states_alloc = _ScopedMemory(
-      sizeof(c_core.MojoHandleSignalsState) * length)
-  cdef c_core.MojoHandle* handles = <c_core.MojoHandle*>handles_alloc.memory
-  cdef c_core.MojoHandleSignals* signals = (
-      <c_core.MojoHandleSignals*>signals_alloc.memory)
-  cdef c_core.MojoHandleSignalsState* states = (
-      <c_core.MojoHandleSignalsState*>states_alloc.memory)
-  cdef int index = 0
-  for (h, s) in handles_and_signals:
-    handles[index] = (<Handle?>h)._mojo_handle
-    signals[index] = s
-    index += 1
-  cdef c_core.MojoResult result = c_core.MOJO_RESULT_OK
-  cdef c_core.MojoDeadline cdeadline = deadline
-  with nogil:
-    result = c_core.MojoWaitMany(handles, signals, length, cdeadline,
-                                 &result_index, states)
-
-  returned_result_index = None
-  if result_index != <uint32_t>(-1):
-    returned_result_index = result_index
-
-  returned_states = None
-  if result not in _WAITMANY_NO_SIGNAL_STATE_ERRORS:
-    returned_states = [(states[i].satisfied_signals,
-                        states[i].satisfiable_signals) for i in xrange(length)]
-
-  return (result, returned_result_index, returned_states)
-
-
-cdef class DataPipeTwoPhaseBuffer(object):
-  """Return value for two phases read and write.
-
-  The buffer field contains the python buffer where data can be read or written.
-  When done with the buffer, the |end| method must be called with the number of
-  bytes read or written.
-  """
-
-  cdef object _buffer
-  cdef Handle _handle
-  cdef char _read
-
-  def __init__(self, handle, buffer, read=True):
-    self._buffer = buffer
-    self._handle = handle
-    self._read = read
-
-  def End(self, num_bytes):
-    self._buffer = None
-    cdef c_core.MojoResult result
-    if self._read:
-      result = c_core.MojoEndReadData(self._handle._mojo_handle, num_bytes)
-    else:
-      result = c_core.MojoEndWriteData(self._handle._mojo_handle, num_bytes)
-    self._handle = None
-    return result
-
-  @property
-  def buffer(self):
-    return self._buffer
-
-  def __dealloc__(self):
-    assert not self._buffer
-
-cdef class MappedBuffer(object):
-  """Return value for the |map| operation on shared buffer handles.
-
-  The buffer field contains the python buffer where data can be read or written.
-  When done with the buffer, the |unmap| method must be called.
-  """
-
-  cdef object _buffer
-  cdef object _handle
-  cdef object _cleanup
-
-  def __init__(self, handle, buffer, cleanup):
-    self._buffer = buffer
-    self._handle = handle
-    self._cleanup = cleanup
-
-  def UnMap(self):
-    self._buffer = None
-    cdef c_core.MojoResult result = self._cleanup()
-    self._cleanup = None
-    self._handle = None
-    return result
-
-  @property
-  def buffer(self):
-    return self._buffer
-
-  def __dealloc__(self):
-    if self._buffer:
-      self.UnMap()
-
-cdef class Handle(object):
-  """A mojo object."""
-
-  cdef c_core.MojoHandle _mojo_handle
-
-  def __init__(self, mojo_handle=c_core.MOJO_HANDLE_INVALID):
-    self._mojo_handle = mojo_handle
-
-  def _Invalidate(self):
-    """Invalidate the current handle.
-
-    The close operation is not called. It is the responsability of the caller to
-    ensure that the handle is not leaked.
-    """
-    self._mojo_handle = c_core.MOJO_HANDLE_INVALID
-
-  def __richcmp__(self, other, op):
-    if op != Py_EQ and op != Py_NE:
-      raise TypeError('Handle is not ordered')
-    cdef int equality
-    if type(self) is not type(other):
-      equality = id(self) == id(other)
-    else:
-      equality = (<Handle>self)._mojo_handle == (<Handle>other)._mojo_handle
-    if op == Py_EQ:
-      return equality
-    else:
-      return not equality
-
-  def IsValid(self):
-    """Returns whether this handle is valid."""
-    return self._mojo_handle != c_core.MOJO_HANDLE_INVALID
-
-  def Close(self):
-    """Closes this handle.
-
-    See mojo/public/c/system/functions.h
-    """
-    cdef c_core.MojoResult result = c_core.MOJO_RESULT_OK
-    if self.IsValid():
-      result = c_core.MojoClose(self._mojo_handle)
-      self._Invalidate()
-    return result
-
-  def __dealloc__(self):
-    self.Close()
-
-  def Wait(self, signals, deadline):
-    """Waits on the given handle.
-
-    See mojo/public/c/system/functions.h
-    """
-    cdef c_core.MojoHandle handle = self._mojo_handle
-    cdef c_core.MojoHandleSignals csignals = signals
-    cdef c_core.MojoDeadline cdeadline = deadline
-    cdef c_core.MojoHandleSignalsState signal_states
-    cdef c_core.MojoResult result
-    with nogil:
-      result = c_core.MojoWait(handle, csignals, cdeadline, &signal_states)
-
-    returned_states = None
-    if result not in _WAITMANY_NO_SIGNAL_STATE_ERRORS:
-      returned_states = (signal_states.satisfied_signals,
-            signal_states.satisfiable_signals)
-
-    return (result, returned_states)
-
-  def AsyncWait(self, signals, deadline, callback):
-    cdef c_core.MojoHandle handle = self._mojo_handle
-    cdef c_core.MojoHandleSignals csignals = signals
-    cdef c_core.MojoDeadline cdeadline = deadline
-    wait_id = _ASYNC_WAITER.AsyncWait(
-        handle,
-        csignals,
-        cdeadline,
-        callback)
-    def cancel():
-      _ASYNC_WAITER.CancelWait(wait_id)
-    return cancel
-
-  def WriteMessage(self,
-                    buffer=None,
-                    handles=None,
-                    flags=WRITE_MESSAGE_FLAG_NONE):
-    """Writes a message to the message pipe.
-
-    This method can only be used on a handle obtained from |MessagePipe()|.
-
-    See mojo/public/c/system/message_pipe.h
-    """
-    cdef _ScopedBuffer buffer_as_buffer = _ScopedBuffer(buffer)
-    cdef uint32_t input_buffer_length = buffer_as_buffer.len
-    cdef c_core.MojoHandle* input_handles = NULL
-    cdef uint32_t input_handles_length = 0
-    cdef _ScopedMemory handles_alloc = None
-    if handles:
-      input_handles_length = len(handles)
-      handles_alloc = _ScopedMemory(sizeof(c_core.MojoHandle) *
-                                    input_handles_length)
-      input_handles = <c_core.MojoHandle*>handles_alloc.memory
-      for i in xrange(input_handles_length):
-        input_handles[i] = (<Handle?>handles[i])._mojo_handle
-    cdef c_core.MojoResult res = c_core.MojoWriteMessage(self._mojo_handle,
-                                                         buffer_as_buffer.buf,
-                                                         input_buffer_length,
-                                                         input_handles,
-                                                         input_handles_length,
-                                                         flags)
-    if res == c_core.MOJO_RESULT_OK and handles:
-      # Handles have been transferred. Let's invalidate those.
-      for handle in handles:
-        handle._Invalidate()
-    return res
-
-  def ReadMessage(self,
-                   buffer=None,
-                   max_number_of_handles=0,
-                   flags=READ_MESSAGE_FLAG_NONE):
-    """Reads a message from the message pipe.
-
-    This method can only be used on a handle obtained from |MessagePipe()|.
-
-    This method returns a triplet of value (code, data, sizes):
-    - if code is RESULT_OK, sizes will be None, and data will be a pair of
-      (buffer, handles) where buffer is a view of the input buffer with the read
-      data, and handles is a list of received handles.
-    - if code is RESULT_RESOURCE_EXHAUSTED, data will be None and sizes will be
-      a pair of (buffer_size, handles_size) where buffer_size is the size of the
-      next message data and handles_size is the number of handles in the next
-      message.
-    - if code is any other value, data and sizes will be None.
-
-    See mojo/public/c/system/message_pipe.h
-    """
-    cdef _ScopedBuffer buffer_as_buffer = _ScopedBuffer(buffer, PyBUF_CONTIG)
-    cdef uint32_t input_buffer_length = buffer_as_buffer.len
-    cdef c_core.MojoHandle* input_handles = NULL
-    cdef uint32_t input_handles_length = 0
-    cdef _ScopedMemory handles_alloc = None
-    if max_number_of_handles > 0:
-      input_handles_length = max_number_of_handles
-      handles_alloc = _ScopedMemory(sizeof(c_core.MojoHandle) *
-                                    input_handles_length)
-      input_handles = <c_core.MojoHandle*>handles_alloc.memory
-    cdef res = c_core.MojoReadMessage(self._mojo_handle,
-                                      buffer_as_buffer.buf,
-                                      &input_buffer_length,
-                                      input_handles,
-                                      &input_handles_length,
-                                      flags)
-    if res == c_core.MOJO_RESULT_RESOURCE_EXHAUSTED:
-      return (res, None, (input_buffer_length, input_handles_length))
-    if res == c_core.MOJO_RESULT_OK:
-      returned_handles = [Handle(input_handles[i])
-                          for i in xrange(input_handles_length)]
-      return (res,
-              (_SliceBuffer(buffer, input_buffer_length), returned_handles),
-              None)
-    return (res, None, None)
-
-  def WriteData(self, buffer=None, flags=WRITE_DATA_FLAG_NONE):
-    """
-    Writes the given data to the data pipe producer.
-
-    This method can only be used on a producer handle obtained from
-    |DataPipe()|.
-
-    This method returns a tuple (code, num_bytes).
-    - If code is RESULT_OK, num_bytes is the number of written bytes.
-    - Otherwise, num_bytes is None.
-
-    See mojo/public/c/system/data_pipe.h
-    """
-    cdef _ScopedBuffer buffer_as_buffer = _ScopedBuffer(buffer)
-    cdef uint32_t input_buffer_length = buffer_as_buffer.len
-    cdef c_core.MojoResult res = c_core.MojoWriteData(self._mojo_handle,
-                                                      buffer_as_buffer.buf,
-                                                      &input_buffer_length,
-                                                      flags)
-    if res == c_core.MOJO_RESULT_OK:
-      return (res, input_buffer_length)
-    return (res, None)
-
-  def BeginWriteData(self,
-                       min_size=None,
-                       flags=WRITE_DATA_FLAG_NONE):
-    """
-    Begins a two-phase write to the data pipe producer.
-
-    This method can only be used on a producer handle obtained from
-    |DataPipe()|.
-
-    This method returns a tuple (code, two_phase_buffer).
-    - If code is RESULT_OK, two_phase_buffer is a writable
-      DataPipeTwoPhaseBuffer
-    - Otherwise, two_phase_buffer is None.
-
-    See mojo/public/c/system/data_pipe.h
-    """
-    cdef void* out_buffer
-    cdef uint32_t out_size = 0
-    if min_size:
-      flags |= c_core.MOJO_WRITE_DATA_FLAG_ALL_OR_NONE
-      out_size = min_size
-    cdef c_core.MojoResult res = c_core.MojoBeginWriteData(self._mojo_handle,
-                                                           &out_buffer,
-                                                           &out_size,
-                                                           flags)
-    if res != c_core.MOJO_RESULT_OK:
-      return (res, None)
-    cdef _NativeMemoryView view_buffer = _NativeMemoryView(self)
-    view_buffer.Wrap(out_buffer, out_size, read_only=False)
-    return (res, DataPipeTwoPhaseBuffer(self, memoryview(view_buffer), False))
-
-  def ReadData(self, buffer=None, flags=READ_DATA_FLAG_NONE):
-    """Reads data from the data pipe consumer.
-
-    This method can only be used on a consumer handle obtained from
-    |DataPipe()|.
-
-    This method returns a tuple (code, buffer)
-    - if code is RESULT_OK, buffer will be a view of the input buffer with the
-      read data.
-    - otherwise, buffer will be None.
-
-    See mojo/public/c/system/data_pipe.h
-    """
-    cdef _ScopedBuffer buffer_as_buffer = _ScopedBuffer(buffer)
-    cdef uint32_t input_buffer_length = buffer_as_buffer.len
-    cdef c_core.MojoResult res = c_core.MojoReadData(self._mojo_handle,
-                                                     buffer_as_buffer.buf,
-                                                     &input_buffer_length,
-                                                     flags)
-    if res == c_core.MOJO_RESULT_OK:
-      return (res, _SliceBuffer(buffer, input_buffer_length))
-    return (res, None)
-
-  def QueryData(self, flags=READ_DATA_FLAG_NONE):
-    """Queries the amount of data available on the data pipe consumer.
-
-    This method can only be used on a consumer handle obtained from
-    |DataPipe()|.
-
-    This method returns a tuple (code, num_bytes)
-    - if code is RESULT_OK, num_bytes will be the number of bytes available on
-      the data pipe consumer.
-    - otherwise, num_bytes will be None.
-
-    See mojo/public/c/system/data_pipe.h
-    """
-    cdef uint32_t num_bytes = 0
-    cdef c_core.MojoResult res = c_core.MojoReadData(
-        self._mojo_handle,
-        NULL,
-        &num_bytes,
-        flags|c_core.MOJO_READ_DATA_FLAG_QUERY)
-    return (res, num_bytes)
-
-  def BeginReadData(self, min_size=None, flags=READ_DATA_FLAG_NONE):
-    """
-    Begins a two-phase read to the data pipe consumer.
-
-    This method can only be used on a consumer handle obtained from
-    |DataPipe()|.
-
-    This method returns a tuple (code, two_phase_buffer).
-    - If code is RESULT_OK, two_phase_buffer is a readable
-      DataPipeTwoPhaseBuffer
-    - Otherwise, two_phase_buffer is None.
-
-    See mojo/public/c/system/data_pipe.h
-    """
-    cdef const void* out_buffer
-    cdef uint32_t out_size = 0
-    if min_size:
-      flags |= c_core.MOJO_READ_DATA_FLAG_ALL_OR_NONE
-      out_size = min_size
-    cdef c_core.MojoResult res = c_core.MojoBeginReadData(self._mojo_handle,
-                                                          &out_buffer,
-                                                          &out_size,
-                                                          flags)
-    if res != c_core.MOJO_RESULT_OK:
-      return (res, None)
-    cdef _NativeMemoryView view_buffer = _NativeMemoryView(self)
-    view_buffer.Wrap(out_buffer, out_size, read_only=True)
-    return (res, DataPipeTwoPhaseBuffer(self, memoryview(view_buffer), True))
-
-  def Duplicate(self, options=None):
-    """Duplicate the shared buffer handle.
-
-    This method can only be used on a handle obtained from
-    |CreateSharedBuffer()| or |Duplicate()|.
-
-    See mojo/public/c/system/buffer.h
-    """
-    cdef c_core.MojoDuplicateBufferHandleOptions coptions
-    cdef c_core.MojoDuplicateBufferHandleOptions* coptions_ptr = NULL
-    cdef c_core.MojoHandle cnew_handle = c_core.MOJO_HANDLE_INVALID
-    if options:
-      coptions.struct_size = sizeof(c_core.MojoDuplicateBufferHandleOptions)
-      coptions.flags = options.flags
-      coptions_ptr = &coptions
-    cdef c_core.MojoResult result = c_core.MojoDuplicateBufferHandle(
-        self._mojo_handle, coptions_ptr, &cnew_handle)
-    new_handle = Handle(cnew_handle)
-    if result != c_core.MOJO_RESULT_OK:
-      raise MojoException(result)
-    return new_handle
-
-  def Map(self, offset, num_bytes, flags=MAP_BUFFER_FLAG_NONE):
-    """Maps the part (at offset |offset| of length |num_bytes|) of the buffer.
-
-    This method can only be used on a handle obtained from
-    |CreateSharedBuffer()| or |Duplicate()|.
-
-    This method returns a tuple (code, mapped_buffer).
-    - If code is RESULT_OK, mapped_buffer is a readable/writable
-      MappedBuffer
-    - Otherwise, mapped_buffer is None.
-
-    See mojo/public/c/system/buffer.h
-    """
-    cdef void* buffer
-    res = c_core.MojoMapBuffer(self._mojo_handle,
-                               offset,
-                               num_bytes,
-                               &buffer,
-                               flags)
-    if res != c_core.MOJO_RESULT_OK:
-      return (res, None)
-    cdef _NativeMemoryView view_buffer = _NativeMemoryView(self)
-    view_buffer.Wrap(buffer, num_bytes, read_only=False)
-    return (res, MappedBuffer(self,
-                              memoryview(view_buffer),
-                              lambda: c_core.MojoUnmapBuffer(buffer)))
-
-class CreateMessagePipeOptions(object):
-  """Options for creating a message pipe.
-
-  See mojo/public/c/system/message_pipe.h
-  """
-  FLAG_NONE = c_core.MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE
-
-  def __init__(self):
-    self.flags = CreateMessagePipeOptions.FLAG_NONE
-
-class MessagePipe(object):
-  """Creates a message pipe.
-
-  The two ends of the message pipe are accessible with the members handle0 and
-  handle1.
-
-  See mojo/public/c/system/message_pipe.h
-  """
-  def __init__(self, options=None):
-    cdef c_core.MojoCreateMessagePipeOptions coptions
-    cdef c_core.MojoCreateMessagePipeOptions* coptions_ptr = NULL
-    cdef c_core.MojoHandle chandle0 = c_core.MOJO_HANDLE_INVALID
-    cdef c_core.MojoHandle chandle1 = c_core.MOJO_HANDLE_INVALID
-    if options:
-      coptions.struct_size = sizeof(c_core.MojoCreateMessagePipeOptions)
-      coptions.flags = options.flags
-      coptions_ptr = &coptions
-    cdef c_core.MojoResult result = c_core.MojoCreateMessagePipe(coptions_ptr,
-                                                                 &chandle0,
-                                                                 &chandle1)
-    self.handle0 = Handle(chandle0)
-    self.handle1 = Handle(chandle1)
-    if result != c_core.MOJO_RESULT_OK:
-      raise c_core.MojoException(result)
-
-
-class CreateDataPipeOptions(object):
-  """Options for creating a data pipe.
-
-  See mojo/public/c/system/data_pipe.h
-  """
-  FLAG_NONE = c_core.MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE
-  FLAG_MAY_DISCARD = c_core.MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD
-
-  def __init__(self):
-    self.flags = CreateDataPipeOptions.FLAG_NONE
-    self.element_num_bytes = 1
-    self.capacity_num_bytes = 0
-
-class DataPipe(object):
-  """Creates a data pipe.
-
-  The producer end of the data pipe is accessible with the member
-  producer_handle and the consumer end of the data pipe is accessible with the
-  member cconsumer_handle.
-
-  See mojo/public/c/system/data_pipe.h
-  """
-  def __init__(self, options=None):
-    cdef c_core.MojoCreateDataPipeOptions coptions
-    cdef c_core.MojoCreateDataPipeOptions* coptions_ptr = NULL
-    cdef c_core.MojoHandle cproducer_handle = c_core.MOJO_HANDLE_INVALID
-    cdef c_core.MojoHandle cconsumer_handle = c_core.MOJO_HANDLE_INVALID
-    if options:
-      coptions.struct_size = sizeof(c_core.MojoCreateDataPipeOptions)
-      coptions.flags = options.flags
-      coptions.element_num_bytes = options.element_num_bytes
-      coptions.capacity_num_bytes = options.capacity_num_bytes
-      coptions_ptr = &coptions
-    cdef c_core.MojoResult result = c_core.MojoCreateDataPipe(coptions_ptr,
-                                                              &cproducer_handle,
-                                                              &cconsumer_handle)
-    self.producer_handle = Handle(cproducer_handle)
-    self.consumer_handle = Handle(cconsumer_handle)
-    if result != c_core.MOJO_RESULT_OK:
-      raise MojoException(result)
-
-class CreateSharedBufferOptions(object):
-  """Options for creating a shared buffer.
-
-  See mojo/public/c/system/buffer.h
-  """
-  FLAG_NONE = c_core.MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE
-
-  def __init__(self):
-    self.flags = CreateSharedBufferOptions.FLAG_NONE
-
-def CreateSharedBuffer(num_bytes, options=None):
-  """Creates a buffer of size |num_bytes| bytes that can be shared.
-
-  See mojo/public/c/system/buffer.h
-  """
-  cdef c_core.MojoCreateSharedBufferOptions coptions
-  cdef c_core.MojoCreateSharedBufferOptions* coptions_ptr = NULL
-  cdef c_core.MojoHandle chandle = c_core.MOJO_HANDLE_INVALID
-  if options:
-    coptions.struct_size = sizeof(c_core.MojoCreateSharedBufferOptions)
-    coptions.flags = options.flags
-    coptions_ptr = &coptions
-  cdef c_core.MojoResult result = c_core.MojoCreateSharedBuffer(coptions_ptr,
-                                                                num_bytes,
-                                                                &chandle)
-  handle = Handle(chandle)
-  if result != c_core.MOJO_RESULT_OK:
-    raise MojoException(result)
-  return handle
-
-class DuplicateSharedBufferOptions(object):
-  """Options for duplicating a shared buffer.
-
-  See mojo/public/c/system/buffer.h
-  """
-  FLAG_NONE = c_core.MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE
-
-  def __init__(self):
-    self.flags = DuplicateSharedBufferOptions.FLAG_NONE
-
-
-# Keeps a thread local weak reference to the current run loop.
-_RUN_LOOPS = threading.local()
-
-
-class RunLoop(object):
-  """RunLoop to use when using asynchronous operations on handles."""
-
-  def __init__(self):
-    self.__run_loop = mojo_system_impl.RunLoop()
-    _RUN_LOOPS.loop = id(self)
-
-  def __del__(self):
-    del _RUN_LOOPS.loop
-
-  def Run(self):
-    """Run the runloop until Quit is called."""
-    return self.__run_loop.Run()
-
-  def RunUntilIdle(self):
-    """Run the runloop until Quit is called or no operation is waiting."""
-    return self.__run_loop.RunUntilIdle()
-
-  def Quit(self):
-    """Quit the runloop."""
-    return self.__run_loop.Quit()
-
-  def PostDelayedTask(self, runnable, delay=0):
-    """
-    Post a task on the runloop. This must be called from the thread owning the
-    runloop.
-    """
-    return self.__run_loop.PostDelayedTask(runnable, delay)
-
-  @staticmethod
-  def Current():
-    if hasattr(_RUN_LOOPS, 'loop'):
-      return ctypes.cast(_RUN_LOOPS.loop, ctypes.py_object).value
-    return None
-
-
-_ASYNC_WAITER = mojo_system_impl.AsyncWaiter()