bindings: Use Maybe version of Get in bindings/

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 239 matching lines @@
 
     // FIXME: should use the plugin's owner frame as the security context.
     ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
     if (!scriptState)
         return false;
 
     ScriptState::Scope scope(scriptState);
     ExceptionCatcher exceptionCatcher;
 
     v8::Local<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NpObject->v8Object);
-    v8::Local<v8::Value> functionObject = v8Object->Get(v8AtomicString(isolate, identifier->value.string));
-    if (functionObject.IsEmpty() || functionObject->IsNull()) {
+    v8::Local<v8::Value> functionObject;
+    if (!v8Object->Get(scriptState->context(), v8AtomicString(scriptState->isolate(), identifier->value.string)).ToLocal(&functionObject) || functionObject->IsNull()) {
         NULL_TO_NPVARIANT(*result);
         return false;
     }
     if (functionObject->IsUndefined()) {
         VOID_TO_NPVARIANT(*result);
         return false;
     }
 
     LocalFrame* frame = v8NpObject->rootObject->frame();
     ASSERT(frame);
@@ skipping 118 matching lines @@
     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::Local<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
-        v8::Local<v8::Value> v8result = obj->Get(npIdentifierToV8Identifier(isolate, propertyName));
-
-        if (v8result.IsEmpty())
+        v8::Local<v8::Value> v8result;
+        if (!obj->Get(scriptState->context(), npIdentifierToV8Identifier(scriptState->isolate(), propertyName)).ToLocal(&v8result))
             return false;
 
         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);
     }
@@ skipping 78 matching lines @@
 
     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::Local<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
-        v8::Local<v8::Value> prop = obj->Get(npIdentifierToV8Identifier(isolate, methodName));
+        v8::Local<v8::Value> prop;
+        if (!obj->Get(scriptState->context(), npIdentifierToV8Identifier(scriptState->isolate(), methodName)).ToLocal(&prop))
+            return false;
         return prop->IsFunction();
     }
 
     if (npObject->_class->hasMethod)
         return npObject->_class->hasMethod(npObject, methodName);
     return false;
 }
 
 void _NPN_SetException(NPObject* npObject, const NPUTF8 *message)
 {
@@ skipping 14 matching lines @@
 
     V8ThrowException::throwGeneralError(isolate, message);
 }
 
 bool _NPN_Enumerate(NPP npp, NPObject* npObject, NPIdentifier** identifier, uint32_t* count)
 {
     if (!npObject)
         return false;
 
     if (V8NPObject* object = npObjectToV8NPObject(npObject)) {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
-        ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
+        ScriptState* scriptState = mainWorldScriptState(v8::Isolate::GetCurrent(), npp, npObject);
         if (!scriptState)
             return false;
         ScriptState::Scope scope(scriptState);
         ExceptionCatcher exceptionCatcher;
 
-        v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(isolate, object->v8Object);
+        v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(scriptState->isolate(), object->v8Object);
 
         // FIXME: http://b/issue?id=1210340: Use a v8::Object::Keys() method when it exists, instead of evaluating javascript.
 
         // FIXME: Figure out how to cache this helper function.  Run a helper function that collects the properties
         // on the object into an array.
         const char enumeratorCode[] =
             "(function (obj) {"
             "  var props = [];"
             "  for (var prop in obj) {"
             "    props[props.length] = prop;"
             "  }"
             "  return props;"
             "});";
-        v8::Local<v8::String> source = v8AtomicString(isolate, enumeratorCode);
+        v8::Local<v8::String> source = v8AtomicString(scriptState->isolate(), enumeratorCode);
         v8::Local<v8::Value> result;
-        if (!V8ScriptRunner::compileAndRunInternalScript(source, isolate).ToLocal(&result))
+        if (!V8ScriptRunner::compileAndRunInternalScript(source, scriptState->isolate()).ToLocal(&result))
             return false;
         ASSERT(result->IsFunction());
         v8::Local<v8::Function> enumerator = v8::Local<v8::Function>::Cast(result);
         v8::Local<v8::Value> argv[] = { obj };
         v8::Local<v8::Value> propsObj;
-        if (!V8ScriptRunner::callInternalFunction(enumerator, v8::Local<v8::Object>::Cast(result), WTF_ARRAY_LENGTH(argv), argv, isolate).ToLocal(&propsObj))
+        if (!V8ScriptRunner::callInternalFunction(enumerator, v8::Local<v8::Object>::Cast(result), WTF_ARRAY_LENGTH(argv), argv, scriptState->isolate()).ToLocal(&propsObj))
             return false;
 
         // Convert the results into an array of NPIdentifiers.
         v8::Local<v8::Array> props = v8::Local<v8::Array>::Cast(propsObj);
         *count = props->Length();
         *identifier = static_cast<NPIdentifier*>(calloc(*count, sizeof(NPIdentifier)));
         for (uint32_t i = 0; i < *count; ++i) {
-            v8::Local<v8::Value> name = props->Get(v8::Integer::New(isolate, i));
+            v8::Local<v8::Value> name;
+            if (!props->Get(scriptState->context(), v8::Integer::New(scriptState->isolate(), i)).ToLocal(&name))
+                return false;
             (*identifier)[i] = getStringIdentifier(v8::Local<v8::String>::Cast(name));
         }
         return true;
     }
 
     if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(npObject->_class) && npObject->_class->enumerate)
        return npObject->_class->enumerate(npObject, identifier, count);
 
     return false;
 }
 
 bool _NPN_Construct(NPP npp, NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
 {
     if (!npObject)
         return false;
 
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-
     if (V8NPObject* object = npObjectToV8NPObject(npObject)) {
-        ScriptState* scriptState = mainWorldScriptState(isolate, npp, npObject);
+        ScriptState* scriptState = mainWorldScriptState(v8::Isolate::GetCurrent(), npp, npObject);
         if (!scriptState)
             return false;
         ScriptState::Scope scope(scriptState);
         ExceptionCatcher exceptionCatcher;
 
         // Lookup the constructor function.
-        v8::Local<v8::Object> ctorObj = v8::Local<v8::Object>::New(isolate, object->v8Object);
+        v8::Local<v8::Object> ctorObj = v8::Local<v8::Object>::New(scriptState->isolate(), object->v8Object);
         if (!ctorObj->IsFunction())
             return false;
 
         // Call the constructor.
         v8::Local<v8::Value> resultObject;
         v8::Local<v8::Function> ctor = v8::Local<v8::Function>::Cast(ctorObj);
         if (!ctor->IsNull()) {
             LocalFrame* frame = object->rootObject->frame();
             ASSERT(frame);
-            OwnPtr<v8::Local<v8::Value>[]> argv = createValueListFromVariantArgs(arguments, argumentCount, npObject, isolate);
-            resultObject = V8ObjectConstructor::newInstanceInDocument(isolate, ctor, argumentCount, argv.get(), frame ? frame->document() : 0);
+            OwnPtr<v8::Local<v8::Value>[]> argv = createValueListFromVariantArgs(arguments, argumentCount, npObject, scriptState->isolate());
+            resultObject = V8ObjectConstructor::newInstanceInDocument(scriptState->isolate(), ctor, argumentCount, argv.get(), frame ? frame->document() : 0);
         }
 
         if (resultObject.IsEmpty())
             return false;
 
-        convertV8ObjectToNPVariant(isolate, resultObject, npObject, result);
+        convertV8ObjectToNPVariant(scriptState->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;
 }