Replace Handle<> with Local<> in bindings/core/v8

Source/bindings/core/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 100 matching lines @@
     for (int i = 0; i < numArgs; i++)
         convertV8ObjectToNPVariant(isolate, info[i], npObject, &npArgs[i]);
 
     NPVariant result;
     VOID_TO_NPVARIANT(result);
 
     bool retval = true;
     switch (functionId) {
     case InvokeMethod:
         if (npObject->_class->invoke) {
-            v8::Handle<v8::String> functionName = v8::Handle<v8::String>::Cast(info.Data());
+            v8::Local<v8::String> functionName = v8::Local<v8::String>::Cast(info.Data());
             NPIdentifier identifier = getStringIdentifier(functionName);
             retval = npObject->_class->invoke(npObject, identifier, npArgs.get(), numArgs, &result);
         }
         break;
     case InvokeConstruct:
         if (npObject->_class->construct)
             retval = npObject->_class->construct(npObject, npArgs.get(), numArgs, &result);
         break;
     case InvokeDefault:
         if (npObject->_class->invokeDefault)
             retval = npObject->_class->invokeDefault(npObject, npArgs.get(), numArgs, &result);
         break;
     default:
         break;
     }
 
     if (!retval)
         V8ThrowException::throwGeneralError(isolate, "Error calling method on NPObject.");
 
     for (int i = 0; i < numArgs; i++)
         _NPN_ReleaseVariantValue(&npArgs[i]);
 
     // Unwrap return values.
-    v8::Handle<v8::Value> returnValue;
+    v8::Local<v8::Value> returnValue;
     if (_NPN_IsAlive(npObject))
         returnValue = convertNPVariantToV8Object(isolate, &result, npObject);
     _NPN_ReleaseVariantValue(&result);
 
     v8SetReturnValue(info, returnValue);
 }
 
 
 void npObjectMethodHandler(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
@@ skipping 40 matching lines @@
 class V8NPTemplateMap {
 public:
     // NPIdentifier is PrivateIdentifier*.
     typedef v8::PersistentValueMap<PrivateIdentifier*, v8::FunctionTemplate, V8TemplateMapTraits> MapType;
 
     v8::Local<v8::FunctionTemplate> get(PrivateIdentifier* key)
     {
         return m_map.Get(key);
     }
 
-    void set(PrivateIdentifier* key, v8::Handle<v8::FunctionTemplate> handle)
+    void set(PrivateIdentifier* key, v8::Local<v8::FunctionTemplate> handle)
     {
         ASSERT(!m_map.Contains(key));
         m_map.Set(key, handle);
     }
 
     static V8NPTemplateMap& sharedInstance(v8::Isolate* isolate)
     {
         DEFINE_STATIC_LOCAL(V8NPTemplateMap, map, (isolate));
         ASSERT(isolate == map.m_map.GetIsolate());
         return map;
     }
 
     friend class V8TemplateMapTraits;
 
 private:
     explicit V8NPTemplateMap(v8::Isolate* isolate)
         : m_map(isolate)
     {
     }
 
     MapType m_map;
 };
 
 V8TemplateMapTraits::MapType* V8TemplateMapTraits::MapFromWeakCallbackData(const v8::WeakCallbackData<v8::FunctionTemplate, WeakCallbackDataType>& data)
 {
     return &V8NPTemplateMap::sharedInstance(data.GetIsolate()).m_map;
 }
 
 
-static v8::Handle<v8::Value> npObjectGetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> key, v8::Isolate* isolate)
+static v8::Local<v8::Value> npObjectGetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> key, v8::Isolate* isolate)
 {
     NPObject* npObject = v8ObjectToNPObject(self);
 
     // Verify that our wrapper wasn't using a NPObject which
     // has already been deleted.
     if (!npObject || !_NPN_IsAlive(npObject))
         return V8ThrowException::throwReferenceError(isolate, "NPObject deleted");
 
 
     if (npObject->_class->hasProperty && npObject->_class->getProperty && npObject->_class->hasProperty(npObject, identifier)) {
         if (!_NPN_IsAlive(npObject))
             return V8ThrowException::throwReferenceError(isolate, "NPObject deleted");
 
         NPVariant result;
         VOID_TO_NPVARIANT(result);
         if (!npObject->_class->getProperty(npObject, identifier, &result))
             return v8Undefined();
 
-        v8::Handle<v8::Value> returnValue;
+        v8::Local<v8::Value> returnValue;
         if (_NPN_IsAlive(npObject))
             returnValue = convertNPVariantToV8Object(isolate, &result, npObject);
         _NPN_ReleaseVariantValue(&result);
         return returnValue;
 
     }
 
     if (!_NPN_IsAlive(npObject))
         return V8ThrowException::throwReferenceError(isolate, "NPObject deleted");
 
     if (key->IsString() && npObject->_class->hasMethod && npObject->_class->hasMethod(npObject, identifier)) {
         if (!_NPN_IsAlive(npObject))
             return V8ThrowException::throwReferenceError(isolate, "NPObject deleted");
 
         PrivateIdentifier* id = static_cast<PrivateIdentifier*>(identifier);
         v8::Local<v8::FunctionTemplate> functionTemplate = V8NPTemplateMap::sharedInstance(isolate).get(id);
         // Cache templates using identifier as the key.
         if (functionTemplate.IsEmpty()) {
             // Create a new template.
             functionTemplate = v8::FunctionTemplate::New(isolate);
             functionTemplate->SetCallHandler(npObjectMethodHandler, key);
             V8NPTemplateMap::sharedInstance(isolate).set(id, functionTemplate);
         }
         v8::Local<v8::Function> v8Function = functionTemplate->GetFunction();
-        v8Function->SetName(v8::Handle<v8::String>::Cast(key));
+        v8Function->SetName(v8::Local<v8::String>::Cast(key));
         return v8Function;
     }
 
     return v8Undefined();
 }
 
 void npObjectNamedPropertyGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     NPIdentifier identifier = getStringIdentifier(name);
     v8SetReturnValue(info, npObjectGetProperty(info.Holder(), identifier, name, info.GetIsolate()));
@@ skipping 18 matching lines @@
 }
 
 void npObjectQueryProperty(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
 {
     NPIdentifier identifier = getStringIdentifier(name);
     if (npObjectGetProperty(info.Holder(), identifier, name, info.GetIsolate()).IsEmpty())
         return;
     v8SetReturnValueInt(info, 0);
 }
 
-static v8::Handle<v8::Value> npObjectSetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> value, v8::Isolate* isolate)
+static v8::Local<v8::Value> npObjectSetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> value, v8::Isolate* isolate)
 {
     NPObject* npObject = v8ObjectToNPObject(self);
 
     // Verify that our wrapper wasn't using a NPObject which has already been deleted.
     if (!npObject || !_NPN_IsAlive(npObject)) {
         V8ThrowException::throwReferenceError(isolate, "NPObject deleted");
         return value; // Intercepted, but an exception was thrown.
     }
 
     if (npObject->_class->hasProperty && npObject->_class->setProperty && npObject->_class->hasProperty(npObject, identifier)) {
@@ skipping 51 matching lines @@
     if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(npObject->_class) && npObject->_class->enumerate) {
         uint32_t count;
         NPIdentifier* identifiers;
         if (npObject->_class->enumerate(npObject, &identifiers, &count)) {
             uint32_t propertiesCount = 0;
             for (uint32_t i = 0; i < count; ++i) {
                 IdentifierRep* identifier = static_cast<IdentifierRep*>(identifiers[i]);
                 if (namedProperty == identifier->m_isString)
                     ++propertiesCount;
             }
-            v8::Handle<v8::Array> properties = v8::Array::New(info.GetIsolate(), propertiesCount);
+            v8::Local<v8::Array> properties = v8::Array::New(info.GetIsolate(), propertiesCount);
             for (uint32_t i = 0, propertyIndex = 0; i < count; ++i) {
                 IdentifierRep* identifier = static_cast<IdentifierRep*>(identifiers[i]);
                 if (namedProperty == identifier->m_isString) {
                     ASSERT(propertyIndex < propertiesCount);
                     if (namedProperty)
                         properties->Set(v8::Integer::New(info.GetIsolate(), propertyIndex++), v8AtomicString(info.GetIsolate(), identifier->string()));
                     else
                         properties->Set(v8::Integer::New(info.GetIsolate(), propertyIndex++), v8::Integer::New(info.GetIsolate(), identifier->number()));
                 }
             }
@@ skipping 36 matching lines @@
     static v8::Eternal<v8::FunctionTemplate> npObjectDesc;
 
     ASSERT(isolate->InContext());
 
     // If this is a v8 object, just return it.
     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
     if (v8NPObject)
         return v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
 
     // If we've already wrapped this object, just return it.
-    v8::Handle<v8::Object> wrapper = staticNPObjectMap().newLocal(object, isolate);
+    v8::Local<v8::Object> wrapper = staticNPObjectMap().newLocal(object, isolate);
     if (!wrapper.IsEmpty())
         return wrapper;
 
     // FIXME: we should create a Wrapper type as a subclass of JSObject. It has two internal fields, field 0 is the wrapped
     // pointer, and field 1 is the type. There should be an api function that returns unused type id. The same Wrapper type
     // can be used by DOM bindings.
     if (npObjectDesc.IsEmpty()) {
         v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
         templ->InstanceTemplate()->SetInternalFieldCount(npObjectInternalFieldCount);
         templ->InstanceTemplate()->SetNamedPropertyHandler(npObjectNamedPropertyGetter, npObjectNamedPropertySetter, npObjectQueryProperty, 0, npObjectNamedPropertyEnumerator);
         templ->InstanceTemplate()->SetIndexedPropertyHandler(npObjectIndexedPropertyGetter, npObjectIndexedPropertySetter, 0, 0, npObjectIndexedPropertyEnumerator);
         templ->InstanceTemplate()->SetCallAsFunctionHandler(npObjectInvokeDefaultHandler);
         npObjectDesc.Set(isolate, templ);
     }
 
     // FIXME: Move staticNPObjectMap() to DOMDataStore.
     // Use V8DOMWrapper::createWrapper() and
     // V8DOMWrapper::associateObjectWithWrapper()
     // to create a wrapper object.
-    v8::Handle<v8::Function> v8Function = npObjectDesc.Get(isolate)->GetFunction();
+    v8::Local<v8::Function> v8Function = npObjectDesc.Get(isolate)->GetFunction();
     v8::Local<v8::Object> value = V8ObjectConstructor::newInstance(isolate, v8Function);
     if (value.IsEmpty())
         return value;
 
     V8DOMWrapper::setNativeInfo(value, npObjectTypeInfo(), npObjectToScriptWrappable(object));
 
     // KJS retains the object as part of its wrapper (see Bindings::CInstance).
     _NPN_RetainObject(object);
     _NPN_RegisterObject(object, root);
 
     staticNPObjectMap().set(object, value, npObjectTypeInfo());
     ASSERT(V8DOMWrapper::hasInternalFieldsSet(value));
     return value;
 }
 
 void forgetV8ObjectForNPObject(NPObject* object)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope(isolate);
-    v8::Handle<v8::Object> wrapper = staticNPObjectMap().newLocal(object, isolate);
+    v8::Local<v8::Object> wrapper = staticNPObjectMap().newLocal(object, isolate);
     if (!wrapper.IsEmpty()) {
         V8DOMWrapper::clearNativeInfo(wrapper, npObjectTypeInfo());
         staticNPObjectMap().removeAndDispose(object);
         _NPN_ReleaseObject(object);
     }
 }
 
 } // namespace blink