Use upstream V8Proxy and V8Utilities

webkit/port/bindings/v8/V8NPObject.cpp

 /*
 * Copyright (C) 2006, 2007, 2008, 2009 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 45 matching lines @@
 // FIXME: need comments.
 // Params: holder could be HTMLEmbedElement or NPObject
 static v8::Handle<v8::Value> npObjectInvokeImpl(const v8::Arguments& args, InvokeFunctionType functionId)
 {
     NPObject* npObject;
 
     // These three types are subtypes of HTMLPlugInElement.
     if (V8HTMLAppletElement::HasInstance(args.Holder()) || V8HTMLEmbedElement::HasInstance(args.Holder())
         || V8HTMLObjectElement::HasInstance(args.Holder())) {
         // The holder object is a subtype of HTMLPlugInElement.
-        HTMLPlugInElement* element = V8Proxy::DOMWrapperToNode<HTMLPlugInElement>(args.Holder());
+        HTMLPlugInElement* element = V8Proxy::convertDOMWrapperToNode<HTMLPlugInElement>(args.Holder());
         ScriptInstance scriptInstance = element->getInstance();
         if (scriptInstance)
-            npObject = V8Proxy::ToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, scriptInstance->instance());
+            npObject = V8Proxy::convertToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, scriptInstance->instance());
         else
             npObject = 0;
     } else {
         // The holder object is not a subtype of HTMLPlugInElement, it
         // must be an NPObject which has three internal fields.
         if (args.Holder()->InternalFieldCount() != V8Custom::kNPObjectInternalFieldCount)
-          return throwError("NPMethod called on non-NPObject", V8Proxy::REFERENCE_ERROR);
+          return throwError("NPMethod called on non-NPObject", V8Proxy::ReferenceError);
 
-        npObject = V8Proxy::ToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, args.Holder());
+        npObject = V8Proxy::convertToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, args.Holder());
     }
 
     // Verify that our wrapper wasn't using a NPObject which
     // has already been deleted.
     if (!npObject || !_NPN_IsAlive(npObject))
-        return throwError("NPObject deleted", V8Proxy::REFERENCE_ERROR);
+        return throwError("NPObject deleted", V8Proxy::ReferenceError);
 
     // Wrap up parameters.
     int numArgs = args.Length();
     OwnArrayPtr<NPVariant> npArgs(new NPVariant[numArgs]);
 
     for (int i = 0; i < numArgs; i++)
         convertV8ObjectToNPVariant(args[i], npObject, &npArgs[i]);
 
     NPVariant result;
     VOID_TO_NPVARIANT(result);
@@ skipping 56 matching lines @@
     ASSERT(staticTemplateMap.contains(identifier));
 
     staticTemplateMap.forget(identifier);
 }
 
 
 static v8::Handle<v8::Value> npObjectGetProperty(v8::Local<v8::Object> self,
                                                  NPIdentifier identifier,
                                                  v8::Local<v8::Value> key)
 {
-    NPObject* npObject = V8Proxy::ToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, self);
+    NPObject* npObject = V8Proxy::convertToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, self);
 
     // Verify that our wrapper wasn't using a NPObject which
     // has already been deleted.
     if (!npObject || !_NPN_IsAlive(npObject))
-        return throwError("NPObject deleted", V8Proxy::REFERENCE_ERROR);
+        return throwError("NPObject deleted", V8Proxy::ReferenceError);
 
 
     if (npObject->_class->hasProperty && npObject->_class->hasProperty(npObject, identifier)
         && npObject->_class->getProperty) {
 
         NPVariant result;
         VOID_TO_NPVARIANT(result);
         if (!npObject->_class->getProperty(npObject, identifier, &result))
             return v8::Handle<v8::Value>();
 
@@ skipping 47 matching lines @@
                                                  uint32_t index)
 {
     NPIdentifier identifier = NPN_GetIntIdentifier(index);
     return npObjectGetProperty(self, identifier, v8::Number::New(index));
 }
 
 static v8::Handle<v8::Value> npObjectSetProperty(v8::Local<v8::Object> self,
                                                  NPIdentifier identifier,
                                                  v8::Local<v8::Value> value)
 {
-    NPObject* npObject = V8Proxy::ToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, self);
+    NPObject* npObject = V8Proxy::convertToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, self);
 
     // Verify that our wrapper wasn't using a NPObject which
     // has already been deleted.
     if (!npObject || !_NPN_IsAlive(npObject)) {
-        throwError("NPObject deleted", V8Proxy::REFERENCE_ERROR);
+        throwError("NPObject deleted", V8Proxy::ReferenceError);
         return value;  // Intercepted, but an exception was thrown.
     }
 
     if (npObject->_class->hasProperty && npObject->_class->hasProperty(npObject, identifier)
         && npObject->_class->setProperty) {
 
         NPVariant npValue;
         VOID_TO_NPVARIANT(npValue);
         convertV8ObjectToNPVariant(value, npObject, &npValue);
         bool success = npObject->_class->setProperty(npObject, identifier, &npValue);
@@ skipping 82 matching lines @@
     // The same Wrapper type can be used by DOM bindings.
     if (npObjectDesc.IsEmpty()) {
         npObjectDesc = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New());
         npObjectDesc->InstanceTemplate()->SetInternalFieldCount(V8Custom::kNPObjectInternalFieldCount);
         npObjectDesc->InstanceTemplate()->SetNamedPropertyHandler(npObjectNamedPropertyGetter, npObjectNamedPropertySetter);
         npObjectDesc->InstanceTemplate()->SetIndexedPropertyHandler(npObjectIndexedPropertyGetter, npObjectIndexedPropertySetter);
         npObjectDesc->InstanceTemplate()->SetCallAsFunctionHandler(npObjectInvokeDefaultHandler);
     }
 
     v8::Handle<v8::Function> v8Function = npObjectDesc->GetFunction();
-    v8::Local<v8::Object> value = SafeAllocation::NewInstance(v8Function);
+    v8::Local<v8::Object> value = SafeAllocation::newInstance(v8Function);
 
     // If we were unable to allocate the instance, we avoid wrapping
     // and registering the NP object.
     if (value.IsEmpty())
         return value;
 
     wrapNPObject(value, object);
 
     // KJS retains the object as part of its wrapper (see Bindings::CInstance).
     NPN_RetainObject(object);
 
     _NPN_RegisterObject(object, root);
 
     // Maintain a weak pointer for v8 so we can cleanup the object.
     v8::Persistent<v8::Object> weakRef = v8::Persistent<v8::Object>::New(value);
     staticNPObjectMap.set(object, weakRef);
 
     return value;
 }
 
 void forgetV8ObjectForNPObject(NPObject* object)
 {
     if (staticNPObjectMap.contains(object)) {
         v8::HandleScope scope;
         v8::Persistent<v8::Object> handle(staticNPObjectMap.get(object));
-        WebCore::V8Proxy::SetDOMWrapper(handle, WebCore::V8ClassIndex::NPOBJECT, 0);
+        WebCore::V8Proxy::setDOMWrapper(handle, WebCore::V8ClassIndex::NPOBJECT, 0);
         staticNPObjectMap.forget(object);
         NPN_ReleaseObject(object);
     }
 }