remove all old style callbacks - patch 3

test/cctest/test-decls.cc

 // Copyright 2007-2008 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 70 matching lines @@
   virtual void PostInitializeContext(Handle<Context> context) {}
 
   // Get the holder for the interceptor. Default to the instance template
   // but may be overwritten.
   virtual Local<ObjectTemplate> GetHolder(Local<FunctionTemplate> function) {
     return function->InstanceTemplate();
   }
 
   // The handlers are called as static functions that forward
   // to the instance specific virtual methods.
-  static v8::Handle<Value> HandleGet(Local<String> key,
-                                     const AccessorInfo& info);
-  static v8::Handle<Value> HandleSet(Local<String> key,
-                                     Local<Value> value,
-                                     const AccessorInfo& info);
-  static v8::Handle<Integer> HandleQuery(Local<String> key,
-                                         const AccessorInfo& info);
+  static void HandleGet(Local<String> key,
+                        const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void HandleSet(Local<String> key,
+                        Local<Value> value,
+                        const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void HandleQuery(Local<String> key,
+                          const v8::PropertyCallbackInfo<v8::Integer>& info);
 
  private:
   bool is_initialized_;
   Persistent<Context> context_;
 
   int get_count_;
   int set_count_;
   int query_count_;
 
-  static DeclarationContext* GetInstance(const AccessorInfo& info);
+  static DeclarationContext* GetInstance(Local<Value> data);
 };
 
 
 DeclarationContext::DeclarationContext()
     : is_initialized_(false), get_count_(0), set_count_(0), query_count_(0) {
   // Do nothing.
 }
 
 
 void DeclarationContext::InitializeIfNeeded() {
@@ skipping 48 matching lines @@
     CHECK(expectations == EXPECT_EXCEPTION);
     CHECK(catcher.HasCaught());
     if (!value.IsEmpty()) {
       CHECK_EQ(value, catcher.Exception());
     }
   }
   HEAP->CollectAllAvailableGarbage();  // Clean slate for the next test.
 }
 
 
-v8::Handle<Value> DeclarationContext::HandleGet(Local<String> key,
-                                                const AccessorInfo& info) {
-  DeclarationContext* context = GetInstance(info);
+void DeclarationContext::HandleGet(
+    Local<String> key,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  DeclarationContext* context = GetInstance(info.Data());
   context->get_count_++;
-  return context->Get(key);
+  info.GetReturnValue().Set(context->Get(key));
 }
 
 
-v8::Handle<Value> DeclarationContext::HandleSet(Local<String> key,
-                                                Local<Value> value,
-                                                const AccessorInfo& info) {
-  DeclarationContext* context = GetInstance(info);
+void DeclarationContext::HandleSet(
+    Local<String> key,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  DeclarationContext* context = GetInstance(info.Data());
   context->set_count_++;
-  return context->Set(key, value);
+  info.GetReturnValue().Set(context->Set(key, value));
 }
 
 
-v8::Handle<Integer> DeclarationContext::HandleQuery(Local<String> key,
-                                                    const AccessorInfo& info) {
-  DeclarationContext* context = GetInstance(info);
+void DeclarationContext::HandleQuery(
+    Local<String> key,
+    const v8::PropertyCallbackInfo<v8::Integer>& info) {
+  DeclarationContext* context = GetInstance(info.Data());
   context->query_count_++;
-  return context->Query(key);
+  info.GetReturnValue().Set(context->Query(key));
 }
 
 
-DeclarationContext* DeclarationContext::GetInstance(const AccessorInfo& info) {
-  void* value = External::Cast(*info.Data())->Value();
+DeclarationContext* DeclarationContext::GetInstance(Local<Value> data) {
+  void* value = Local<External>::Cast(data)->Value();
   return static_cast<DeclarationContext*>(value);
 }
 
 
 v8::Handle<Value> DeclarationContext::Get(Local<String> key) {
   return v8::Handle<Value>();
 }
 
 
 v8::Handle<Value> DeclarationContext::Set(Local<String> key,
@@ skipping 630 matching lines @@
       SimpleContext context;
       context.Check(firsts[i], EXPECT_RESULT, Number::New(1));
       // TODO(rossberg): All tests should actually be errors in Harmony,
       // but we currently do not detect the cases where the first declaration
       // is not lexical.
       context.Check(seconds[j],
                     i < 2 ? EXPECT_RESULT : EXPECT_ERROR, Number::New(2));
     }
   }
 }