From ab0a50979b9eb4dfa3320eff7e187e41efedf7a9 Mon Sep 17 00:00:00 2001 From: Jocelyn Turcotte Date: Fri, 8 Aug 2014 14:30:41 +0200 Subject: Update Chromium to beta version 37.0.2062.68 Change-Id: I188e3b5aff1bec75566014291b654eb19f5bc8ca Reviewed-by: Andras Becsi --- chromium/gin/wrappable_unittest.cc | 175 +++++++++++++++++++++++++++++++------ 1 file changed, 148 insertions(+), 27 deletions(-) (limited to 'chromium/gin/wrappable_unittest.cc') diff --git a/chromium/gin/wrappable_unittest.cc b/chromium/gin/wrappable_unittest.cc index 3499eedcc18..4916153be52 100644 --- a/chromium/gin/wrappable_unittest.cc +++ b/chromium/gin/wrappable_unittest.cc @@ -15,7 +15,19 @@ namespace gin { -class MyObject : public Wrappable { +class BaseClass { + public: + BaseClass() : value_(23) {} + virtual ~BaseClass() {} + + private: + int value_; + + DISALLOW_COPY_AND_ASSIGN(BaseClass); +}; + +class MyObject : public BaseClass, + public Wrappable { public: static WrapperInfo kWrapperInfo; @@ -26,13 +38,72 @@ class MyObject : public Wrappable { int value() const { return value_; } void set_value(int value) { value_ = value; } - private: + protected: MyObject() : value_(0) {} + virtual ObjectTemplateBuilder GetObjectTemplateBuilder( + v8::Isolate* isolate) OVERRIDE; virtual ~MyObject() {} + private: int value_; }; +class MyObjectSubclass : public MyObject { + public: + static gin::Handle Create(v8::Isolate* isolate) { + return CreateHandle(isolate, new MyObjectSubclass()); + } + + void SayHello(const std::string& name) { + result = std::string("Hello, ") + name; + } + + std::string result; + + private: + virtual ObjectTemplateBuilder GetObjectTemplateBuilder( + v8::Isolate* isolate) OVERRIDE { + return MyObject::GetObjectTemplateBuilder(isolate) + .SetMethod("sayHello", &MyObjectSubclass::SayHello); + } + + MyObjectSubclass() { + } + + virtual ~MyObjectSubclass() { + } +}; + +class MyCallableObject : public Wrappable { + public: + static WrapperInfo kWrapperInfo; + + static gin::Handle Create(v8::Isolate* isolate) { + return CreateHandle(isolate, new MyCallableObject()); + } + + int result() { return result_; } + + private: + virtual ObjectTemplateBuilder GetObjectTemplateBuilder( + v8::Isolate* isolate) OVERRIDE { + return Wrappable::GetObjectTemplateBuilder(isolate) + .SetCallAsFunctionHandler(&MyCallableObject::Call); + } + + MyCallableObject() : result_(0) { + } + + virtual ~MyCallableObject() { + } + + void Call(int val) { + result_ = val; + } + + int result_; +}; + class MyObject2 : public Wrappable { public: static WrapperInfo kWrapperInfo; @@ -44,35 +115,21 @@ class MyObjectBlink : public Wrappable { }; WrapperInfo MyObject::kWrapperInfo = { kEmbedderNativeGin }; +ObjectTemplateBuilder MyObject::GetObjectTemplateBuilder(v8::Isolate* isolate) { + return Wrappable::GetObjectTemplateBuilder(isolate) + .SetProperty("value", &MyObject::value, &MyObject::set_value); +} + +WrapperInfo MyCallableObject::kWrapperInfo = { kEmbedderNativeGin }; WrapperInfo MyObject2::kWrapperInfo = { kEmbedderNativeGin }; WrapperInfo MyObjectBlink::kWrapperInfo = { kEmbedderNativeGin }; -void RegisterTemplates(v8::Isolate* isolate) { - PerIsolateData* data = PerIsolateData::From(isolate); - DCHECK(data->GetObjectTemplate(&MyObject::kWrapperInfo).IsEmpty()); - - v8::Handle templ = ObjectTemplateBuilder(isolate) - .SetProperty("value", &MyObject::value, &MyObject::set_value) - .Build(); - templ->SetInternalFieldCount(kNumberOfInternalFields); - data->SetObjectTemplate(&MyObject::kWrapperInfo, templ); - - templ = v8::ObjectTemplate::New(isolate); - templ->SetInternalFieldCount(kNumberOfInternalFields); - data->SetObjectTemplate(&MyObject2::kWrapperInfo, templ); - - templ = v8::ObjectTemplate::New(isolate); - templ->SetInternalFieldCount(kNumberOfInternalFields); - data->SetObjectTemplate(&MyObjectBlink::kWrapperInfo, templ); -} - typedef V8Test WrappableTest; TEST_F(WrappableTest, WrapAndUnwrap) { v8::Isolate* isolate = instance_->isolate(); v8::HandleScope handle_scope(isolate); - RegisterTemplates(isolate); Handle obj = MyObject::Create(isolate); v8::Handle wrapper = ConvertToV8(isolate, obj.get()); @@ -87,10 +144,8 @@ TEST_F(WrappableTest, UnwrapFailures) { v8::Isolate* isolate = instance_->isolate(); v8::HandleScope handle_scope(isolate); - RegisterTemplates(isolate); - // Something that isn't an object. - v8::Handle thing = v8::Number::New(42); + v8::Handle thing = v8::Number::New(isolate, 42); MyObject* unwrapped = NULL; EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped)); EXPECT_FALSE(unwrapped); @@ -117,7 +172,6 @@ TEST_F(WrappableTest, GetAndSetProperty) { v8::Isolate* isolate = instance_->isolate(); v8::HandleScope handle_scope(isolate); - RegisterTemplates(isolate); gin::Handle obj = MyObject::Create(isolate); obj->set_value(42); @@ -130,7 +184,7 @@ TEST_F(WrappableTest, GetAndSetProperty) { EXPECT_FALSE(source.IsEmpty()); gin::TryCatch try_catch; - v8::Handle script = v8::Script::New(source); + v8::Handle script = v8::Script::Compile(source); EXPECT_FALSE(script.IsEmpty()); v8::Handle val = script->Run(); EXPECT_FALSE(val.IsEmpty()); @@ -146,4 +200,71 @@ TEST_F(WrappableTest, GetAndSetProperty) { EXPECT_EQ(191, obj->value()); } +TEST_F(WrappableTest, WrappableSubclass) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + + gin::Handle object(MyObjectSubclass::Create(isolate)); + v8::Handle source = StringToV8(isolate, + "(function(obj) {" + "obj.sayHello('Lily');" + "})"); + gin::TryCatch try_catch; + v8::Handle script = v8::Script::Compile(source); + v8::Handle val = script->Run(); + v8::Handle func; + EXPECT_TRUE(ConvertFromV8(isolate, val, &func)); + v8::Handle argv[] = { + ConvertToV8(isolate, object.get()) + }; + func->Call(v8::Undefined(isolate), 1, argv); + EXPECT_FALSE(try_catch.HasCaught()); + EXPECT_EQ("Hello, Lily", object->result); +} + +TEST_F(WrappableTest, ErrorInObjectConstructorProperty) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + + v8::Handle source = StringToV8( + isolate, + "(function() {" + " Object.defineProperty(Object.prototype, 'constructor', {" + " get: function() { throw 'Error'; }," + " set: function() { throw 'Error'; }" + " });" + "})();"); + EXPECT_FALSE(source.IsEmpty()); + v8::Handle script = v8::Script::Compile(source); + script->Run(); + + gin::TryCatch try_catch; + gin::Handle obj = MyObject::Create(isolate); + EXPECT_TRUE(obj.IsEmpty()); + EXPECT_TRUE(try_catch.HasCaught()); +} + +TEST_F(WrappableTest, CallAsFunction) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + + gin::Handle object(MyCallableObject::Create(isolate)); + EXPECT_EQ(0, object->result()); + v8::Handle source = StringToV8(isolate, + "(function(obj) {" + "obj(42);" + "})"); + gin::TryCatch try_catch; + v8::Handle script = v8::Script::Compile(source); + v8::Handle val = script->Run(); + v8::Handle func; + EXPECT_TRUE(ConvertFromV8(isolate, val, &func)); + v8::Handle argv[] = { + ConvertToV8(isolate, object.get()) + }; + func->Call(v8::Undefined(isolate), 1, argv); + EXPECT_FALSE(try_catch.HasCaught()); + EXPECT_EQ(42, object->result()); +} + } // namespace gin -- cgit v1.2.3