Add gin, a lightweight bindings system for V8

gin/runner.h

+// Copyright 2013 The Chromium Authors. All rights reserved.

[Aaron Boodman, 2013/11/09 21:40:35]

I don't see what runner is used by in this cl?

[abarth-chromium, 2013/11/10 02:12:20]

Currently it's just used in runner_unittest.cc.  It's going to be the main entry
point to actually executing script.

We can talk through this more, but what I had in mind for Mojo is that we
wouldn't put much of anything into the global scope.  Instead, we'd run the
app's script by calling its "main" function with an interface object that
contained the API.  There are a number of benefits to this approach:

1) We can potentially snapshot apps just before calling main.  Because they
don't have any APIs yet, they can't have much effect on the outside world.  On
subsequent runs, we can start them up faster.

2) The app has greater control over the structure of its code because other code
it loads doesn't automatically have access to the underlying API.  For example,
the script can create a new API and hide the Mojo API inside closures.  If the
script stays inside the SES subset, then it might be able to load untrusted
script into its global object.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GIN_RUNNER_H_
+#define GIN_RUNNER_H_
+
+#include "base/basictypes.h"
+#include "v8/include/v8.h"
+
+namespace gin {
+
+class Runner;
+
+class RunnerDelegate {
+ public:
+  // Returns the object that is passed to the script's |main| function.
+  virtual v8::Handle<v8::Object> CreateRootObject(Runner* runner) = 0;
+
+ protected:
+  virtual ~RunnerDelegate();
+};
+
+class Runner {
+ public:
+  Runner(RunnerDelegate* delegate, v8::Isolate* isolate);
+  ~Runner();
+
+  void Run(v8::Handle<v8::Script> script);
+
+  v8::Isolate* isolate() const { return isolate_; }
+
+  v8::Handle<v8::Context> context() const {
+    return v8::Local<v8::Context>::New(isolate_, context_);
+  }
+
+  v8::Handle<v8::Object> global() const {
+    return context()->Global();
+  }
+
+  class Scope {
+   public:
+    explicit Scope(Runner* runner);
+    ~Scope();
+
+   private:
+    v8::HandleScope handle_scope_;
+    v8::Context::Scope scope_;
+
+    DISALLOW_COPY_AND_ASSIGN(Scope);
+  };
+
+ private:
+  friend class Scope;
+
+  v8::Handle<v8::Function> GetMain();
+
+  RunnerDelegate* delegate_;
+  v8::Isolate* isolate_;
+  v8::Persistent<v8::Context> context_;
+
+  DISALLOW_COPY_AND_ASSIGN(Runner);
+};
+
+}  // namespace gin
+
+#endif  // GIN_RUNNER_H_