Skip to content

Commit

Permalink
gin: Use v8::Local instead of v8::Handle.
Browse files Browse the repository at this point in the history 
Turns out, Handle is just an alias for Local:
https://chromium.googlesource.com/v8/v8.git/+/master/include/v8.h#334

BUG=424445
TEST=gin_unittests
R=jochen@chromium.org

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

Cr-Commit-Position: refs/heads/master@{#328120}
  • Loading branch information
@tfarina
tfarina authored and Commit bot committed May 4, 2015
1 parent c0f287d commit 777bfee
Show file tree
Hide file tree
Showing 2 changed files with 57 additions and 50 deletions.
99 changes: 53 additions & 46 deletions gin/converter.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,54 +10,57 @@ using v8::ArrayBuffer;
using v8::Boolean;
using v8::External;
using v8::Function;
using v8::Handle;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Number;
using v8::Object;
using v8::String;
using v8::Value;

namespace gin {

Handle<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) {
Local<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) {
return Boolean::New(isolate, val).As<Value>();
}

bool Converter<bool>::FromV8(Isolate* isolate, Handle<Value> val, bool* out) {
bool Converter<bool>::FromV8(Isolate* isolate, Local<Value> val, bool* out) {
*out = val->BooleanValue();
return true;
}

Handle<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) {
Local<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) {
return Integer::New(isolate, val).As<Value>();
}

bool Converter<int32_t>::FromV8(Isolate* isolate, Handle<Value> val,
bool Converter<int32_t>::FromV8(Isolate* isolate,
Local<Value> val,
int32_t* out) {
if (!val->IsInt32())
return false;
*out = val->Int32Value();
return true;
}

Handle<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) {
Local<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) {
return Integer::NewFromUnsigned(isolate, val).As<Value>();
}

bool Converter<uint32_t>::FromV8(Isolate* isolate, Handle<Value> val,
bool Converter<uint32_t>::FromV8(Isolate* isolate,
Local<Value> val,
uint32_t* out) {
if (!val->IsUint32())
return false;
*out = val->Uint32Value();
return true;
}

Handle<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
Local<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
return Number::New(isolate, static_cast<double>(val)).As<Value>();
}

bool Converter<int64_t>::FromV8(Isolate* isolate, Handle<Value> val,
bool Converter<int64_t>::FromV8(Isolate* isolate,
Local<Value> val,
int64_t* out) {
if (!val->IsNumber())
return false;
Expand All @@ -67,120 +70,124 @@ bool Converter<int64_t>::FromV8(Isolate* isolate, Handle<Value> val,
return true;
}

Handle<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
Local<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
return Number::New(isolate, static_cast<double>(val)).As<Value>();
}

bool Converter<uint64_t>::FromV8(Isolate* isolate, Handle<Value> val,
bool Converter<uint64_t>::FromV8(Isolate* isolate,
Local<Value> val,
uint64_t* out) {
if (!val->IsNumber())
return false;
*out = static_cast<uint64_t>(val->IntegerValue());
return true;
}

Handle<Value> Converter<float>::ToV8(Isolate* isolate, float val) {
Local<Value> Converter<float>::ToV8(Isolate* isolate, float val) {
return Number::New(isolate, val).As<Value>();
}

bool Converter<float>::FromV8(Isolate* isolate, Handle<Value> val,
float* out) {
bool Converter<float>::FromV8(Isolate* isolate, Local<Value> val, float* out) {
if (!val->IsNumber())
return false;
*out = static_cast<float>(val->NumberValue());
return true;
}

Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
Local<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
return Number::New(isolate, val).As<Value>();
}

bool Converter<double>::FromV8(Isolate* isolate, Handle<Value> val,
bool Converter<double>::FromV8(Isolate* isolate,
Local<Value> val,
double* out) {
if (!val->IsNumber())
return false;
*out = val->NumberValue();
return true;
}

Handle<Value> Converter<base::StringPiece>::ToV8(
Isolate* isolate, const base::StringPiece& val) {
Local<Value> Converter<base::StringPiece>::ToV8(Isolate* isolate,
const base::StringPiece& val) {
return String::NewFromUtf8(isolate, val.data(), String::kNormalString,
static_cast<uint32_t>(val.length()));
}

Handle<Value> Converter<std::string>::ToV8(Isolate* isolate,
const std::string& val) {
Local<Value> Converter<std::string>::ToV8(Isolate* isolate,
const std::string& val) {
return Converter<base::StringPiece>::ToV8(isolate, val);
}

bool Converter<std::string>::FromV8(Isolate* isolate, Handle<Value> val,
bool Converter<std::string>::FromV8(Isolate* isolate,
Local<Value> val,
std::string* out) {
if (!val->IsString())
return false;
Handle<String> str = Handle<String>::Cast(val);
Local<String> str = Local<String>::Cast(val);
int length = str->Utf8Length();
out->resize(length);
str->WriteUtf8(&(*out)[0], length, NULL, String::NO_NULL_TERMINATION);
return true;
}

bool Converter<Handle<Function> >::FromV8(Isolate* isolate, Handle<Value> val,
Handle<Function>* out) {
bool Converter<Local<Function>>::FromV8(Isolate* isolate,
Local<Value> val,
Local<Function>* out) {
if (!val->IsFunction())
return false;
*out = Handle<Function>::Cast(val);
*out = Local<Function>::Cast(val);
return true;
}

Handle<Value> Converter<Handle<Object> >::ToV8(Isolate* isolate,
Handle<Object> val) {
Local<Value> Converter<Local<Object>>::ToV8(Isolate* isolate,
Local<Object> val) {
return val.As<Value>();
}

bool Converter<Handle<Object> >::FromV8(Isolate* isolate, Handle<Value> val,
Handle<Object>* out) {
bool Converter<Local<Object>>::FromV8(Isolate* isolate,
Local<Value> val,
Local<Object>* out) {
if (!val->IsObject())
return false;
*out = Handle<Object>::Cast(val);
*out = Local<Object>::Cast(val);
return true;
}

Handle<Value> Converter<Handle<ArrayBuffer> >::ToV8(Isolate* isolate,
Handle<ArrayBuffer> val) {
Local<Value> Converter<Local<ArrayBuffer>>::ToV8(Isolate* isolate,
Local<ArrayBuffer> val) {
return val.As<Value>();
}

bool Converter<Handle<ArrayBuffer> >::FromV8(Isolate* isolate,
Handle<Value> val,
Handle<ArrayBuffer>* out) {
bool Converter<Local<ArrayBuffer>>::FromV8(Isolate* isolate,
Local<Value> val,
Local<ArrayBuffer>* out) {
if (!val->IsArrayBuffer())
return false;
*out = Handle<ArrayBuffer>::Cast(val);
*out = Local<ArrayBuffer>::Cast(val);
return true;
}

Handle<Value> Converter<Handle<External> >::ToV8(Isolate* isolate,
Handle<External> val) {
Local<Value> Converter<Local<External>>::ToV8(Isolate* isolate,
Local<External> val) {
return val.As<Value>();
}

bool Converter<Handle<External> >::FromV8(Isolate* isolate,
v8::Local<Value> val,
Handle<External>* out) {
bool Converter<Local<External>>::FromV8(Isolate* isolate,
v8::Local<Value> val,
Local<External>* out) {
if (!val->IsExternal())
return false;
*out = Handle<External>::Cast(val);
*out = Local<External>::Cast(val);
return true;
}

Handle<Value> Converter<Handle<Value> >::ToV8(Isolate* isolate,
Handle<Value> val) {
Local<Value> Converter<Local<Value>>::ToV8(Isolate* isolate, Local<Value> val) {
return val;
}

bool Converter<Handle<Value> >::FromV8(Isolate* isolate, Handle<Value> val,
Handle<Value>* out) {
bool Converter<Local<Value>>::FromV8(Isolate* isolate,
Local<Value> val,
Local<Value>* out) {
*out = val;
return true;
}
Expand Down
8 changes: 4 additions & 4 deletions gin/converter_unittest.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,9 +16,9 @@

using v8::Array;
using v8::Boolean;
using v8::Handle;
using v8::HandleScope;
using v8::Integer;
using v8::Local;
using v8::Null;
using v8::Number;
using v8::Object;
Expand All @@ -39,7 +39,7 @@ TEST_F(ConverterTest, Bool) {
Boolean::New(instance_->isolate(), false)));

struct {
Handle<Value> input;
Local<Value> input;
bool expected;
} test_data[] = {
{ Boolean::New(instance_->isolate(), false).As<Value>(), false },
Expand Down Expand Up @@ -116,8 +116,8 @@ TEST_F(ConverterTest, Vector) {
expected.push_back(0);
expected.push_back(1);

Handle<Array> js_array = Handle<Array>::Cast(
Converter<std::vector<int> >::ToV8(instance_->isolate(), expected));
Local<Array> js_array = Local<Array>::Cast(
Converter<std::vector<int>>::ToV8(instance_->isolate(), expected));
ASSERT_FALSE(js_array.IsEmpty());
EXPECT_EQ(3u, js_array->Length());
for (size_t i = 0; i < expected.size(); ++i) {
Expand Down

0 comments on commit 777bfee

Please sign in to comment.