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

Source/bindings/core/v8/V8Binding.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 76 matching lines @@
 v8::Local<v8::Value> createMinimumArityTypeErrorForConstructor(v8::Isolate* isolate, const char* type, unsigned expected, unsigned provided)
 {
     return V8ThrowException::createTypeError(isolate, ExceptionMessages::failedToConstruct(type, ExceptionMessages::notEnoughArguments(expected, provided)));
 }
 
 void setMinimumArityTypeError(ExceptionState& exceptionState, unsigned expected, unsigned provided)
 {
     exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(expected, provided));
 }
 
-PassRefPtrWillBeRawPtr<NodeFilter> toNodeFilter(v8::Handle<v8::Value> callback, v8::Handle<v8::Object> creationContext, ScriptState* scriptState)
+PassRefPtrWillBeRawPtr<NodeFilter> toNodeFilter(v8::Local<v8::Value> callback, v8::Local<v8::Object> creationContext, ScriptState* scriptState)
 {
     if (callback->IsNull())
         return nullptr;
     RefPtrWillBeRawPtr<NodeFilter> filter = NodeFilter::create();
 
-    v8::Handle<v8::Object> filterWrapper = toV8(filter.get(), creationContext, scriptState->isolate()).As<v8::Object>();
+    v8::Local<v8::Object> filterWrapper = toV8(filter.get(), creationContext, scriptState->isolate()).As<v8::Object>();
 
     RefPtrWillBeRawPtr<NodeFilterCondition> condition = V8NodeFilterCondition::create(callback, filterWrapper, scriptState);
     filter->setCondition(condition.release());
 
     return filter.release();
 }
 
 bool toBooleanSlow(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsBoolean());
@@ skipping 47 matching lines @@
     static const unsigned numberOfValues = 65536; // 2^16
 };
 
 template <>
 struct IntTypeLimits<uint16_t> {
     static const unsigned short maxValue = 65535;
     static const unsigned numberOfValues = 65536; // 2^16
 };
 
 template <typename T>
-static inline T toSmallerInt(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, const char* typeName, ExceptionState& exceptionState)
+static inline T toSmallerInt(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, const char* typeName, ExceptionState& exceptionState)
 {
     typedef IntTypeLimits<T> LimitsTrait;
 
     // Fast case. The value is already a 32-bit integer in the right range.
     if (value->IsInt32()) {
         int32_t result = value.As<v8::Int32>()->Value();
         if (result >= LimitsTrait::minValue && result <= LimitsTrait::maxValue)
             return static_cast<T>(result);
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the '" + String(typeName) + "' value range.");
@@ skipping 31 matching lines @@
     if (std::isinf(numberValue))
         return 0;
 
     numberValue = numberValue < 0 ? -floor(fabs(numberValue)) : floor(fabs(numberValue));
     numberValue = fmod(numberValue, LimitsTrait::numberOfValues);
 
     return static_cast<T>(numberValue > LimitsTrait::maxValue ? numberValue - LimitsTrait::numberOfValues : numberValue);
 }
 
 template <typename T>
-static inline T toSmallerUInt(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, const char* typeName, ExceptionState& exceptionState)
+static inline T toSmallerUInt(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, const char* typeName, ExceptionState& exceptionState)
 {
     typedef IntTypeLimits<T> LimitsTrait;
 
     // Fast case. The value is a 32-bit signed integer - possibly positive?
     if (value->IsInt32()) {
         int32_t result = value.As<v8::Int32>()->Value();
         if (result >= 0 && result <= LimitsTrait::maxValue)
             return static_cast<T>(result);
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the '" + String(typeName) + "' value range.");
@@ skipping 28 matching lines @@
     if (configuration == Clamp)
         return clampTo<T>(numberValue);
 
     if (std::isinf(numberValue))
         return 0;
 
     numberValue = numberValue < 0 ? -floor(fabs(numberValue)) : floor(fabs(numberValue));
     return static_cast<T>(fmod(numberValue, LimitsTrait::numberOfValues));
 }
 
-int8_t toInt8(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+int8_t toInt8(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerInt<int8_t>(isolate, value, configuration, "byte", exceptionState);
 }
 
-uint8_t toUInt8(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+uint8_t toUInt8(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerUInt<uint8_t>(isolate, value, configuration, "octet", exceptionState);
 }
 
-int16_t toInt16(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+int16_t toInt16(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerInt<int16_t>(isolate, value, configuration, "short", exceptionState);
 }
 
-uint16_t toUInt16(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+uint16_t toUInt16(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerUInt<uint16_t>(isolate, value, configuration, "unsigned short", exceptionState);
 }
 
-int32_t toInt32Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+int32_t toInt32Slow(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsInt32());
     // Can the value be converted to a number?
     v8::TryCatch block(isolate);
     v8::Local<v8::Number> numberObject;
     if (!v8Call(value->ToNumber(isolate->GetCurrentContext()), numberObject, block)) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
@@ skipping 13 matching lines @@
         return 0;
 
     int32_t result;
     if (!v8Call(numberObject->Int32Value(isolate->GetCurrentContext()), result, block)) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
     return result;
 }
 
-uint32_t toUInt32Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+uint32_t toUInt32Slow(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsUint32());
     if (value->IsInt32()) {
         ASSERT(configuration != NormalConversion);
         int32_t result = value.As<v8::Int32>()->Value();
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long' value range.");
             return 0;
@@ skipping 26 matching lines @@
         return 0;
 
     uint32_t result;
     if (!v8Call(numberObject->Uint32Value(isolate->GetCurrentContext()), result, block)) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
     return result;
 }
 
-int64_t toInt64Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+int64_t toInt64Slow(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsInt32());
 
     v8::Local<v8::Number> numberObject;
     // Can the value be converted to a number?
     v8::TryCatch block(isolate);
     if (!v8Call(value->ToNumber(isolate->GetCurrentContext()), numberObject, block)) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
     ASSERT(!numberObject.IsEmpty());
 
     double numberValue = numberObject->Value();
 
     if (configuration == EnforceRange)
         return enforceRange(numberValue, -kJSMaxInteger, kJSMaxInteger, "long long", exceptionState);
 
     if (std::isnan(numberValue) || std::isinf(numberValue))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
     doubleToInteger(numberValue, integer);
     return integer;
 }
 
-uint64_t toUInt64Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
+uint64_t toUInt64Slow(v8::Isolate* isolate, v8::Local<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsUint32());
     if (value->IsInt32()) {
         ASSERT(configuration != NormalConversion);
         int32_t result = value.As<v8::Int32>()->Value();
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long long' value range.");
             return 0;
@@ skipping 24 matching lines @@
 
     if (std::isinf(numberValue))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
     doubleToInteger(numberValue, integer);
     return integer;
 }
 
-float toRestrictedFloat(v8::Isolate* isolate, v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+float toRestrictedFloat(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     float numberValue = toFloat(isolate, value, exceptionState);
     if (exceptionState.hadException())
         return 0;
     if (!std::isfinite(numberValue)) {
         exceptionState.throwTypeError("The provided float value is non-finite.");
         return 0;
     }
     return numberValue;
 }
 
-double toDoubleSlow(v8::Isolate* isolate, v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+double toDoubleSlow(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsNumber());
     v8::TryCatch block(isolate);
     double doubleValue;
     if (!v8Call(value->NumberValue(isolate->GetCurrentContext()), doubleValue, block)) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
     return doubleValue;
 }
 
-double toRestrictedDouble(v8::Isolate* isolate, v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+double toRestrictedDouble(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     double numberValue = toDouble(isolate, value, exceptionState);
     if (exceptionState.hadException())
         return 0;
     if (!std::isfinite(numberValue)) {
         exceptionState.throwTypeError("The provided double value is non-finite.");
         return 0;
     }
     return numberValue;
 }
 
-String toByteString(v8::Isolate* isolate, v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+String toByteString(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     // Handle null default value.
     if (value.IsEmpty())
         return String();
 
     // From the Web IDL spec: http://heycam.github.io/webidl/#es-ByteString
     if (value.IsEmpty())
         return String();
 
     // 1. Let x be ToString(v)
@@ skipping 118 matching lines @@
         }
         // 3. Set i to i+1.
         ++i;
     }
 
     // 6. Return U.
     ASSERT(u.length() == string.length());
     return u.toString();
 }
 
-String toUSVString(v8::Isolate* isolate, v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+String toUSVString(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     // http://heycam.github.io/webidl/#es-USVString
     if (value.IsEmpty())
         return String();
 
     v8::Local<v8::String> stringObject;
     if (value->IsString()) {
         stringObject = value.As<v8::String>();
     } else {
         v8::TryCatch block(isolate);
         if (!v8Call(value->ToString(isolate->GetCurrentContext()), stringObject, block)) {
             exceptionState.rethrowV8Exception(block.Exception());
             return String();
         }
     }
 
     // USVString is identical to DOMString except that "convert a
     // DOMString to a sequence of Unicode characters" is used subsequently
     // when converting to an IDL value
     String x = toCoreString(stringObject);
     return replaceUnmatchedSurrogates(x);
 }
 
-XPathNSResolver* toXPathNSResolver(ScriptState* scriptState, v8::Handle<v8::Value> value)
+XPathNSResolver* toXPathNSResolver(ScriptState* scriptState, v8::Local<v8::Value> value)
 {
     XPathNSResolver* resolver = nullptr;
     if (V8XPathNSResolver::hasInstance(value, scriptState->isolate()))
-        resolver = V8XPathNSResolver::toImpl(v8::Handle<v8::Object>::Cast(value));
+        resolver = V8XPathNSResolver::toImpl(v8::Local<v8::Object>::Cast(value));
     else if (value->IsObject())
         resolver = V8CustomXPathNSResolver::create(scriptState, value.As<v8::Object>());
     return resolver;
 }
 
-DOMWindow* toDOMWindow(v8::Isolate* isolate, v8::Handle<v8::Value> value)
+DOMWindow* toDOMWindow(v8::Isolate* isolate, v8::Local<v8::Value> value)
 {
     if (value.IsEmpty() || !value->IsObject())
         return 0;
 
-    v8::Handle<v8::Object> windowWrapper = V8Window::findInstanceInPrototypeChain(v8::Handle<v8::Object>::Cast(value), isolate);
+    v8::Local<v8::Object> windowWrapper = V8Window::findInstanceInPrototypeChain(v8::Local<v8::Object>::Cast(value), isolate);
     if (!windowWrapper.IsEmpty())
         return V8Window::toImpl(windowWrapper);
     return 0;
 }
 
-DOMWindow* toDOMWindow(v8::Handle<v8::Context> context)
+DOMWindow* toDOMWindow(v8::Local<v8::Context> context)
 {
     if (context.IsEmpty())
         return 0;
     return toDOMWindow(context->GetIsolate(), context->Global());
 }
 
 LocalDOMWindow* enteredDOMWindow(v8::Isolate* isolate)
 {
     LocalDOMWindow* window = toLocalDOMWindow(toDOMWindow(isolate->GetEnteredContext()));
     if (!window) {
         // We don't always have an entered DOM window, for example during microtask callbacks from V8
         // (where the entered context may be the DOM-in-JS context). In that case, we fall back
         // to the current context.
         window = currentDOMWindow(isolate);
         ASSERT(window);
     }
     return window;
 }
 
 LocalDOMWindow* currentDOMWindow(v8::Isolate* isolate)
 {
     return toLocalDOMWindow(toDOMWindow(isolate->GetCurrentContext()));
 }
 
 LocalDOMWindow* callingDOMWindow(v8::Isolate* isolate)
 {
-    v8::Handle<v8::Context> context = isolate->GetCallingContext();
+    v8::Local<v8::Context> context = isolate->GetCallingContext();
     if (context.IsEmpty()) {
         // Unfortunately, when processing script from a plugin, we might not
         // have a calling context. In those cases, we fall back to the
         // entered context.
         context = isolate->GetEnteredContext();
     }
     return toLocalDOMWindow(toDOMWindow(context));
 }
 
-ExecutionContext* toExecutionContext(v8::Handle<v8::Context> context)
+ExecutionContext* toExecutionContext(v8::Local<v8::Context> context)
 {
     if (context.IsEmpty())
         return 0;
-    v8::Handle<v8::Object> global = context->Global();
-    v8::Handle<v8::Object> windowWrapper = V8Window::findInstanceInPrototypeChain(global, context->GetIsolate());
+    v8::Local<v8::Object> global = context->Global();
+    v8::Local<v8::Object> windowWrapper = V8Window::findInstanceInPrototypeChain(global, context->GetIsolate());
     if (!windowWrapper.IsEmpty())
         return V8Window::toImpl(windowWrapper)->executionContext();
-    v8::Handle<v8::Object> workerWrapper = V8WorkerGlobalScope::findInstanceInPrototypeChain(global, context->GetIsolate());
+    v8::Local<v8::Object> workerWrapper = V8WorkerGlobalScope::findInstanceInPrototypeChain(global, context->GetIsolate());
     if (!workerWrapper.IsEmpty())
         return V8WorkerGlobalScope::toImpl(workerWrapper)->executionContext();
     // FIXME: Is this line of code reachable?
     return 0;
 }
 
 ExecutionContext* currentExecutionContext(v8::Isolate* isolate)
 {
     return toExecutionContext(isolate->GetCurrentContext());
 }
 
 ExecutionContext* callingExecutionContext(v8::Isolate* isolate)
 {
-    v8::Handle<v8::Context> context = isolate->GetCallingContext();
+    v8::Local<v8::Context> context = isolate->GetCallingContext();
     if (context.IsEmpty()) {
         // Unfortunately, when processing script from a plugin, we might not
         // have a calling context. In those cases, we fall back to the
         // entered context.
         context = isolate->GetEnteredContext();
     }
     return toExecutionContext(context);
 }
 
-Frame* toFrameIfNotDetached(v8::Handle<v8::Context> context)
+Frame* toFrameIfNotDetached(v8::Local<v8::Context> context)
 {
     DOMWindow* window = toDOMWindow(context);
     if (window && window->isCurrentlyDisplayedInFrame())
         return window->frame();
     // We return 0 here because |context| is detached from the Frame. If we
     // did return |frame| we could get in trouble because the frame could be
     // navigated to another security origin.
     return nullptr;
 }
 
-EventTarget* toEventTarget(v8::Isolate* isolate, v8::Handle<v8::Value> value)
+EventTarget* toEventTarget(v8::Isolate* isolate, v8::Local<v8::Value> value)
 {
     // We need to handle a DOMWindow specially, because a DOMWindow wrapper
     // exists on a prototype chain of v8Value.
     if (DOMWindow* window = toDOMWindow(isolate, value))
         return static_cast<EventTarget*>(window);
     if (V8EventTarget::hasInstance(value, isolate)) {
-        v8::Local<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
+        v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
         return toWrapperTypeInfo(object)->toEventTarget(object);
     }
     return 0;
 }
 
 v8::Local<v8::Context> toV8Context(ExecutionContext* context, DOMWrapperWorld& world)
 {
     ASSERT(context);
     if (context->isDocument()) {
         if (LocalFrame* frame = toDocument(context)->frame())
@@ skipping 37 matching lines @@
 
 bool isValidEnum(const Vector<String>& values, const char** validValues, size_t length, const String& enumName, ExceptionState& exceptionState)
 {
     for (auto value : values) {
         if (!isValidEnum(value, validValues, length, enumName, exceptionState))
             return false;
     }
     return true;
 }
 
-v8::Handle<v8::Function> getBoundFunction(v8::Handle<v8::Function> function)
+v8::Local<v8::Function> getBoundFunction(v8::Local<v8::Function> function)
 {
-    v8::Handle<v8::Value> boundFunction = function->GetBoundFunction();
-    return boundFunction->IsFunction() ? v8::Handle<v8::Function>::Cast(boundFunction) : function;
+    v8::Local<v8::Value> boundFunction = function->GetBoundFunction();
+    return boundFunction->IsFunction() ? v8::Local<v8::Function>::Cast(boundFunction) : function;
 }
 
-void addHiddenValueToArray(v8::Isolate* isolate, v8::Handle<v8::Object> object, v8::Local<v8::Value> value, int arrayIndex)
+void addHiddenValueToArray(v8::Isolate* isolate, v8::Local<v8::Object> object, v8::Local<v8::Value> value, int arrayIndex)
 {
     ASSERT(!value.IsEmpty());
     v8::Local<v8::Value> arrayValue = object->GetInternalField(arrayIndex);
     if (arrayValue->IsNull() || arrayValue->IsUndefined()) {
         arrayValue = v8::Array::New(isolate);
         object->SetInternalField(arrayIndex, arrayValue);
     }
 
     v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(arrayValue);
     array->Set(v8::Integer::New(isolate, array->Length()), value);
 }
 
-void removeHiddenValueFromArray(v8::Isolate* isolate, v8::Handle<v8::Object> object, v8::Local<v8::Value> value, int arrayIndex)
+void removeHiddenValueFromArray(v8::Isolate* isolate, v8::Local<v8::Object> object, v8::Local<v8::Value> value, int arrayIndex)
 {
     v8::Local<v8::Value> arrayValue = object->GetInternalField(arrayIndex);
     if (!arrayValue->IsArray())
         return;
     v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(arrayValue);
     for (int i = array->Length() - 1; i >= 0; --i) {
         v8::Local<v8::Value> item;
         if (!array->Get(isolate->GetCurrentContext(), i).ToLocal(&item))
             return;
         if (item->StrictEquals(value)) {
             array->Delete(isolate->GetCurrentContext(), i);
             return;
         }
     }
 }
 
-void moveEventListenerToNewWrapper(v8::Isolate* isolate, v8::Handle<v8::Object> object, EventListener* oldValue, v8::Local<v8::Value> newValue, int arrayIndex)
+void moveEventListenerToNewWrapper(v8::Isolate* isolate, v8::Local<v8::Object> object, EventListener* oldValue, v8::Local<v8::Value> newValue, int arrayIndex)
 {
     if (oldValue) {
         V8AbstractEventListener* oldListener = V8AbstractEventListener::cast(oldValue);
         if (oldListener) {
             v8::Local<v8::Object> oldListenerObject = oldListener->getExistingListenerObject();
             if (!oldListenerObject.IsEmpty())
                 removeHiddenValueFromArray(isolate, object, oldListenerObject, arrayIndex);
         }
     }
     // Non-callable input is treated as null and ignored
@@ skipping 76 matching lines @@
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 void DevToolsFunctionInfo::ensureInitialized() const
 {
     if (m_function.IsEmpty())
         return;
 
-    v8::Handle<v8::Function> originalFunction = getBoundFunction(m_function);
+    v8::Local<v8::Function> originalFunction = getBoundFunction(m_function);
     m_scriptId = originalFunction->ScriptId();
     v8::ScriptOrigin origin = originalFunction->GetScriptOrigin();
     if (!origin.ResourceName().IsEmpty()) {
         V8StringResource<> stringResource(origin.ResourceName());
         stringResource.prepare();
         m_resourceName = stringResource;
         m_lineNumber = originalFunction->GetScriptLineNumber() + 1;
     }
     if (m_resourceName.isEmpty()) {
         m_resourceName = "undefined";
@@ skipping 14 matching lines @@
     ensureInitialized();
     return m_lineNumber;
 }
 
 String DevToolsFunctionInfo::resourceName() const
 {
     ensureInitialized();
     return m_resourceName;
 }
 
-PassRefPtr<TraceEvent::ConvertableToTraceFormat> devToolsTraceEventData(v8::Isolate* isolate, ExecutionContext* context, v8::Handle<v8::Function> function)
+PassRefPtr<TraceEvent::ConvertableToTraceFormat> devToolsTraceEventData(v8::Isolate* isolate, ExecutionContext* context, v8::Local<v8::Function> function)
 {
     DevToolsFunctionInfo info(function);
     return InspectorFunctionCallEvent::data(context, info.scriptId(), info.resourceName(), info.lineNumber());
 }
 
 void v8ConstructorAttributeGetter(v8::Local<v8::Name> propertyName, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter");
     v8::Local<v8::Value> data = info.Data();
     ASSERT(data->IsExternal());
     V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
     if (!perContextData)
         return;
     v8SetReturnValue(info, perContextData->constructorForType(WrapperTypeInfo::unwrap(data)));
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
 } // namespace blink