Cleanup of Isolate::Current() usage in api.cc.

src/api.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1370 matching lines @@
   ENTER_V8;
   Local<Script> generic = New(source, origin, pre_data, script_data);
   if (generic.IsEmpty())
     return generic;
   i::Handle<i::Object> obj = Utils::OpenHandle(*generic);
   i::Handle<i::SharedFunctionInfo> function =
       i::Handle<i::SharedFunctionInfo>(i::SharedFunctionInfo::cast(*obj));
   i::Handle<i::JSFunction> result =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
           function,
-          i::Isolate::Current()->global_context());
+          isolate->global_context());
   return Local<Script>(ToApi<Script>(result));
 }
 
 
 Local<Script> Script::Compile(v8::Handle<String> source,
                               v8::Handle<Value> file_name,
                               v8::Handle<String> script_data) {
   ScriptOrigin origin(file_name);
   return Compile(source, &origin, 0, script_data);
 }
 
 
 Local<Value> Script::Run() {
   i::Isolate* isolate = i::Isolate::Current();
   ON_BAILOUT(isolate, "v8::Script::Run()", return Local<Value>());
   LOG_API(isolate, "Script::Run");
   ENTER_V8;
   i::Object* raw_result = NULL;
   {
     HandleScope scope;
     i::Handle<i::Object> obj = Utils::OpenHandle(this);
     i::Handle<i::JSFunction> fun;
     if (obj->IsSharedFunctionInfo()) {
       i::Handle<i::SharedFunctionInfo>
           function_info(i::SharedFunctionInfo::cast(*obj));
       fun = isolate->factory()->NewFunctionFromSharedFunctionInfo(
-          function_info, i::Isolate::Current()->global_context());
+          function_info, isolate->global_context());
     } else {
       fun = i::Handle<i::JSFunction>(i::JSFunction::cast(*obj));
     }
     EXCEPTION_PREAMBLE();
     i::Handle<i::Object> receiver(
-        i::Isolate::Current()->context()->global_proxy());
+        isolate->context()->global_proxy());
     i::Handle<i::Object> result =
         i::Execution::Call(fun, receiver, 0, NULL, &has_pending_exception);
     EXCEPTION_BAILOUT_CHECK(Local<Value>());
     raw_result = *result;
   }
   i::Handle<i::Object> result(raw_result);
   return Utils::ToLocal(result);
 }
 
 
@@ skipping 51 matching lines @@
       message_(i::Smi::FromInt(0)),
       is_verbose_(false),
       can_continue_(true),
       capture_message_(true),
       rethrow_(false) {
   i::Isolate::Current()->RegisterTryCatchHandler(this);
 }
 
 
 v8::TryCatch::~TryCatch() {
+  i::Isolate* isolate = i::Isolate::Current();
   if (rethrow_) {
     v8::HandleScope scope;
     v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(Exception());
-    i::Isolate::Current()->UnregisterTryCatchHandler(this);
+    isolate->UnregisterTryCatchHandler(this);
     v8::ThrowException(exc);
   } else {
-    i::Isolate::Current()->UnregisterTryCatchHandler(this);
+    isolate->UnregisterTryCatchHandler(this);
   }
 }
 
 
 bool v8::TryCatch::HasCaught() const {
   return !reinterpret_cast<i::Object*>(exception_)->IsTheHole();
 }
 
 
 bool v8::TryCatch::CanContinue() const {
@@ skipping 517 matching lines @@
 
 bool Value::IsRegExp() const {
   if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsRegExp()")) return false;
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   return obj->IsJSRegExp();
 }
 
 
 Local<String> Value::ToString() const {
   i::Isolate* isolate = i::Isolate::Current();
-  if (IsDeadCheck(i::Isolate::Current(), "v8::Value::ToString()")) {
+  if (IsDeadCheck(isolate, "v8::Value::ToString()")) {
     return Local<String>();
   }
   LOG_API(isolate, "ToString");
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   i::Handle<i::Object> str;
   if (obj->IsString()) {
     str = obj;
   } else {
     ENTER_V8;
     EXCEPTION_PREAMBLE();
@@ skipping 37 matching lines @@
     EXCEPTION_PREAMBLE();
     val = i::Execution::ToObject(obj, &has_pending_exception);
     EXCEPTION_BAILOUT_CHECK(Local<v8::Object>());
   }
   return Local<v8::Object>(ToApi<Object>(val));
 }
 
 
 Local<Boolean> Value::ToBoolean() const {
   i::Isolate* isolate = i::Isolate::Current();
-  if (IsDeadCheck(i::Isolate::Current(), "v8::Value::ToBoolean()")) {
+  if (IsDeadCheck(isolate, "v8::Value::ToBoolean()")) {
     return Local<Boolean>();
   }
   LOG_API(isolate, "ToBoolean");
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   if (obj->IsBoolean()) {
     return Local<Boolean>(ToApi<Boolean>(obj));
   } else {
     ENTER_V8;
     i::Handle<i::Object> val = i::Execution::ToBoolean(obj);
     return Local<Boolean>(ToApi<Boolean>(val));
@@ skipping 1541 matching lines @@
 
     // Restore the access check info on the global template.
     if (!global_template.IsEmpty()) {
       ASSERT(!global_constructor.is_null());
       ASSERT(!proxy_constructor.is_null());
       global_constructor->set_access_check_info(
           proxy_constructor->access_check_info());
       global_constructor->set_needs_access_check(
           proxy_constructor->needs_access_check());
     }
-    i::Isolate::Current()->runtime_profiler()->Reset();
+    isolate->runtime_profiler()->Reset();
   }
   // Leave V8.
 
   if (env.is_null())
     return Persistent<Context>();
   return Persistent<Context>(Utils::ToLocal(env));
 }
 
 
 void v8::Context::SetSecurityToken(Handle<Value> token) {
@@ skipping 34 matching lines @@
   return env->has_out_of_memory();
 }
 
 
 bool Context::InContext() {
   return i::Isolate::Current()->context() != NULL;
 }
 
 
 v8::Local<v8::Context> Context::GetEntered() {
-  if (IsDeadCheck(i::Isolate::Current(), "v8::Context::GetEntered()")) {
+  i::Isolate* isolate = i::Isolate::Current();
+  if (IsDeadCheck(isolate, "v8::Context::GetEntered()")) {
     return Local<Context>();
   }
   i::Handle<i::Object> last =
-      i::Isolate::Current()->handle_scope_implementer()->LastEnteredContext();
+      isolate->handle_scope_implementer()->LastEnteredContext();
   if (last.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(last);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Context> Context::GetCurrent() {
-  if (IsDeadCheck(i::Isolate::Current(), "v8::Context::GetCurrent()")) {
+  i::Isolate* isolate = i::Isolate::Current();
+  if (IsDeadCheck(isolate, "v8::Context::GetCurrent()")) {
     return Local<Context>();
   }
-  i::Handle<i::Object> current = i::Isolate::Current()->global_context();
+  i::Handle<i::Object> current = isolate->global_context();
   if (current.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(current);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Context> Context::GetCalling() {
-  if (IsDeadCheck(i::Isolate::Current(), "v8::Context::GetCalling()")) {
+  i::Isolate* isolate = i::Isolate::Current();
+  if (IsDeadCheck(isolate, "v8::Context::GetCalling()")) {
     return Local<Context>();
   }
   i::Handle<i::Object> calling =
-      i::Isolate::Current()->GetCallingGlobalContext();
+      isolate->GetCallingGlobalContext();
   if (calling.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(calling);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Object> Context::Global() {
   if (IsDeadCheck(i::Isolate::Current(), "v8::Context::Global()")) {
     return Local<v8::Object>();
   }
   i::Object** ctx = reinterpret_cast<i::Object**>(this);
   i::Handle<i::Context> context =
       i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx));
   i::Handle<i::Object> global(context->global_proxy());
   return Utils::ToLocal(i::Handle<i::JSObject>::cast(global));
 }
 
 
 void Context::DetachGlobal() {
-  if (IsDeadCheck(i::Isolate::Current(), "v8::Context::DetachGlobal()")) return;
+  i::Isolate* isolate = i::Isolate::Current();
+  if (IsDeadCheck(isolate, "v8::Context::DetachGlobal()")) return;
   ENTER_V8;
   i::Object** ctx = reinterpret_cast<i::Object**>(this);
   i::Handle<i::Context> context =
       i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx));
-  i::Isolate::Current()->bootstrapper()->DetachGlobal(context);
+  isolate->bootstrapper()->DetachGlobal(context);
 }
 
 
 void Context::ReattachGlobal(Handle<Object> global_object) {
   i::Isolate* isolate = i::Isolate::Current();
   if (IsDeadCheck(isolate, "v8::Context::ReattachGlobal()")) return;
   ENTER_V8;
   i::Object** ctx = reinterpret_cast<i::Object**>(this);
   i::Handle<i::Context> context =
       i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx));
@@ skipping 290 matching lines @@
   return !shape.IsExternal();
 }
 
 
 Local<v8::Object> v8::Object::New() {
   i::Isolate* isolate = i::Isolate::Current();
   EnsureInitializedForIsolate(isolate, "v8::Object::New()");
   LOG_API(isolate, "Object::New");
   ENTER_V8;
   i::Handle<i::JSObject> obj =
-      isolate->factory()->NewJSObject(i::Isolate::Current()->object_function());
+      isolate->factory()->NewJSObject(isolate->object_function());
   return Utils::ToLocal(obj);
 }
 
 
 Local<v8::Value> v8::Date::New(double time) {
   i::Isolate* isolate = i::Isolate::Current();
   EnsureInitializedForIsolate(isolate, "v8::Date::New()");
   LOG_API(isolate, "Date::New");
   if (isnan(time)) {
     // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
@@ skipping 454 matching lines @@
 
 
 int V8::GetCurrentThreadId() {
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
   EnsureInitialized("V8::GetCurrentThreadId()");
   return i::Isolate::Current()->thread_id();
 }
 
 
 void V8::TerminateExecution(int thread_id) {
-  if (!i::Isolate::Current()->IsInitialized()) return;
+  i::Isolate* isolate = i::Isolate::Current();
+  if (!isolate->IsInitialized()) return;
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
-  i::Isolate* isolate = i::Isolate::Current();
   // If the thread_id identifies the current thread just terminate
   // execution right away.  Otherwise, ask the thread manager to
   // terminate the thread with the given id if any.
   if (thread_id == isolate->thread_id()) {
     isolate->stack_guard()->TerminateExecution();
   } else {
     isolate->thread_manager()->TerminateExecution(thread_id);
   }
 }
 
 
 void V8::TerminateExecution(Isolate* isolate) {
   // If no isolate is supplied, use the default isolate.
   if (isolate != NULL) {
     reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->TerminateExecution();
   } else {
     i::Isolate::GetDefaultIsolateStackGuard()->TerminateExecution();
   }
 }
 
 
 bool V8::IsExecutionTerminating() {
-  if (!i::Isolate::Current()->IsInitialized()) return false;
-  if (i::Isolate::Current()->has_scheduled_exception()) {
-    return i::Isolate::Current()->scheduled_exception() ==
+  i::Isolate* isolate = i::Isolate::Current();
+  if (!isolate->IsInitialized()) return false;
+  if (isolate->has_scheduled_exception()) {
+    return isolate->scheduled_exception() ==
         HEAP->termination_exception();
   }
   return false;
 }
 
 
 Isolate* Isolate::GetCurrent() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
   return reinterpret_cast<Isolate*>(isolate);
 }
@@ skipping 296 matching lines @@
   EnsureInitialized("v8::Debug::SetMessageHandler");
   ENTER_V8;
   i::Isolate* isolate = i::Isolate::Current();
   // Message handler thread not supported any more. Parameter temporally left in
   // the API for client compatability reasons.
   CHECK(!message_handler_thread);
 
   // TODO(sgjesse) support the old message handler API through a simple wrapper.
   isolate->set_message_handler(handler);
   if (handler != NULL) {
-    i::Isolate::Current()->debugger()->SetMessageHandler(MessageHandlerWrapper);
+    isolate->debugger()->SetMessageHandler(MessageHandlerWrapper);
   } else {
-    i::Isolate::Current()->debugger()->SetMessageHandler(NULL);
+    isolate->debugger()->SetMessageHandler(NULL);
   }
 }
 
 
 void Debug::SetMessageHandler2(v8::Debug::MessageHandler2 handler) {
   EnsureInitialized("v8::Debug::SetMessageHandler");
   ENTER_V8;
   i::Isolate::Current()->debugger()->SetMessageHandler(handler);
 }
 
@@ skipping 32 matching lines @@
 
 Local<Value> Debug::Call(v8::Handle<v8::Function> fun,
                          v8::Handle<v8::Value> data) {
   i::Isolate* isolate = i::Isolate::Current();
   if (!isolate->IsInitialized()) return Local<Value>();
   ON_BAILOUT(isolate, "v8::Debug::Call()", return Local<Value>());
   ENTER_V8;
   i::Handle<i::Object> result;
   EXCEPTION_PREAMBLE();
   if (data.IsEmpty()) {
-    result = i::Isolate::Current()->debugger()->Call(
+    result = isolate->debugger()->Call(
         Utils::OpenHandle(*fun),
         isolate->factory()->undefined_value(),
         &has_pending_exception);
   } else {
-    result = i::Isolate::Current()->debugger()->Call(Utils::OpenHandle(*fun),
+    result = isolate->debugger()->Call(Utils::OpenHandle(*fun),
                                                      Utils::OpenHandle(*data),
                                                      &has_pending_exception);
   }
   EXCEPTION_BAILOUT_CHECK(Local<Value>());
   return Utils::ToLocal(result);
 }
 
 
 Local<Value> Debug::GetMirror(v8::Handle<v8::Value> obj) {
   i::Isolate* isolate = i::Isolate::Current();
   if (!isolate->IsInitialized()) return Local<Value>();
   ON_BAILOUT(isolate, "v8::Debug::GetMirror()", return Local<Value>());
   ENTER_V8;
   v8::HandleScope scope;
-  i::Debug* isolate_debug = i::Isolate::Current()->debug();
+  i::Debug* isolate_debug = isolate->debug();
   isolate_debug->Load();
   i::Handle<i::JSObject> debug(isolate_debug->debug_context()->global());
   i::Handle<i::String> name =
       isolate->factory()->LookupAsciiSymbol("MakeMirror");
   i::Handle<i::Object> fun_obj = i::GetProperty(debug, name);
   i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(fun_obj);
   v8::Handle<v8::Function> v8_fun = Utils::ToLocal(fun);
   const int kArgc = 1;
   v8::Handle<v8::Value> argv[kArgc] = { obj };
   EXCEPTION_PREAMBLE();
@@ skipping 677 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal