Introduce gin_shell

gin/runner.cc

 // Copyright 2013 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 "gin/runner.h"
 
 #include "gin/converter.h"
+#include "gin/try_catch.h"
 
 using v8::Context;
-using v8::Handle;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Script;
 
 namespace gin {
 
 RunnerDelegate::RunnerDelegate() {
 }
 
 RunnerDelegate::~RunnerDelegate() {
 }
 
-Handle<ObjectTemplate> RunnerDelegate::GetGlobalTemplate(Runner* runner) {
-  return Handle<ObjectTemplate>();
+v8::Handle<ObjectTemplate> RunnerDelegate::GetGlobalTemplate(Runner* runner) {
+  return v8::Handle<ObjectTemplate>();
 }
 
 void RunnerDelegate::DidCreateContext(Runner* runner) {
 }
 
+void RunnerDelegate::WillRunScript(Runner* runner, v8::Handle<Script> script) {
+}
+
+void RunnerDelegate::DidRunScript(Runner* runner, v8::Handle<Script> script) {
+}
+
+void RunnerDelegate::UnhandledException(Runner* runner, TryCatch& try_catch) {
+}
+
 Runner::Runner(RunnerDelegate* delegate, Isolate* isolate)
     : ContextHolder(isolate),
-      delegate_(delegate) {
+      delegate_(delegate),
+      weak_factory_(this) {
   HandleScope handle_scope(isolate);
   SetContext(Context::New(isolate, NULL, delegate_->GetGlobalTemplate(this)));
 
   v8::Context::Scope scope(context());
   delegate_->DidCreateContext(this);
 }
 
 Runner::~Runner() {
 }
 
 void Runner::Run(const std::string& script) {
   Run(Script::New(StringToV8(isolate(), script)));
 }
 
-void Runner::Run(Handle<Script> script) {
-  script->Run();
+void Runner::Run(v8::Handle<Script> script) {
+  delegate_->WillRunScript(this, script);
+  {
+    TryCatch try_catch;
+    script->Run();

[jochen (gone - plz use gerrit), 2013/11/18 12:46:05]

consider locking the isolate and entering before running scripts.

This code currently relies on the default isolate being correctly setup and
everything. It would be nicer to do this explicitly.

[abarth-chromium, 2013/11/18 15:33:06]

Done.  Is there some way to enable an ASSERT in V8 to make sure we're always
doing this?

[abarth-chromium, 2013/11/18 15:36:40]

Adding a v8::Locker causes an ASSERT.  I've left it off for now.  We can add it
in a future CL.

+    if (try_catch.HasCaught())
+      delegate_->UnhandledException(this, try_catch);
+  }
+  delegate_->DidRunScript(this, script);
 }
 
 Runner::Scope::Scope(Runner* runner)
     : handle_scope_(runner->isolate()),
       scope_(runner->context()) {
 }
 
 Runner::Scope::~Scope() {
 }
 
 }  // namespace gin