Cutover v8 to use new style callbacks internally

src/arguments.h

 // 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 134 matching lines @@
   F(IndexedPropertyGetter, IndexedPropertyGetterCallback) \
   F(IndexedPropertySetter, IndexedPropertySetterCallback) \
   F(IndexedPropertyQuery, IndexedPropertyQueryCallback) \
   F(IndexedPropertyDeleter, IndexedPropertyDeleterCallback) \
   F(IndexedPropertyEnumerator, IndexedPropertyEnumeratorCallback) \
 
 
 // TODO(dcarney): Remove this class when old callbacks are gone.
 class CallbackTable {
  public:
-  // TODO(dcarney): Flip this when it makes sense for performance.
-  static const bool kStoreVoidFunctions = true;
+  static const bool kStoreVoidFunctions = false;
   static inline bool ReturnsVoid(Isolate* isolate, void* function) {
     CallbackTable* table = isolate->callback_table();
     bool contains =
         table != NULL &&
         table->map_.occupancy() != 0 &&
         table->Contains(function);
     return contains == kStoreVoidFunctions;
   }
 
   STATIC_ASSERT(sizeof(intptr_t) == sizeof(AccessorGetterCallback));
 
   template<typename F>
   static inline void* FunctionToVoidPtr(F function) {
     return reinterpret_cast<void*>(reinterpret_cast<intptr_t>(function));
   }
 
 #define WRITE_REGISTER(OldFunction, NewFunction)                    \
-  static OldFunction Register(Isolate* isolate, NewFunction f) {    \
-    InsertCallback(isolate, FunctionToVoidPtr(f), true);            \
-    return reinterpret_cast<OldFunction>(f);                        \
+  static NewFunction Register(Isolate* isolate, OldFunction f) {    \
+    InsertCallback(isolate, FunctionToVoidPtr(f), false);           \
+    return reinterpret_cast<NewFunction>(f);                        \
   }                                                                 \
                                                                     \
-  static OldFunction Register(Isolate* isolate, OldFunction f) {    \
-    InsertCallback(isolate, FunctionToVoidPtr(f), false);           \
+  static NewFunction Register(Isolate* isolate, NewFunction f) {    \
+    InsertCallback(isolate, FunctionToVoidPtr(f), true);            \
     return f;                                                       \
   }
   FOR_EACH_CALLBACK_TABLE_MAPPING(WRITE_REGISTER)
 #undef WRITE_REGISTER
 
  private:
   CallbackTable();
   bool Contains(void* function);
   static void InsertCallback(Isolate* isolate,
                              void* function,
@@ skipping 156 matching lines @@
   return __RT_impl_##Name(args, isolate);                             \
 }                                                                     \
 static Type __RT_impl_##Name(Arguments args, Isolate* isolate)
 
 #define RUNTIME_ARGUMENTS(isolate, args) \
   args.length(), args.arguments(), isolate
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARGUMENTS_H_