mojo: Add a runloop utility in python

mojo/public/python/src/python_system_helper.cc

+// 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.
+
+#include "mojo/public/python/src/python_system_helper.h"
+
+#include "Python.h"
+
+#include "mojo/public/cpp/system/macros.h"
+#include "mojo/public/cpp/utility/run_loop.h"
+
+namespace {
+
+class PythonClosure : public mojo::Closure::Runnable {
+ public:
+  PythonClosure(PyObject* callable) {

[sdefresne, 2014/09/16 16:35:59]

If callable is NULL, then callable_ will be uninitialized leading to undefined
behavior in the destructor. Please initialize it or DCHECK that callable is not
NULL.

[qsr, 2014/09/17 11:15:48]

Done.

+    if (callable) {
+      callable_ = callable;
+      Py_XINCREF(callable);
+    }
+  }
+
+  virtual ~PythonClosure() {
+    if (callable_)
+      Py_DECREF(callable_);
+  }
+
+  virtual void Run() const MOJO_OVERRIDE {
+    PyObject* empty_tuple = PyTuple_New(0);

[sdefresne, 2014/09/16 16:35:59]

IIRC, Python function with a prototype returning a PyObject* only return NULL
when a Python exception was raised. I think you need to deal with the exception
here as I don't think the mojo base function know how to deal with a Python
exception asynchronously.

In addition to that, if I understand the code correctly, this function may be
called from another thread than the one that created the PythonClosure, right?
If so, I think this function (and maybe the destructor too if it can be called
from C++) must acquire the GIL before calling CPython code.

  virtual void Run() const MOJO_OVERRIDE {
    PyGILState_STATE gstate;
    gstate = PyGILState_Ensure();
    PyObject* result = RunWithGlobalInterpreterLock();
    if (result == NULL) {
      // Deal with Python exception
    } else {
      Py_DECREF(result);
    }
    PyGILState_Release(gstate);
  }

  PyObject* RunWithGlobalInterpreterLock() {
    PyObject* empty_tuple = PyTuple_New(0);
    if (!empty_tuple)
      return NULL;

    // ...
  }

See https://docs.python.org/2/c-api/init.html#non-python-created-threads

[qsr, 2014/09/17 11:15:48]

 Changed to deal with the exception in the following way: Quit the runloop, and
makes the 2 Run function for the runloop sending exception -> it means that if
you throw on a task, the run function will throw your exception. See the added
test case.
 Nope, that's not possible. But the thread will have release the GIL when this
method is called, so your point is still valid. Added a scoepd object to acquire
the GIL, and used it when needed.

+    if (!empty_tuple)
+      return;
+
+    PyObject* result = PyObject_CallObject(callable_, empty_tuple);
+    Py_DECREF(empty_tuple);
+    if (result)
+      Py_DECREF(result);
+  }
+
+ private:
+  PyObject* callable_;
+};
+
+}  // namespace
+
+namespace mojo {
+
+Closure BuildClosure(PyObject* callable) {
+  if (!PyCallable_Check(callable))
+    return Closure();
+
+  return Closure(
+      static_cast<mojo::Closure::Runnable*>(new PythonClosure(callable)));
+}
+
+void InitRunLoop() {
+  mojo::RunLoop::SetUp();
+}
+
+}  // namespace mojo