OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "base/logging.h" |
| 6 #include "gin/arguments.h" |
| 7 #include "gin/handle.h" |
| 8 #include "gin/interceptor.h" |
| 9 #include "gin/object_template_builder.h" |
| 10 #include "gin/per_isolate_data.h" |
| 11 #include "gin/public/isolate_holder.h" |
| 12 #include "gin/test/v8_test.h" |
| 13 #include "gin/try_catch.h" |
| 14 #include "gin/wrappable.h" |
| 15 #include "testing/gtest/include/gtest/gtest.h" |
| 16 |
| 17 namespace gin { |
| 18 |
| 19 class MyInterceptor : public Wrappable<MyInterceptor>, |
| 20 public NamedPropertyInterceptor, |
| 21 public IndexedPropertyInterceptor { |
| 22 public: |
| 23 static WrapperInfo kWrapperInfo; |
| 24 |
| 25 static gin::Handle<MyInterceptor> Create(v8::Isolate* isolate) { |
| 26 return CreateHandle(isolate, new MyInterceptor(isolate)); |
| 27 } |
| 28 |
| 29 int value() const { return value_; } |
| 30 void set_value(int value) { value_ = value; } |
| 31 |
| 32 // gin::NamedPropertyInterceptor |
| 33 virtual v8::Local<v8::Value> GetNamedProperty(v8::Isolate* isolate, |
| 34 const std::string& property) |
| 35 OVERRIDE { |
| 36 if (property == "value") { |
| 37 return ConvertToV8(isolate, value_); |
| 38 } else if (property == "func") { |
| 39 return CreateFunctionTemplate(isolate, |
| 40 base::Bind(&MyInterceptor::Call), |
| 41 HolderIsFirstArgument)->GetFunction(); |
| 42 } else { |
| 43 return v8::Local<v8::Value>(); |
| 44 } |
| 45 } |
| 46 virtual void SetNamedProperty(v8::Isolate* isolate, |
| 47 const std::string& property, |
| 48 v8::Local<v8::Value> value) OVERRIDE { |
| 49 if (property != "value") |
| 50 return; |
| 51 ConvertFromV8(isolate, value, &value_); |
| 52 } |
| 53 virtual std::vector<std::string> EnumerateNamedProperties( |
| 54 v8::Isolate* isolate) OVERRIDE { |
| 55 std::vector<std::string> result; |
| 56 result.push_back("func"); |
| 57 result.push_back("value"); |
| 58 return result; |
| 59 } |
| 60 |
| 61 // gin::IndexedPropertyInterceptor |
| 62 virtual v8::Local<v8::Value> GetIndexedProperty(v8::Isolate* isolate, |
| 63 uint32_t index) OVERRIDE { |
| 64 if (index == 0) |
| 65 return ConvertToV8(isolate, value_); |
| 66 return v8::Local<v8::Value>(); |
| 67 } |
| 68 virtual void SetIndexedProperty(v8::Isolate* isolate, |
| 69 uint32_t index, |
| 70 v8::Local<v8::Value> value) OVERRIDE { |
| 71 if (index != 0) |
| 72 return; |
| 73 ConvertFromV8(isolate, value, &value_); |
| 74 } |
| 75 virtual std::vector<uint32_t> EnumerateIndexedProperties(v8::Isolate* isolate) |
| 76 OVERRIDE { |
| 77 std::vector<uint32_t> result; |
| 78 result.push_back(0); |
| 79 return result; |
| 80 } |
| 81 |
| 82 private: |
| 83 explicit MyInterceptor(v8::Isolate* isolate) |
| 84 : NamedPropertyInterceptor(isolate, this), |
| 85 IndexedPropertyInterceptor(isolate, this), |
| 86 value_(0) {} |
| 87 virtual ~MyInterceptor() {} |
| 88 |
| 89 // gin::Wrappable |
| 90 virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) |
| 91 OVERRIDE { |
| 92 return Wrappable<MyInterceptor>::GetObjectTemplateBuilder(isolate) |
| 93 .AddNamedPropertyInterceptor() |
| 94 .AddIndexedPropertyInterceptor(); |
| 95 } |
| 96 |
| 97 int Call(int value) { |
| 98 int tmp = value_; |
| 99 value_ = value; |
| 100 return tmp; |
| 101 } |
| 102 |
| 103 int value_; |
| 104 }; |
| 105 |
| 106 WrapperInfo MyInterceptor::kWrapperInfo = {kEmbedderNativeGin}; |
| 107 |
| 108 class InterceptorTest : public V8Test { |
| 109 public: |
| 110 void RunInterceptorTest(const std::string& script_source) { |
| 111 v8::Isolate* isolate = instance_->isolate(); |
| 112 v8::HandleScope handle_scope(isolate); |
| 113 |
| 114 gin::Handle<MyInterceptor> obj = MyInterceptor::Create(isolate); |
| 115 |
| 116 obj->set_value(42); |
| 117 EXPECT_EQ(42, obj->value()); |
| 118 |
| 119 v8::Handle<v8::String> source = StringToV8(isolate, script_source); |
| 120 EXPECT_FALSE(source.IsEmpty()); |
| 121 |
| 122 gin::TryCatch try_catch; |
| 123 v8::Handle<v8::Script> script = v8::Script::Compile(source); |
| 124 EXPECT_FALSE(script.IsEmpty()); |
| 125 v8::Handle<v8::Value> val = script->Run(); |
| 126 EXPECT_FALSE(val.IsEmpty()); |
| 127 v8::Handle<v8::Function> func; |
| 128 EXPECT_TRUE(ConvertFromV8(isolate, val, &func)); |
| 129 v8::Handle<v8::Value> argv[] = {ConvertToV8(isolate, obj.get()), }; |
| 130 func->Call(v8::Undefined(isolate), 1, argv); |
| 131 EXPECT_FALSE(try_catch.HasCaught()); |
| 132 EXPECT_EQ("", try_catch.GetStackTrace()); |
| 133 |
| 134 EXPECT_EQ(191, obj->value()); |
| 135 } |
| 136 }; |
| 137 |
| 138 TEST_F(InterceptorTest, NamedInterceptor) { |
| 139 RunInterceptorTest( |
| 140 "(function (obj) {" |
| 141 " if (obj.value !== 42) throw 'FAIL';" |
| 142 " else obj.value = 191; })"); |
| 143 } |
| 144 |
| 145 TEST_F(InterceptorTest, NamedInterceptorCall) { |
| 146 RunInterceptorTest( |
| 147 "(function (obj) {" |
| 148 " if (obj.func(191) !== 42) throw 'FAIL';" |
| 149 " })"); |
| 150 } |
| 151 |
| 152 TEST_F(InterceptorTest, IndexedInterceptor) { |
| 153 RunInterceptorTest( |
| 154 "(function (obj) {" |
| 155 " if (obj[0] !== 42) throw 'FAIL';" |
| 156 " else obj[0] = 191; })"); |
| 157 } |
| 158 |
| 159 } // namespace gin |
OLD | NEW |