Commit faaa1b6a authored by deepak.s's avatar deepak.s Committed by Commit bot

Replace Handle<> with Local in remaining gin/*

Handle is an alias for Local

BUG=424445

Review URL: https://codereview.chromium.org/1112923003

Cr-Commit-Position: refs/heads/master@{#327672}
parent f8b27693
......@@ -26,13 +26,13 @@ Arguments::Arguments(const v8::FunctionCallbackInfo<v8::Value>& info)
Arguments::~Arguments() {
}
v8::Handle<v8::Value> Arguments::PeekNext() const {
v8::Local<v8::Value> Arguments::PeekNext() const {
if (next_ >= info_->Length())
return v8::Handle<v8::Value>();
return v8::Local<v8::Value>();
return (*info_)[next_];
}
std::string V8TypeAsString(v8::Handle<v8::Value> value) {
std::string V8TypeAsString(v8::Local<v8::Value> value) {
if (value.IsEmpty())
return "<empty handle>";
if (value->IsUndefined())
......
......@@ -36,7 +36,7 @@ class GIN_EXPORT Arguments {
insufficient_arguments_ = true;
return false;
}
v8::Handle<v8::Value> val = (*info_)[next_++];
v8::Local<v8::Value> val = (*info_)[next_++];
return ConvertFromV8(isolate_, val, out);
}
......@@ -49,7 +49,7 @@ class GIN_EXPORT Arguments {
int remaining = info_->Length() - next_;
out->resize(remaining);
for (int i = 0; i < remaining; ++i) {
v8::Handle<v8::Value> val = (*info_)[next_++];
v8::Local<v8::Value> val = (*info_)[next_++];
if (!ConvertFromV8(isolate_, val, &out->at(i)))
return false;
}
......@@ -72,7 +72,7 @@ class GIN_EXPORT Arguments {
info_->GetReturnValue().Set(ConvertToV8(isolate_, val));
}
v8::Handle<v8::Value> PeekNext() const;
v8::Local<v8::Value> PeekNext() const;
void ThrowError() const;
void ThrowTypeError(const std::string& message) const;
......
......@@ -62,7 +62,7 @@ ArrayBufferAllocator* ArrayBufferAllocator::SharedInstance() {
class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
public:
static scoped_refptr<Private> From(v8::Isolate* isolate,
v8::Handle<v8::ArrayBuffer> array);
v8::Local<v8::ArrayBuffer> array);
void* buffer() const { return buffer_; }
size_t length() const { return length_; }
......@@ -70,7 +70,7 @@ class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
private:
friend class base::RefCounted<Private>;
Private(v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array);
Private(v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> array);
~Private();
static void FirstWeakCallback(const v8::WeakCallbackInfo<Private>& data);
......@@ -84,9 +84,9 @@ class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
};
scoped_refptr<ArrayBuffer::Private> ArrayBuffer::Private::From(
v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array) {
v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> array) {
if (array->IsExternal()) {
CHECK_EQ(WrapperInfo::From(v8::Handle<v8::Object>::Cast(array)),
CHECK_EQ(WrapperInfo::From(v8::Local<v8::Object>::Cast(array)),
&g_array_buffer_wrapper_info)
<< "Cannot mix blink and gin ArrayBuffers";
return make_scoped_refptr(static_cast<Private*>(
......@@ -96,7 +96,7 @@ scoped_refptr<ArrayBuffer::Private> ArrayBuffer::Private::From(
}
ArrayBuffer::Private::Private(v8::Isolate* isolate,
v8::Handle<v8::ArrayBuffer> array)
v8::Local<v8::ArrayBuffer> array)
: array_buffer_(isolate, array), isolate_(isolate) {
// Take ownership of the array buffer.
CHECK(!array->IsExternal());
......@@ -138,7 +138,7 @@ ArrayBuffer::ArrayBuffer()
}
ArrayBuffer::ArrayBuffer(v8::Isolate* isolate,
v8::Handle<v8::ArrayBuffer> array) {
v8::Local<v8::ArrayBuffer> array) {
private_ = ArrayBuffer::Private::From(isolate, array);
bytes_ = private_->buffer();
num_bytes_ = private_->length();
......@@ -157,11 +157,11 @@ ArrayBuffer& ArrayBuffer::operator=(const ArrayBuffer& other) {
// Converter<ArrayBuffer> -----------------------------------------------------
bool Converter<ArrayBuffer>::FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
ArrayBuffer* out) {
if (!val->IsArrayBuffer())
return false;
*out = ArrayBuffer(isolate, v8::Handle<v8::ArrayBuffer>::Cast(val));
*out = ArrayBuffer(isolate, v8::Local<v8::ArrayBuffer>::Cast(val));
return true;
}
......@@ -173,7 +173,7 @@ ArrayBufferView::ArrayBufferView()
}
ArrayBufferView::ArrayBufferView(v8::Isolate* isolate,
v8::Handle<v8::ArrayBufferView> view)
v8::Local<v8::ArrayBufferView> view)
: array_buffer_(isolate, view->Buffer()),
offset_(view->ByteOffset()),
num_bytes_(view->ByteLength()) {
......@@ -193,11 +193,11 @@ ArrayBufferView& ArrayBufferView::operator=(const ArrayBufferView& other) {
// Converter<ArrayBufferView> -------------------------------------------------
bool Converter<ArrayBufferView>::FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
ArrayBufferView* out) {
if (!val->IsArrayBufferView())
return false;
*out = ArrayBufferView(isolate, v8::Handle<v8::ArrayBufferView>::Cast(val));
*out = ArrayBufferView(isolate, v8::Local<v8::ArrayBufferView>::Cast(val));
return true;
}
......
......@@ -26,7 +26,7 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
class GIN_EXPORT ArrayBuffer {
public:
ArrayBuffer();
ArrayBuffer(v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> buffer);
ArrayBuffer(v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> buffer);
~ArrayBuffer();
ArrayBuffer& operator=(const ArrayBuffer& other);
......@@ -45,14 +45,14 @@ class GIN_EXPORT ArrayBuffer {
template<>
struct GIN_EXPORT Converter<ArrayBuffer> {
static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
ArrayBuffer* out);
};
class GIN_EXPORT ArrayBufferView {
public:
ArrayBufferView();
ArrayBufferView(v8::Isolate* isolate, v8::Handle<v8::ArrayBufferView> view);
ArrayBufferView(v8::Isolate* isolate, v8::Local<v8::ArrayBufferView> view);
~ArrayBufferView();
ArrayBufferView& operator=(const ArrayBufferView& other);
......@@ -71,7 +71,7 @@ class GIN_EXPORT ArrayBufferView {
template<>
struct GIN_EXPORT Converter<ArrayBufferView> {
static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
ArrayBufferView* out);
};
......
......@@ -18,7 +18,7 @@ ContextHolder::~ContextHolder() {
data_.reset();
}
void ContextHolder::SetContext(v8::Handle<v8::Context> context) {
void ContextHolder::SetContext(v8::Local<v8::Context> context) {
DCHECK(context_.IsEmpty());
context_.Reset(isolate_, context);
data_.reset(new PerContextData(this, context));
......
......@@ -166,7 +166,7 @@ Handle<Value> Converter<Handle<External> >::ToV8(Isolate* isolate,
}
bool Converter<Handle<External> >::FromV8(Isolate* isolate,
v8::Handle<Value> val,
v8::Local<Value> val,
Handle<External>* out) {
if (!val->IsExternal())
return false;
......@@ -185,7 +185,7 @@ bool Converter<Handle<Value> >::FromV8(Isolate* isolate, Handle<Value> val,
return true;
}
v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
const base::StringPiece& val) {
return String::NewFromUtf8(isolate,
val.data(),
......@@ -193,7 +193,7 @@ v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
static_cast<uint32_t>(val.length()));
}
std::string V8ToString(v8::Handle<v8::Value> value) {
std::string V8ToString(v8::Local<v8::Value> value) {
if (value.IsEmpty())
return std::string();
std::string result;
......
......@@ -19,133 +19,133 @@ struct Converter {};
template<>
struct GIN_EXPORT Converter<bool> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
bool val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
bool* out);
};
template<>
struct GIN_EXPORT Converter<int32_t> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
int32_t val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
int32_t* out);
};
template<>
struct GIN_EXPORT Converter<uint32_t> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
uint32_t val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
uint32_t* out);
};
template<>
struct GIN_EXPORT Converter<int64_t> {
// Warning: JavaScript cannot represent 64 integers precisely.
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
int64_t val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
int64_t* out);
};
template<>
struct GIN_EXPORT Converter<uint64_t> {
// Warning: JavaScript cannot represent 64 integers precisely.
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
uint64_t val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
uint64_t* out);
};
template<>
struct GIN_EXPORT Converter<float> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
float val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
float* out);
};
template<>
struct GIN_EXPORT Converter<double> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
double val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
double* out);
};
template<>
struct GIN_EXPORT Converter<base::StringPiece> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const base::StringPiece& val);
// No conversion out is possible because StringPiece does not contain storage.
};
template<>
struct GIN_EXPORT Converter<std::string> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const std::string& val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
std::string* out);
};
template<>
struct GIN_EXPORT Converter<v8::Handle<v8::Function> > {
struct GIN_EXPORT Converter<v8::Local<v8::Function> > {
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Handle<v8::Function>* out);
v8::Local<v8::Value> val,
v8::Local<v8::Function>* out);
};
template<>
struct GIN_EXPORT Converter<v8::Handle<v8::Object> > {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
v8::Handle<v8::Object> val);
struct GIN_EXPORT Converter<v8::Local<v8::Object> > {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
v8::Local<v8::Object> val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Handle<v8::Object>* out);
v8::Local<v8::Value> val,
v8::Local<v8::Object>* out);
};
template<>
struct GIN_EXPORT Converter<v8::Handle<v8::ArrayBuffer> > {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
v8::Handle<v8::ArrayBuffer> val);
struct GIN_EXPORT Converter<v8::Local<v8::ArrayBuffer> > {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
v8::Local<v8::ArrayBuffer> val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Handle<v8::ArrayBuffer>* out);
v8::Local<v8::Value> val,
v8::Local<v8::ArrayBuffer>* out);
};
template<>
struct GIN_EXPORT Converter<v8::Handle<v8::External> > {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
v8::Handle<v8::External> val);
struct GIN_EXPORT Converter<v8::Local<v8::External> > {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
v8::Local<v8::External> val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Handle<v8::External>* out);
v8::Local<v8::Value> val,
v8::Local<v8::External>* out);
};
template<>
struct GIN_EXPORT Converter<v8::Handle<v8::Value> > {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val);
struct GIN_EXPORT Converter<v8::Local<v8::Value> > {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
v8::Local<v8::Value> val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Handle<v8::Value>* out);
v8::Local<v8::Value> val,
v8::Local<v8::Value>* out);
};
template<typename T>
struct Converter<std::vector<T> > {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const std::vector<T>& val) {
v8::Handle<v8::Array> result(
v8::Local<v8::Array> result(
v8::Array::New(isolate, static_cast<int>(val.size())));
for (size_t i = 0; i < val.size(); ++i) {
result->Set(static_cast<int>(i), Converter<T>::ToV8(isolate, val[i]));
......@@ -154,13 +154,13 @@ struct Converter<std::vector<T> > {
}
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
std::vector<T>* out) {
if (!val->IsArray())
return false;
std::vector<T> result;
v8::Handle<v8::Array> array(v8::Handle<v8::Array>::Cast(val));
v8::Local<v8::Array> array(v8::Local<v8::Array>::Cast(val));
uint32_t length = array->Length();
for (uint32_t i = 0; i < length; ++i) {
T item;
......@@ -176,26 +176,26 @@ struct Converter<std::vector<T> > {
// Convenience functions that deduce T.
template<typename T>
v8::Handle<v8::Value> ConvertToV8(v8::Isolate* isolate, T input) {
v8::Local<v8::Value> ConvertToV8(v8::Isolate* isolate, T input) {
return Converter<T>::ToV8(isolate, input);
}
GIN_EXPORT inline v8::Handle<v8::String> StringToV8(
GIN_EXPORT inline v8::Local<v8::String> StringToV8(
v8::Isolate* isolate,
const base::StringPiece& input) {
return ConvertToV8(isolate, input).As<v8::String>();
}
GIN_EXPORT v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
GIN_EXPORT v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
const base::StringPiece& val);
template<typename T>
bool ConvertFromV8(v8::Isolate* isolate, v8::Handle<v8::Value> input,
bool ConvertFromV8(v8::Isolate* isolate, v8::Local<v8::Value> input,
T* result) {
return Converter<T>::FromV8(isolate, input, result);
}
GIN_EXPORT std::string V8ToString(v8::Handle<v8::Value> value);
GIN_EXPORT std::string V8ToString(v8::Local<v8::Value> value);
} // namespace gin
......
......@@ -79,7 +79,7 @@ TEST_F(ConverterTest, Int32) {
}
struct {
v8::Handle<v8::Value> input;
v8::Local<v8::Value> input;
bool expect_sucess;
int expected_result;
} test_data_from[] = {
......
......@@ -11,7 +11,7 @@ Dictionary::Dictionary(v8::Isolate* isolate)
}
Dictionary::Dictionary(v8::Isolate* isolate,
v8::Handle<v8::Object> object)
v8::Local<v8::Object> object)
: isolate_(isolate),
object_(object) {
}
......@@ -25,17 +25,17 @@ Dictionary Dictionary::CreateEmpty(v8::Isolate* isolate) {
return dictionary;
}
v8::Handle<v8::Value> Converter<Dictionary>::ToV8(v8::Isolate* isolate,
v8::Local<v8::Value> Converter<Dictionary>::ToV8(v8::Isolate* isolate,
Dictionary val) {
return val.object_;
}
bool Converter<Dictionary>::FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
Dictionary* out) {
if (!val->IsObject())
return false;
*out = Dictionary(isolate, v8::Handle<v8::Object>::Cast(val));
*out = Dictionary(isolate, v8::Local<v8::Object>::Cast(val));
return true;
}
......
......@@ -25,14 +25,14 @@ namespace gin {
class GIN_EXPORT Dictionary {
public:
explicit Dictionary(v8::Isolate* isolate);
Dictionary(v8::Isolate* isolate, v8::Handle<v8::Object> object);
Dictionary(v8::Isolate* isolate, v8::Local<v8::Object> object);
~Dictionary();
static Dictionary CreateEmpty(v8::Isolate* isolate);
template<typename T>
bool Get(const std::string& key, T* out) {
v8::Handle<v8::Value> val = object_->Get(StringToV8(isolate_, key));
v8::Local<v8::Value> val = object_->Get(StringToV8(isolate_, key));
return ConvertFromV8(isolate_, val, out);
}
......@@ -48,15 +48,15 @@ class GIN_EXPORT Dictionary {
// TODO(aa): Remove this. Instead, get via FromV8(), Set(), and Get().
v8::Isolate* isolate_;
v8::Handle<v8::Object> object_;
v8::Local<v8::Object> object_;
};
template<>
struct GIN_EXPORT Converter<Dictionary> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
Dictionary val);
static bool FromV8(v8::Isolate* isolate,
v8::Handle<v8::Value> val,
v8::Local<v8::Value> val,
Dictionary* out);
};
......
......@@ -18,7 +18,7 @@ CallbackHolderBase::~CallbackHolderBase() {
DCHECK(v8_ref_.IsEmpty());
}
v8::Handle<v8::External> CallbackHolderBase::GetHandle(v8::Isolate* isolate) {
v8::Local<v8::External> CallbackHolderBase::GetHandle(v8::Isolate* isolate) {
return v8::Local<v8::External>::New(isolate, v8_ref_);
}
......
......@@ -44,7 +44,7 @@ struct CallbackParamTraits<const T*> {
// among every CallbackHolder instance.
class GIN_EXPORT CallbackHolderBase {
public:
v8::Handle<v8::External> GetHandle(v8::Isolate* isolate);
v8::Local<v8::External> GetHandle(v8::Isolate* isolate);
protected:
explicit CallbackHolderBase(v8::Isolate* isolate);
......@@ -200,7 +200,7 @@ struct Dispatcher<ReturnType(ArgTypes...)> {
static void DispatchToCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
Arguments args(info);
v8::Handle<v8::External> v8_holder;
v8::Local<v8::External> v8_holder;
CHECK(args.GetData(&v8_holder));
CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>(
v8_holder->Value());
......@@ -237,7 +237,7 @@ v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
return v8::FunctionTemplate::New(
isolate,
&internal::Dispatcher<Sig>::DispatchToCallback,
ConvertToV8<v8::Handle<v8::External> >(isolate,
ConvertToV8<v8::Local<v8::External> >(isolate,
holder->GetHandle(isolate)));
}
......@@ -251,7 +251,7 @@ void CreateFunctionHandler(v8::Isolate* isolate,
typedef internal::CallbackHolder<Sig> HolderT;
HolderT* holder = new HolderT(isolate, callback, callback_flags);
tmpl->SetCallAsFunctionHandler(&internal::Dispatcher<Sig>::DispatchToCallback,
ConvertToV8<v8::Handle<v8::External> >(
ConvertToV8<v8::Local<v8::External> >(
isolate, holder->GetHandle(isolate)));
}
......
......@@ -18,7 +18,7 @@ class Handle {
public:
Handle() : object_(NULL) {}
Handle(v8::Handle<v8::Value> wrapper, T* object)
Handle(v8::Local<v8::Value> wrapper, T* object)
: wrapper_(wrapper),
object_(object) {
}
......@@ -31,21 +31,21 @@ class Handle {
}
T* operator->() const { return object_; }
v8::Handle<v8::Value> ToV8() const { return wrapper_; }
v8::Local<v8::Value> ToV8() const { return wrapper_; }
T* get() const { return object_; }
private:
v8::Handle<v8::Value> wrapper_;
v8::Local<v8::Value> wrapper_;
T* object_;
};
template<typename T>
struct Converter<gin::Handle<T> > {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const gin::Handle<T>& val) {
return val.ToV8();
}
static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
gin::Handle<T>* out) {
T* object = NULL;
if (!Converter<T*>::FromV8(isolate, val, &object)) {
......@@ -60,7 +60,7 @@ struct Converter<gin::Handle<T> > {
// without having to write out the type of the object explicitly.
template<typename T>
gin::Handle<T> CreateHandle(v8::Isolate* isolate, T* object) {
v8::Handle<v8::Object> wrapper = object->GetWrapper(isolate);
v8::Local<v8::Object> wrapper = object->GetWrapper(isolate);
if (wrapper.IsEmpty())
return gin::Handle<T>();
return gin::Handle<T>(wrapper, object);
......
......@@ -136,17 +136,17 @@ class InterceptorTest : public V8Test {
obj->set_value(42);
EXPECT_EQ(42, obj->value());
v8::Handle<v8::