make isolate accessible from returnvalue

test/cctest/test-api.cc

 // Copyright 2012 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 792 matching lines @@
   global->Set(v8_str("pi"), v8_num(3.1415926));
   Local<Value> pi = global->Get(v8_str("pi"));
   CHECK_EQ(3.1415926, pi->NumberValue());
 }
 
 
 template<typename T>
 static void CheckReturnValue(const T& t) {
   v8::ReturnValue<v8::Value> rv = t.GetReturnValue();
   i::Object** o = *reinterpret_cast<i::Object***>(&rv);
-  CHECK_EQ(t.GetIsolate(), v8::Isolate::GetCurrent());
+  CHECK_EQ(v8::Isolate::GetCurrent(), t.GetIsolate());
+  CHECK_EQ(t.GetIsolate(), rv.GetIsolate());
   CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
 }
 
 static v8::Handle<Value> handle_call(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(args);
   args.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(102);
 }
 
@@ skipping 96 matching lines @@
     for (int i = 0; i < 30; i++) {
       CHECK_EQ(102, script->Run()->Int32Value());
     }
   }
   // Use SetCallHandler to initialize a function template, should work like the
   // previous one.
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
-    fun_templ->SetCallHandler(handler);
+    fun_templ->SetCallHandler(handler_2);
     Local<Function> fun = fun_templ->GetFunction();
     env->Global()->Set(v8_str("obj"), fun);
     Local<Script> script = v8_compile("obj()");
     for (int i = 0; i < 30; i++) {
       CHECK_EQ(102, script->Run()->Int32Value());
     }
   }
 }
 
 
@@ skipping 89 matching lines @@
 static const int32_t kFastReturnValueInt32 = 471;
 static const uint32_t kFastReturnValueUint32 = 571;
 static const double kFastReturnValueDouble = 2.7;
 // variable return values
 static bool fast_return_value_bool = false;
 static bool fast_return_value_void_is_null = false;
 
 template<>
 void FastReturnValueCallback<int32_t>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  info.GetReturnValue().Set(info.GetIsolate(), kFastReturnValueInt32);
+  CheckReturnValue(info);
+  info.GetReturnValue().Set(kFastReturnValueInt32);
 }
 
 template<>
 void FastReturnValueCallback<uint32_t>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  info.GetReturnValue().Set(info.GetIsolate(), kFastReturnValueUint32);
+  CheckReturnValue(info);
+  info.GetReturnValue().Set(kFastReturnValueUint32);
 }
 
 template<>
 void FastReturnValueCallback<double>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  info.GetReturnValue().Set(info.GetIsolate(), kFastReturnValueDouble);
+  CheckReturnValue(info);
+  info.GetReturnValue().Set(kFastReturnValueDouble);
 }
 
 template<>
 void FastReturnValueCallback<bool>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  info.GetReturnValue().Set(info.GetIsolate(), fast_return_value_bool);
+  CheckReturnValue(info);
+  info.GetReturnValue().Set(fast_return_value_bool);
 }
 
 template<>
 void FastReturnValueCallback<void>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
+  CheckReturnValue(info);
   if (fast_return_value_void_is_null) {
-    info.GetReturnValue().SetNull(info.GetIsolate());
+    info.GetReturnValue().SetNull();
   } else {
-    info.GetReturnValue().SetUndefined(info.GetIsolate());
+    info.GetReturnValue().SetUndefined();
   }
 }
 
 template<typename T>
 Handle<Value> TestFastReturnValues() {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
   v8::FunctionCallback callback = &FastReturnValueCallback<T>;
   object_template->Set("callback", v8::FunctionTemplate::New(callback));
@@ skipping 18236 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32