move constructors to new style callbacks

Source/bindings/v8/custom/V8ArrayBufferViewCustom.h

 /*
  * Copyright (C) 2009, 2011 Google Inc. 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
@@ skipping 31 matching lines @@
 namespace WebCore {
 
 const char tooLargeSize[] = "Size is too large (or is negative).";
 const char outOfRangeLengthAndOffset[] = "Index is out of range.";
 
 // Copy the elements from the source array to the typed destination array.
 // Returns true if it succeeded, otherwise returns false.
 bool copyElements(v8::Handle<v8::Object> destArray, v8::Handle<v8::Object> srcArray, uint32_t length, uint32_t offset, v8::Isolate*);
 
 template<class ArrayClass>
-v8::Handle<v8::Value> wrapArrayBufferView(const v8::Arguments& args, WrapperTypeInfo* type, ArrayClass array, v8::ExternalArrayType arrayType, bool hasIndexer)
+void wrapArrayBufferView(const v8::FunctionCallbackInfo<v8::Value>& args, WrapperTypeInfo* type, ArrayClass array, v8::ExternalArrayType arrayType, bool hasIndexer)
 {
     // Transform the holder into a wrapper object for the array.
     ASSERT(!hasIndexer || static_cast<int32_t>(array.get()->length()) >= 0);
     if (hasIndexer)
         args.Holder()->SetIndexedPropertiesToExternalArrayData(array.get()->baseAddress(), arrayType, array.get()->length());
     v8::Handle<v8::Object> wrapper = args.Holder();
     V8DOMWrapper::associateObjectWithWrapper(array.release(), type, wrapper, args.GetIsolate(), WrapperConfiguration::Independent);
-    return wrapper;
+    args.GetReturnValue().Set(wrapper);
 }
 
 // Template function used by the ArrayBufferView*Constructor callbacks.
 template<class ArrayClass, class ElementType>
-v8::Handle<v8::Value> constructWebGLArrayWithArrayBufferArgument(const v8::Arguments& args, WrapperTypeInfo* type, v8::ExternalArrayType arrayType, bool hasIndexer)
+void constructWebGLArrayWithArrayBufferArgument(const v8::FunctionCallbackInfo<v8::Value>& args, WrapperTypeInfo* type, v8::ExternalArrayType arrayType, bool hasIndexer)
 {
     ArrayBuffer* buf = V8ArrayBuffer::toNative(args[0]->ToObject());
-    if (!buf)
-        return throwTypeError("Could not convert argument 0 to a ArrayBuffer", args.GetIsolate());
+    if (!buf) {
+        throwTypeError("Could not convert argument 0 to a ArrayBuffer", args.GetIsolate());
+        return;
+    }
     bool ok;
     uint32_t offset = 0;
     int argLen = args.Length();
     if (argLen > 1) {
         offset = toUInt32(args[1], ok);
-        if (!ok)
-            return throwTypeError("Could not convert argument 1 to a number", args.GetIsolate());
+        if (!ok) {
+            throwTypeError("Could not convert argument 1 to a number", args.GetIsolate());
+            return;
+        }
     }
     uint32_t length = 0;
     if (argLen > 2) {
         length = toUInt32(args[2], ok);
-        if (!ok)
-            return throwTypeError("Could not convert argument 2 to a number", args.GetIsolate());
+        if (!ok) {
+            throwTypeError("Could not convert argument 2 to a number", args.GetIsolate());
+            return;
+        }
     } else {
-        if ((buf->byteLength() - offset) % sizeof(ElementType))
-            return throwError(v8RangeError, "ArrayBuffer length minus the byteOffset is not a multiple of the element size.", args.GetIsolate());
+        if ((buf->byteLength() - offset) % sizeof(ElementType)) {
+            throwError(v8RangeError, "ArrayBuffer length minus the byteOffset is not a multiple of the element size.", args.GetIsolate());
+            return;
+        }
         length = (buf->byteLength() - offset) / sizeof(ElementType);
     }
 
-    if (static_cast<int32_t>(length) < 0)
-        return throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+    if (static_cast<int32_t>(length) < 0) {
+        throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+        return;
+    }
 
     RefPtr<ArrayClass> array = ArrayClass::create(buf, offset, length);
-    if (!array)
-        return throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+    if (!array) {
+        throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+        return;
+    }
 
-    return wrapArrayBufferView(args, type, array, arrayType, hasIndexer);
+    wrapArrayBufferView(args, type, array, arrayType, hasIndexer);
 }
 
 // Template function used by the ArrayBufferView*Constructor callbacks.
 template<class ArrayClass, class JavaScriptWrapperArrayType, class ElementType>
-v8::Handle<v8::Value> constructWebGLArray(const v8::Arguments& args, WrapperTypeInfo* type, v8::ExternalArrayType arrayType)
+void constructWebGLArray(const v8::FunctionCallbackInfo<v8::Value>& args, WrapperTypeInfo* type, v8::ExternalArrayType arrayType)
 {
-    if (!args.IsConstructCall())
-        return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
+    if (!args.IsConstructCall()) {
+        throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
+        return;
+    }
 
-    if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
-        return args.Holder();
+    if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) {
+        args.GetReturnValue().Set(args.Holder());
+        return;
+    }
 
     int argLen = args.Length();
     if (!argLen) {
         // This happens when we return a previously constructed
         // ArrayBufferView, e.g. from the call to <Type>Array.subset().
         // The V8DOMWrapper will set the internal pointer in the
         // created object. Unfortunately it doesn't look like it's
         // possible to distinguish between this case and that where
         // the user calls "new <Type>Array()" from JavaScript. We must
         // construct an empty view to avoid crashes when fetching the
         // length.
         RefPtr<ArrayClass> array = ArrayClass::create(0);
         // Do not call SetIndexedPropertiesToExternalArrayData on this
         // object. Not only is there no point from a performance
         // perspective, but doing so causes errors in the subset() case.
-        return wrapArrayBufferView(args, type, array, arrayType, false);
+        wrapArrayBufferView(args, type, array, arrayType, false);
+        return;
     }
 
     // Supported constructors:
     // WebGL<T>Array(n) where n is an integer:
     //   -- create an empty array of n elements
     // WebGL<T>Array(arr) where arr is an array:
     //   -- create a WebGL<T>Array containing the contents of "arr"
     // WebGL<T>Array(buf, offset, length)
     //   -- create a WebGL<T>Array pointing to the ArrayBuffer
     //      "buf", starting at the specified offset, for the given
     //      length
 
     if (args[0]->IsNull()) {
         // Invalid first argument
-        return throwTypeError(0, args.GetIsolate());
+        throwTypeError(0, args.GetIsolate());
+        return;
     }
 
     // See whether the first argument is a ArrayBuffer.
-    if (V8ArrayBuffer::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))
-      return constructWebGLArrayWithArrayBufferArgument<ArrayClass, ElementType>(args, type, arrayType, true);
+    if (V8ArrayBuffer::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate()))) {
+        constructWebGLArrayWithArrayBufferArgument<ArrayClass, ElementType>(args, type, arrayType, true);
+        return;
+    }
 
     // See whether the first argument is the same type as impl. In that case,
     // we can simply memcpy data from source to impl.
     if (JavaScriptWrapperArrayType::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate()))) {
         ArrayClass* source = JavaScriptWrapperArrayType::toNative(args[0]->ToObject());
         uint32_t length = source->length();
 
-        if (static_cast<int32_t>(length) < 0)
-            return throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+        if (static_cast<int32_t>(length) < 0) {
+            throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+            return;
+        }
 
         RefPtr<ArrayClass> array = ArrayClass::createUninitialized(length);
-        if (!array.get())
-            return throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+        if (!array.get()) {
+            throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+            return;
+        }
 
         array->buffer()->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instance());
         v8::V8::AdjustAmountOfExternalAllocatedMemory(array->byteLength());
 
         memcpy(array->baseAddress(), source->baseAddress(), length * sizeof(ElementType));
 
-        return wrapArrayBufferView(args, type, array, arrayType, true);
+        wrapArrayBufferView(args, type, array, arrayType, true);
+        return;
     }
 
     uint32_t len = 0;
     v8::Handle<v8::Object> srcArray;
     bool doInstantiation = false;
 
     if (args[0]->IsObject()) {
         srcArray = args[0]->ToObject();
-        if (srcArray.IsEmpty())
-            return throwTypeError("Could not convert argument 0 to an array", args.GetIsolate());
+        if (srcArray.IsEmpty()) {
+            throwTypeError("Could not convert argument 0 to an array", args.GetIsolate());
+            return;
+        }
         v8::Local<v8::Value> val = srcArray->Get(v8::String::NewSymbol("length"));
         if (val.IsEmpty()) {
             // Exception thrown during fetch of length property.
-            return v8Undefined();
+            return;
         }
         len = toUInt32(val);
         doInstantiation = true;
     } else {
         bool ok = false;
         int32_t tempLength = toInt32(args[0], ok); // NaN/+inf/-inf returns 0, this is intended by WebIDL
         if (ok && tempLength >= 0) {
             len = static_cast<uint32_t>(tempLength);
             doInstantiation = true;
         }
     }
 
-    if (static_cast<int32_t>(len) < 0)
-        return throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+    if (static_cast<int32_t>(len) < 0) {
+        throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+        return;
+    }
 
     RefPtr<ArrayClass> array;
     if (doInstantiation) {
         if (srcArray.IsEmpty())
             array = ArrayClass::create(len);
         else
             array = ArrayClass::createUninitialized(len);
     }
 
-    if (!array.get())
-        return throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+    if (!array.get()) {
+        throwError(v8RangeError, tooLargeSize, args.GetIsolate());
+        return;
+    }
 
     if (doInstantiation) {
         array->buffer()->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instance());
         v8::V8::AdjustAmountOfExternalAllocatedMemory(array->byteLength());
     }
 
 
     // Transform the holder into a wrapper object for the array.
     args.Holder()->SetIndexedPropertiesToExternalArrayData(array.get()->baseAddress(), arrayType, array.get()->length());
 
     if (!srcArray.IsEmpty()) {
         bool copied = copyElements(args.Holder(), srcArray, len, 0, args.GetIsolate());
         if (!copied) {
             for (unsigned i = 0; i < len; i++) {
                 v8::Local<v8::Value> val = srcArray->Get(i);
                 if (val.IsEmpty()) {
                     // Exception thrown during fetch.
-                    return v8Undefined();
+                    return;
                 }
                 array->set(i, val->NumberValue());
             }
         }
     }
 
     v8::Handle<v8::Object> wrapper = args.Holder();
     V8DOMWrapper::associateObjectWithWrapper(array.release(), type, wrapper, args.GetIsolate(), WrapperConfiguration::Independent);
-    return wrapper;
+    args.GetReturnValue().Set(wrapper);
 }
 
 template <class CPlusPlusArrayType, class JavaScriptWrapperArrayType>
 v8::Handle<v8::Value> setWebGLArrayHelper(const v8::Arguments& args)
 {
     if (args.Length() < 1)
         return throwNotEnoughArgumentsError(args.GetIsolate());
 
     CPlusPlusArrayType* impl = JavaScriptWrapperArrayType::toNative(args.Holder());
 
@@ skipping 24 matching lines @@
         }
         return v8::Undefined();
     }
 
     return throwTypeError("Invalid argument", args.GetIsolate());
 }
 
 }
 
 #endif // V8ArrayBufferViewCustom_h