QtScript/V8: Add API for manipulating scope and function contexts

Needed for the implementation of QScriptEngine::{push,pop}Context(),
QScriptContext::{push,pop}Scope() and friends.

This API is experimental and added only for the purpose of our
research.

The upstream v8 API only provides access to global context objects.
Internally, there are two other types of context objects:
FunctionContexts, used to implement closures, and WithContexts,
used to implement JS "with" statements. The API added in this
change provides a way to construct and access such context objects
from C++.

Author: Kent Hansen

src/3rdparty/v8/include/v8.h

@@ -3304,6 +3304,49 @@ class V8EXPORT Context {
     Handle<Context> context_;
   };
 
+#ifdef QT_BUILD_SCRIPT_LIB
+  /**
+   * Creates a new scope context.
+   *
+   * The currently entered context will be the new context's previous
+   * scope.
+   *
+   * Properties on the given object, scope_object, are accessible from
+   * the new scope.
+   */
+  static Local<Context> NewScopeContext(Handle<Object> scope_object);
+
+  /**
+   * Creates a new function context.
+   *
+   * The currently entered context will be the new context's previous
+   * scope.
+   */
+  static Local<Context> NewFunctionContext();
+
+  /**
+   * Returns the extension object of this context.
+   *
+   * For a scope context, the extension object is the object that was
+   * passed to NewScopeContext().
+   *
+   * For a function context, the extension object is the object that's
+   * used to hold the context's dynamically instantiated variables
+   * (e.g. by eval()).
+   */
+  Local<Object> GetExtensionObject();
+
+  /**
+   * Gets the previous context.
+   */
+  Local<Context> GetPrevious();
+
+  /**
+   * Gets the context corresponding to the top-most JavaScript caller.
+   */
+  static Local<Context> GetCallerContext();
+#endif
+
  private:
   friend class Value;
   friend class Script;

src/3rdparty/v8/src/api.cc

@@ -3835,6 +3835,87 @@ void Context::DetachGlobal() {
 }
 
 
+#ifdef QT_BUILD_SCRIPT_LIB
+Local<Context> v8::Context::NewScopeContext(v8::Handle<Object> scope_object) {
+  i::Isolate* isolate = i::Isolate::Current();
+  EnsureInitializedForIsolate(isolate, "v8::Context::NewScopeContext()");
+  ON_BAILOUT(isolate, "v8::Context::NewScopeContext()", return Local<Context>());
+  LOG_API(isolate, "Context::NewScopeContext");
+
+  ENTER_V8(isolate);
+  i::Handle<i::JSObject> obj = Utils::OpenHandle(*scope_object);
+  i::Handle<i::Context> current(isolate->context());
+  i::Handle<i::Context> context = isolate->factory()->NewWithContext(current, obj, /*is_catch_context=*/false);
+  return Utils::ToLocal(context);
+}
+
+
+Local<Context> v8::Context::NewFunctionContext() {
+  i::Isolate* isolate = i::Isolate::Current();
+  EnsureInitializedForIsolate(isolate, "v8::Context::NewFunctionContext()");
+  ON_BAILOUT(isolate, "v8::Context::NewFunctionContext()", return Local<Context>());
+  LOG_API(isolate, "Context::NewFunctionContext");
+
+  ENTER_V8(isolate);
+  i::Handle<i::JSFunction> closure(isolate->global_context()->closure());
+  i::Handle<i::Context> context = isolate->factory()->NewFunctionContext(i::Context::MIN_CONTEXT_SLOTS,
+                                                                         closure);
+  return Utils::ToLocal(context);
+}
+
+
+Local<Context> v8::Context::GetPrevious() {
+  i::Isolate* isolate = i::Isolate::Current();
+  if (IsDeadCheck(isolate, "v8::Context::GetPrevious()")) return Local<Context>();
+  ENTER_V8(isolate);
+  i::Handle<i::Context> env = Utils::OpenHandle(this);
+  if (env->IsGlobalContext()) return Local<Context>();
+  i::Context* previous = 0;
+  if (env->is_function_context())
+    previous = env->closure()->context();
+  else
+    previous = env->previous();
+  if (!previous) return Local<Context>();
+  i::Handle<i::Context> previous_handle(previous);
+  return Utils::ToLocal(previous_handle);
+}
+
+
+Local<Object> v8::Context::GetExtensionObject() {
+  i::Isolate* isolate = i::Isolate::Current();
+  if (IsDeadCheck(isolate, "v8::Context::GetExtensionObject()")) return Local<Object>();
+  ENTER_V8(isolate);
+  i::Handle<i::Context> env = Utils::OpenHandle(this);
+  if (!env->has_extension()) {
+      if (env->is_function_context()) {
+          // Create extension object on demand.
+          i::Handle<i::JSObject> ext = isolate->factory()->NewJSObject(
+              isolate->context_extension_function());
+          env->set_extension(*ext);
+      } else {
+          return Local<Object>();
+      }
+  }
+  i::Handle<i::Object> extension_handle(env->extension());
+  return Local<v8::Object>(ToApi<Object>(extension_handle));
+}
+
+
+v8::Local<v8::Context> Context::GetCallerContext()
+{
+  i::JavaScriptFrameIterator it;
+  if (it.done())
+      return Local<Context>();
+  i::JavaScriptFrame *frame = it.frame();
+  ASSERT(frame);
+  i::Context *context = (i::Context*)frame->context();
+  ASSERT(context);
+  i::Handle<i::Context> context_handle(context);
+  return Utils::ToLocal(context_handle);
+}
+#endif
+
+
 void Context::ReattachGlobal(Handle<Object> global_object) {
   i::Isolate* isolate = i::Isolate::Current();
   if (IsDeadCheck(isolate, "v8::Context::ReattachGlobal()")) return;