Inherit EventTarget interface instead of duplicating its code

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 29 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>
+template<class JavaScriptWrapperArrayType, class ArrayClass>
 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);
+    V8DOMWrapper::associateObjectWithWrapper<JavaScriptWrapperArrayType>(array.release(), type, wrapper, args.GetIsolate(), WrapperConfiguration::Independent);
     args.GetReturnValue().Set(wrapper);
 }
 
 // Template function used by the ArrayBufferView*Constructor callbacks.
-template<class ArrayClass, class ElementType>
+template<class ArrayClass, class ElementType, class JavaScriptWrapperArrayType>
 void constructWebGLArrayWithArrayBufferArgument(const v8::FunctionCallbackInfo<v8::Value>& args, WrapperTypeInfo* type, v8::ExternalArrayType arrayType, bool hasIndexer)
 {
     ArrayBuffer* buf = V8ArrayBuffer::toNative(args[0]->ToObject());
     if (!buf) {
         throwTypeError("Could not convert argument 0 to a ArrayBuffer", args.GetIsolate());
         return;
     }
     bool ok;
     uint32_t offset = 0;
     int argLen = args.Length();
@@ skipping 23 matching lines @@
         throwError(v8RangeError, tooLargeSize, args.GetIsolate());
         return;
     }
 
     RefPtr<ArrayClass> array = ArrayClass::create(buf, offset, length);
     if (!array) {
         throwError(v8RangeError, tooLargeSize, args.GetIsolate());
         return;
     }
 
-    wrapArrayBufferView(args, type, array, arrayType, hasIndexer);
+    wrapArrayBufferView<JavaScriptWrapperArrayType>(args, type, array, arrayType, hasIndexer);
 }
 
 // Template function used by the ArrayBufferView*Constructor callbacks.
 template<class ArrayClass, class JavaScriptWrapperArrayType, class ElementType>
 void constructWebGLArray(const v8::FunctionCallbackInfo<v8::Value>& args, WrapperTypeInfo* type, v8::ExternalArrayType arrayType)
 {
     if (!args.IsConstructCall()) {
         throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
         return;
     }
@@ skipping 10 matching lines @@
         // 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.
-        wrapArrayBufferView(args, type, array, arrayType, false);
+        wrapArrayBufferView<JavaScriptWrapperArrayType>(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
         throwTypeError(0, args.GetIsolate());
         return;
     }
 
     // See whether the first argument is a ArrayBuffer.
     if (V8ArrayBuffer::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate()))) {
-        constructWebGLArrayWithArrayBufferArgument<ArrayClass, ElementType>(args, type, arrayType, true);
+        constructWebGLArrayWithArrayBufferArgument<ArrayClass, ElementType, JavaScriptWrapperArrayType>(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) {
             throwError(v8RangeError, tooLargeSize, args.GetIsolate());
             return;
         }
 
         RefPtr<ArrayClass> array = ArrayClass::createUninitialized(length);
         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));
 
-        wrapArrayBufferView(args, type, array, arrayType, true);
+        wrapArrayBufferView<JavaScriptWrapperArrayType>(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()) {
@@ skipping 51 matching lines @@
                 if (val.IsEmpty()) {
                     // Exception thrown during fetch.
                     return;
                 }
                 array->set(i, val->NumberValue());
             }
         }
     }
 
     v8::Handle<v8::Object> wrapper = args.Holder();
-    V8DOMWrapper::associateObjectWithWrapper(array.release(), type, wrapper, args.GetIsolate(), WrapperConfiguration::Independent);
+    V8DOMWrapper::associateObjectWithWrapper<JavaScriptWrapperArrayType>(array.release(), type, wrapper, args.GetIsolate(), WrapperConfiguration::Independent);
     args.GetReturnValue().Set(wrapper);
 }
 
 template <class CPlusPlusArrayType, class JavaScriptWrapperArrayType>
 void setWebGLArrayHelper(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     if (args.Length() < 1) {
         throwNotEnoughArgumentsError(args.GetIsolate());
         return;
     }
@@ skipping 31 matching lines @@
         }
         return;
     }
 
     throwTypeError("Invalid argument", args.GetIsolate());
 }
 
 }
 
 #endif // V8ArrayBufferViewCustom_h