Move the v8::Isolate* parameter to the first parameter of various binding methods in third_party/We…

Source/bindings/core/v8/NPV8Object.cpp

 /*
  * Copyright (C) 2004, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2007, 2008, 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2014 Opera Software ASA. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 83 matching lines @@
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::Context> context = toV8Context(object->rootObject->frame(), DOMWrapperWorld::mainWorld());
     return ScriptState::from(context);
 }
 
 static PassOwnPtr<v8::Handle<v8::Value>[]> createValueListFromVariantArgs(const NPVariant* arguments, uint32_t argumentCount, NPObject* owner, v8::Isolate* isolate)
 {
     OwnPtr<v8::Handle<v8::Value>[]> argv = adoptArrayPtr(new v8::Handle<v8::Value>[argumentCount]);
     for (uint32_t index = 0; index < argumentCount; index++) {
         const NPVariant* arg = &arguments[index];
-        argv[index] = convertNPVariantToV8Object(arg, owner, isolate);
+        argv[index] = convertNPVariantToV8Object(isolate, arg, owner);
     }
     return argv.release();
 }
 
 // Create an identifier (null terminated utf8 char*) from the NPIdentifier.
-static v8::Local<v8::String> npIdentifierToV8Identifier(NPIdentifier name, v8::Isolate* isolate)
+static v8::Local<v8::String> npIdentifierToV8Identifier(v8::Isolate* isolate, NPIdentifier name)
 {
     PrivateIdentifier* identifier = static_cast<PrivateIdentifier*>(name);
     if (identifier->isString)
         return v8AtomicString(isolate, static_cast<const char*>(identifier->value.string));
 
     char buffer[32];
     snprintf(buffer, sizeof(buffer), "%d", identifier->value.number);
     return v8AtomicString(isolate, buffer);
 }
 
@@ skipping 154 matching lines @@
     // Call the function object.
     v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(functionObject);
     OwnPtr<v8::Handle<v8::Value>[]> argv = createValueListFromVariantArgs(arguments, argumentCount, npObject, isolate);
     v8::Local<v8::Value> resultObject = frame->script().callFunction(function, v8Object, argumentCount, argv.get());
 
     // If we had an error, return false.  The spec is a little unclear here, but says "Returns true if the method was
     // successfully invoked".  If we get an error return value, was that successfully invoked?
     if (resultObject.IsEmpty())
         return false;
 
-    convertV8ObjectToNPVariant(resultObject, npObject, result, isolate);
+    convertV8ObjectToNPVariant(isolate, resultObject, npObject, result);
     return true;
 }
 
 // FIXME: Fix it same as _NPN_Invoke (HandleScope and such).
 bool _NPN_InvokeDefault(NPP npp, NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
 {
     if (!npObject)
         return false;
 
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
@@ skipping 28 matching lines @@
         ASSERT(frame);
 
         OwnPtr<v8::Handle<v8::Value>[]> argv = createValueListFromVariantArgs(arguments, argumentCount, npObject, isolate);
         resultObject = frame->script().callFunction(function, functionObject, argumentCount, argv.get());
     }
     // If we had an error, return false.  The spec is a little unclear here, but says "Returns true if the method was
     // successfully invoked".  If we get an error return value, was that successfully invoked?
     if (resultObject.IsEmpty())
         return false;
 
-    convertV8ObjectToNPVariant(resultObject, npObject, result, isolate);
+    convertV8ObjectToNPVariant(isolate, resultObject, npObject, result);
     return true;
 }
 
 bool _NPN_Evaluate(NPP npp, NPObject* npObject, NPString* npScript, NPVariant* result)
 {
     // FIXME: Give the embedder a way to control this.
     bool popupsAllowed = false;
     return _NPN_EvaluateHelper(npp, popupsAllowed, npObject, npScript, result);
 }
 
@@ skipping 25 matching lines @@
 
     String script = String::fromUTF8(npScript->UTF8Characters, npScript->UTF8Length);
 
     UserGestureIndicator gestureIndicator(popupsAllowed ? DefinitelyProcessingNewUserGesture : PossiblyProcessingUserGesture);
     v8::Local<v8::Value> v8result = frame->script().executeScriptAndReturnValue(scriptState->context(), ScriptSourceCode(script, KURL(ParsedURLString, filename)));
 
     if (v8result.IsEmpty())
         return false;
 
     if (_NPN_IsAlive(npObject))
-        convertV8ObjectToNPVariant(v8result, npObject, result, isolate);
+        convertV8ObjectToNPVariant(isolate, v8result, npObject, result);
     return true;
 }
 
 bool _NPN_GetProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
 {
     if (!npObject)
         return false;
 
     if (V8NPObject* object = npObjectToV8NPObject(npObject)) {
         v8::Isolate* isolate = v8::Isolate::GetCurrent();
         ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
         if (!scriptState)
             return false;
 
         ScriptState::Scope scope(scriptState);
         ExceptionCatcher exceptionCatcher;
 
         v8::Handle<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
-        v8::Local<v8::Value> v8result = obj->Get(npIdentifierToV8Identifier(propertyName, isolate));
+        v8::Local<v8::Value> v8result = obj->Get(npIdentifierToV8Identifier(isolate, propertyName));
 
         if (v8result.IsEmpty())
             return false;
 
-        convertV8ObjectToNPVariant(v8result, npObject, result, isolate);
+        convertV8ObjectToNPVariant(isolate, v8result, npObject, result);
         return true;
     }
 
     if (npObject->_class->hasProperty && npObject->_class->getProperty) {
         if (npObject->_class->hasProperty(npObject, propertyName))
             return npObject->_class->getProperty(npObject, propertyName, result);
     }
 
     VOID_TO_NPVARIANT(*result);
     return false;
 }
 
 bool _NPN_SetProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName, const NPVariant* value)
 {
     if (!npObject)
         return false;
 
     if (V8NPObject* object = npObjectToV8NPObject(npObject)) {
         v8::Isolate* isolate = v8::Isolate::GetCurrent();
         ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
         if (!scriptState)
             return false;
 
         ScriptState::Scope scope(scriptState);
         ExceptionCatcher exceptionCatcher;
 
         v8::Handle<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
-        obj->Set(npIdentifierToV8Identifier(propertyName, isolate), convertNPVariantToV8Object(value, object->rootObject->frame()->script().windowScriptNPObject(), isolate));
+        obj->Set(npIdentifierToV8Identifier(isolate, propertyName), convertNPVariantToV8Object(isolate, value, object->rootObject->frame()->script().windowScriptNPObject()));
         return true;
     }
 
     if (npObject->_class->setProperty)
         return npObject->_class->setProperty(npObject, propertyName, value);
 
     return false;
 }
 
 bool _NPN_RemoveProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName)
 {
     if (!npObject)
         return false;
 
     V8NPObject* object = npObjectToV8NPObject(npObject);
     if (!object)
         return false;
 
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
     if (!scriptState)
         return false;
     ScriptState::Scope scope(scriptState);
     ExceptionCatcher exceptionCatcher;
 
     v8::Handle<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
     // FIXME: Verify that setting to undefined is right.
-    obj->Set(npIdentifierToV8Identifier(propertyName, isolate), v8::Undefined(isolate));
+    obj->Set(npIdentifierToV8Identifier(isolate, propertyName), v8::Undefined(isolate));
     return true;
 }
 
 bool _NPN_HasProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName)
 {
     if (!npObject)
         return false;
 
     if (V8NPObject* object = npObjectToV8NPObject(npObject)) {
         v8::Isolate* isolate = v8::Isolate::GetCurrent();
         ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
         if (!scriptState)
             return false;
         ScriptState::Scope scope(scriptState);
         ExceptionCatcher exceptionCatcher;
 
         v8::Handle<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
-        return obj->Has(npIdentifierToV8Identifier(propertyName, isolate));
+        return obj->Has(npIdentifierToV8Identifier(isolate, propertyName));
     }
 
     if (npObject->_class->hasProperty)
         return npObject->_class->hasProperty(npObject, propertyName);
     return false;
 }
 
 bool _NPN_HasMethod(NPP npp, NPObject* npObject, NPIdentifier methodName)
 {
     if (!npObject)
         return false;
 
     if (V8NPObject* object = npObjectToV8NPObject(npObject)) {
         v8::Isolate* isolate = v8::Isolate::GetCurrent();
         ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
         if (!scriptState)
             return false;
         ScriptState::Scope scope(scriptState);
         ExceptionCatcher exceptionCatcher;
 
         v8::Handle<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
-        v8::Handle<v8::Value> prop = obj->Get(npIdentifierToV8Identifier(methodName, isolate));
+        v8::Handle<v8::Value> prop = obj->Get(npIdentifierToV8Identifier(isolate, methodName));
         return prop->IsFunction();
     }
 
     if (npObject->_class->hasMethod)
         return npObject->_class->hasMethod(npObject, methodName);
     return false;
 }
 
 void _NPN_SetException(NPObject* npObject, const NPUTF8 *message)
 {
@@ skipping 94 matching lines @@
         if (!ctor->IsNull()) {
             LocalFrame* frame = object->rootObject->frame();
             ASSERT(frame);
             OwnPtr<v8::Handle<v8::Value>[]> argv = createValueListFromVariantArgs(arguments, argumentCount, npObject, isolate);
             resultObject = V8ObjectConstructor::newInstanceInDocument(isolate, ctor, argumentCount, argv.get(), frame ? frame->document() : 0);
         }
 
         if (resultObject.IsEmpty())
             return false;
 
-        convertV8ObjectToNPVariant(resultObject, npObject, result, isolate);
+        convertV8ObjectToNPVariant(isolate, resultObject, npObject, result);
         return true;
     }
 
     if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(npObject->_class) && npObject->_class->construct)
         return npObject->_class->construct(npObject, arguments, argumentCount, result);
 
     return false;
 }