remove all old style callbacks - patch 3

test/cctest/test-log-stack-tracer.cc

 // Copyright 2011 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 74 matching lines @@
 }
 
 
 // --- T r a c e   E x t e n s i o n ---
 
 class TraceExtension : public v8::Extension {
  public:
   TraceExtension() : v8::Extension("v8/trace", kSource) { }
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<String> name);
-  static v8::Handle<v8::Value> Trace(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSTrace(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSEntrySP(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSEntrySPLevel2(const v8::Arguments& args);
+  static void Trace(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void JSTrace(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void JSEntrySP(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void JSEntrySPLevel2(const v8::FunctionCallbackInfo<v8::Value>& args);
  private:
-  static Address GetFP(const v8::Arguments& args);
+  static Address GetFP(const v8::FunctionCallbackInfo<v8::Value>& args);
   static const char* kSource;
 };
 
 
 const char* TraceExtension::kSource =
     "native function trace();"
     "native function js_trace();"
     "native function js_entry_sp();"
     "native function js_entry_sp_level2();";
 
 v8::Handle<v8::FunctionTemplate> TraceExtension::GetNativeFunction(
     v8::Handle<String> name) {
   if (name->Equals(String::New("trace"))) {
     return v8::FunctionTemplate::New(TraceExtension::Trace);
   } else if (name->Equals(String::New("js_trace"))) {
     return v8::FunctionTemplate::New(TraceExtension::JSTrace);
   } else if (name->Equals(String::New("js_entry_sp"))) {
     return v8::FunctionTemplate::New(TraceExtension::JSEntrySP);
   } else if (name->Equals(String::New("js_entry_sp_level2"))) {
     return v8::FunctionTemplate::New(TraceExtension::JSEntrySPLevel2);
   } else {
     CHECK(false);
     return v8::Handle<v8::FunctionTemplate>();
   }
 }
 
 
-Address TraceExtension::GetFP(const v8::Arguments& args) {
+Address TraceExtension::GetFP(const v8::FunctionCallbackInfo<v8::Value>& args) {
   // Convert frame pointer from encoding as smis in the arguments to a pointer.
   CHECK_EQ(2, args.Length());  // Ignore second argument on 32-bit platform.
 #if defined(V8_HOST_ARCH_32_BIT)
   Address fp = *reinterpret_cast<Address*>(*args[0]);
 #elif defined(V8_HOST_ARCH_64_BIT)
   int64_t low_bits = *reinterpret_cast<uint64_t*>(*args[0]) >> 32;
   int64_t high_bits = *reinterpret_cast<uint64_t*>(*args[1]);
   Address fp = reinterpret_cast<Address>(high_bits | low_bits);
 #else
 #error Host architecture is neither 32-bit nor 64-bit.
 #endif
   printf("Trace: %p\n", fp);
   return fp;
 }
 
 
-v8::Handle<v8::Value> TraceExtension::Trace(const v8::Arguments& args) {
+void TraceExtension::Trace(const v8::FunctionCallbackInfo<v8::Value>& args) {
   DoTrace(GetFP(args));
-  return v8::Undefined();
 }
 
 
-v8::Handle<v8::Value> TraceExtension::JSTrace(const v8::Arguments& args) {
+void TraceExtension::JSTrace(const v8::FunctionCallbackInfo<v8::Value>& args) {
   DoTraceHideCEntryFPAddress(GetFP(args));
-  return v8::Undefined();
 }
 
 
 static Address GetJsEntrySp() {
   CHECK_NE(NULL, i::Isolate::Current()->thread_local_top());
   return Isolate::js_entry_sp(i::Isolate::Current()->thread_local_top());
 }
 
 
-v8::Handle<v8::Value> TraceExtension::JSEntrySP(const v8::Arguments& args) {
+void TraceExtension::JSEntrySP(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_NE(0, GetJsEntrySp());
-  return v8::Undefined();
 }
 
 
-v8::Handle<v8::Value> TraceExtension::JSEntrySPLevel2(
-    const v8::Arguments& args) {
+void TraceExtension::JSEntrySPLevel2(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   const Address js_entry_sp = GetJsEntrySp();
   CHECK_NE(0, js_entry_sp);
   CompileRun("js_entry_sp();");
   CHECK_EQ(js_entry_sp, GetJsEntrySp());
-  return v8::Undefined();
 }
 
 
 static TraceExtension kTraceExtension;
 v8::DeclareExtension kTraceExtensionDeclaration(&kTraceExtension);
 
 
 static bool IsAddressWithinFuncCode(JSFunction* function, Address addr) {
   i::Code* code = function->code();
   return code->contains(addr);
 }
 
 static bool IsAddressWithinFuncCode(const char* func_name, Address addr) {
   v8::Local<v8::Value> func = CcTest::env()->Global()->Get(v8_str(func_name));
   CHECK(func->IsFunction());
   JSFunction* js_func = JSFunction::cast(*v8::Utils::OpenHandle(*func));
   return IsAddressWithinFuncCode(js_func, addr);
 }
 
 
 // This C++ function is called as a constructor, to grab the frame pointer
 // from the calling function.  When this function runs, the stack contains
 // a C_Entry frame and a Construct frame above the calling function's frame.
-static v8::Handle<Value> construct_call(const v8::Arguments& args) {
+static void construct_call(const v8::FunctionCallbackInfo<v8::Value>& args) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
   i::StackFrameIterator frame_iterator(isolate);
   CHECK(frame_iterator.frame()->is_exit());
   frame_iterator.Advance();
   CHECK(frame_iterator.frame()->is_construct());
   frame_iterator.Advance();
   i::StackFrame* calling_frame = frame_iterator.frame();
   CHECK(calling_frame->is_java_script());
 
 #if defined(V8_HOST_ARCH_32_BIT)
   int32_t low_bits = reinterpret_cast<int32_t>(calling_frame->fp());
   args.This()->Set(v8_str("low_bits"), v8_num(low_bits >> 1));
 #elif defined(V8_HOST_ARCH_64_BIT)
   uint64_t fp = reinterpret_cast<uint64_t>(calling_frame->fp());
   int32_t low_bits = static_cast<int32_t>(fp & 0xffffffff);
   int32_t high_bits = static_cast<int32_t>(fp >> 32);
   args.This()->Set(v8_str("low_bits"), v8_num(low_bits));
   args.This()->Set(v8_str("high_bits"), v8_num(high_bits));
 #else
 #error Host architecture is neither 32-bit nor 64-bit.
 #endif
-  return args.This();
+  args.GetReturnValue().Set(args.This());
 }
 
 
 // Use the API to create a JSFunction object that calls the above C++ function.
 void CreateFramePointerGrabberConstructor(const char* constructor_name) {
     Local<v8::FunctionTemplate> constructor_template =
         v8::FunctionTemplate::New(construct_call);
     constructor_template->SetClassName(v8_str("FPGrabber"));
     Local<Function> fun = constructor_template->GetFunction();
     CcTest::env()->Global()->Set(v8_str(constructor_name), fun);
@@ skipping 155 matching lines @@
   CcTest::InitializeVM(TRACE_EXTENSION);
   v8::HandleScope scope(CcTest::isolate());
   CHECK_EQ(0, GetJsEntrySp());
   CompileRun("a = 1; b = a + 1;");
   CHECK_EQ(0, GetJsEntrySp());
   CompileRun("js_entry_sp();");
   CHECK_EQ(0, GetJsEntrySp());
   CompileRun("js_entry_sp_level2();");
   CHECK_EQ(0, GetJsEntrySp());
 }