Refactors parts of gin:

gin/default_runner.cc

Index: gin/default_runner.cc
diff --git a/gin/default_runner.cc b/gin/default_runner.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a8b6bbbe317ffda69fe2274bfe270ffab75523f4
--- /dev/null
+++ b/gin/default_runner.cc
@@ -0,0 +1,112 @@
+// 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/default_runner.h"
+
+#include "gin/converter.h"
+#include "gin/modules/module_registry.h"
+#include "gin/per_context_data.h"
+#include "gin/public/context_holder.h"
+#include "gin/try_catch.h"
+
+using v8::Context;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Object;
+using v8::ObjectTemplate;
+using v8::Script;
+
+namespace gin {
+
+DefaultRunnerDelegate::DefaultRunnerDelegate() {
+}
+
+DefaultRunnerDelegate::~DefaultRunnerDelegate() {
+}
+
+v8::Handle<ObjectTemplate> DefaultRunnerDelegate::GetGlobalTemplate(
+    DefaultRunner* runner,
+    v8::Isolate* isolate) {
+  return v8::Handle<ObjectTemplate>();
+}
+
+void DefaultRunnerDelegate::DidCreateContext(DefaultRunner* runner) {
+}
+
+void DefaultRunnerDelegate::WillRunScript(DefaultRunner* runner) {
+}
+
+void DefaultRunnerDelegate::DidRunScript(DefaultRunner* runner) {
+}
+
+void DefaultRunnerDelegate::UnhandledException(DefaultRunner* runner,
+                                               TryCatch& try_catch) {
+  CHECK(false) << try_catch.GetStackTrace();
+}
+
+DefaultRunner::DefaultRunner(DefaultRunnerDelegate* delegate, Isolate* isolate)
+    : delegate_(delegate) {
+  v8::Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  v8::Handle<v8::Context> context =
+      Context::New(isolate, NULL, delegate_->GetGlobalTemplate(this, isolate));
+
+  context_holder_.reset(new ContextHolder(isolate));
+  context_holder_->SetContext(context);
+  PerContextData::From(context)->set_runner(this);
+
+  v8::Context::Scope scope(context);
+  delegate_->DidCreateContext(this);
+}
+
+DefaultRunner::~DefaultRunner() {
+}
+
+void DefaultRunner::Run(const std::string& source,
+                        const std::string& resource_name) {
+  TryCatch try_catch;
+  v8::Isolate* isolate = GetContextHolder()->isolate();
+  v8::Handle<Script> script = Script::New(StringToV8(isolate, source),
+                                          StringToV8(isolate, resource_name));
+  if (try_catch.HasCaught()) {
+    delegate_->UnhandledException(this, try_catch);
+    return;
+  }
+
+  Run(script);
+}
+
+v8::Handle<v8::Value> DefaultRunner::Call(v8::Handle<v8::Function> function,
+                                          v8::Handle<v8::Value> receiver,
+                                          int argc,
+                                          v8::Handle<v8::Value> argv[]) {
+  TryCatch try_catch;
+  delegate_->WillRunScript(this);
+
+  v8::Handle<v8::Value> result = function->Call(receiver, argc, argv);
+
+  delegate_->DidRunScript(this);
+  if (try_catch.HasCaught())
+    delegate_->UnhandledException(this, try_catch);
+
+  return result;
+}
+
+ContextHolder* DefaultRunner::GetContextHolder() {
+  return context_holder_.get();
+}
+
+void DefaultRunner::Run(v8::Handle<Script> script) {
+  TryCatch try_catch;
+  delegate_->WillRunScript(this);
+
+  script->Run();
+
+  delegate_->DidRunScript(this);
+  if (try_catch.HasCaught()) {
+    delegate_->UnhandledException(this, try_catch);
+  }
+}
+
+}  // namespace gin