Simplify the interface of PropertyCallbackArguments

src/api-arguments.cc

Index: src/api-arguments.cc
diff --git a/src/api-arguments.cc b/src/api-arguments.cc
index fabfd49914413c139ee188dc2fb83d9d694523b7..c4b698c5a2146f872f17cfa6a52029c191dab027 100644
--- a/src/api-arguments.cc
+++ b/src/api-arguments.cc
@@ -4,82 +4,28 @@
 
 #include "src/api-arguments.h"
 
-#include "src/api.h"
-#include "src/vm-state-inl.h"
-
 namespace v8 {
 namespace internal {
 
-template <typename T>
-template <typename V>
-v8::Local<V> CustomArguments<T>::GetReturnValue(Isolate* isolate) {
-  // Check the ReturnValue.
-  Object** handle = &this->begin()[kReturnValueOffset];
-  // Nothing was set, return empty handle as per previous behaviour.
-  if ((*handle)->IsTheHole()) return v8::Local<V>();
-  return Utils::Convert<Object, V>(Handle<Object>(handle));
-}
-
-v8::Local<v8::Value> FunctionCallbackArguments::Call(FunctionCallback f) {
+Handle<Object> FunctionCallbackArguments::Call(FunctionCallback f) {
   Isolate* isolate = this->isolate();
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f));
   FunctionCallbackInfo<v8::Value> info(begin(), argv_, argc_,
                                        is_construct_call_);
   f(info);
-  return GetReturnValue<v8::Value>(isolate);
+  return GetReturnValue<Object>(isolate);
 }
 
-#define WRITE_CALL_0(Function, ReturnValue)                            \
-  v8::Local<ReturnValue> PropertyCallbackArguments::Call(Function f) { \
-    Isolate* isolate = this->isolate();                                \
-    VMState<EXTERNAL> state(isolate);                                  \
-    ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f));       \
-    PropertyCallbackInfo<ReturnValue> info(begin());                   \
-    f(info);                                                           \
-    return GetReturnValue<ReturnValue>(isolate);                       \
-  }
-
-#define WRITE_CALL_1(Function, ReturnValue, Arg1)                     \
-  v8::Local<ReturnValue> PropertyCallbackArguments::Call(Function f,  \
-                                                         Arg1 arg1) { \
-    Isolate* isolate = this->isolate();                               \
-    VMState<EXTERNAL> state(isolate);                                 \
-    ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f));      \
-    PropertyCallbackInfo<ReturnValue> info(begin());                  \
-    f(arg1, info);                                                    \
-    return GetReturnValue<ReturnValue>(isolate);                      \
-  }
-
-#define WRITE_CALL_2(Function, ReturnValue, Arg1, Arg2)          \
-  v8::Local<ReturnValue> PropertyCallbackArguments::Call(        \
-      Function f, Arg1 arg1, Arg2 arg2) {                        \
-    Isolate* isolate = this->isolate();                          \
-    VMState<EXTERNAL> state(isolate);                            \
-    ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \
-    PropertyCallbackInfo<ReturnValue> info(begin());             \
-    f(arg1, arg2, info);                                         \
-    return GetReturnValue<ReturnValue>(isolate);                 \
-  }
-
-#define WRITE_CALL_2_VOID(Function, ReturnValue, Arg1, Arg2)               \
-  void PropertyCallbackArguments::Call(Function f, Arg1 arg1, Arg2 arg2) { \
-    Isolate* isolate = this->isolate();                                    \
-    VMState<EXTERNAL> state(isolate);                                      \
-    ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f));           \
-    PropertyCallbackInfo<ReturnValue> info(begin());                       \
-    f(arg1, arg2, info);                                                   \
-  }
-
-FOR_EACH_CALLBACK_TABLE_MAPPING_0(WRITE_CALL_0)
-FOR_EACH_CALLBACK_TABLE_MAPPING_1(WRITE_CALL_1)
-FOR_EACH_CALLBACK_TABLE_MAPPING_2(WRITE_CALL_2)
-FOR_EACH_CALLBACK_TABLE_MAPPING_2_VOID_RETURN(WRITE_CALL_2_VOID)
-
-#undef WRITE_CALL_0
-#undef WRITE_CALL_1
-#undef WRITE_CALL_2
-#undef WRITE_CALL_2_VOID
+Handle<JSObject> PropertyCallbackArguments::Call(
+    IndexedPropertyEnumeratorCallback f) {
+  Isolate* isolate = this->isolate();
+  VMState<EXTERNAL> state(isolate);
+  ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f));
+  PropertyCallbackInfo<v8::Array> info(begin());
+  f(info);
+  return GetReturnValue<JSObject>(isolate);
+}
 
 }  // namespace internal
 }  // namespace v8