gin/wrappable_unittest.cc

   1 // Copyright 2013 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/object_template_builder.h"
   9 #include "gin/per_isolate_data.h"
  10 #include "gin/public/isolate_holder.h"
  11 #include "gin/test/v8_test.h"
  12 #include "gin/try_catch.h"
  13 #include "gin/wrappable.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace gin {
  17
  18 class BaseClass {
  19  public:
  20   BaseClass() : value_(23) {}
  21   virtual ~BaseClass() {}
  22
  23  private:
  24   int value_;
  25
  26   DISALLOW_COPY_AND_ASSIGN(BaseClass);
  27 };
  28
  29 class MyObject : public BaseClass,
  30                  public Wrappable<MyObject> {
  31  public:
  32   static WrapperInfo kWrapperInfo;
  33
  34   static gin::Handle<MyObject> Create(v8::Isolate* isolate) {
  35     return CreateHandle(isolate, new MyObject());
  36   }
  37
  38   int value() const { return value_; }
  39   void set_value(int value) { value_ = value; }
  40
  41  protected:
  42   MyObject() : value_(0) {}
  43   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(
  44       v8::Isolate* isolate) override;
  45   virtual ~MyObject() {}
  46
  47  private:
  48   int value_;
  49 };
  50
  51 class MyObjectSubclass : public MyObject {
  52  public:
  53   static gin::Handle<MyObjectSubclass> Create(v8::Isolate* isolate) {
  54     return CreateHandle(isolate, new MyObjectSubclass());
  55   }
  56
  57   void SayHello(const std::string& name) {
  58     result = std::string("Hello, ") + name;
  59   }
  60
  61   std::string result;
  62
  63  private:
  64   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(
  65       v8::Isolate* isolate) override {
  66     return MyObject::GetObjectTemplateBuilder(isolate)
  67         .SetMethod("sayHello", &MyObjectSubclass::SayHello);
  68   }
  69
  70   MyObjectSubclass() {
  71   }
  72
  73   virtual ~MyObjectSubclass() {
  74   }
  75 };
  76
  77 class MyCallableObject : public Wrappable<MyCallableObject> {
  78  public:
  79   static WrapperInfo kWrapperInfo;
  80
  81   static gin::Handle<MyCallableObject> Create(v8::Isolate* isolate) {
  82     return CreateHandle(isolate, new MyCallableObject());
  83   }
  84
  85   int result() { return result_; }
  86
  87  private:
  88   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(
  89       v8::Isolate* isolate) override {
  90     return Wrappable<MyCallableObject>::GetObjectTemplateBuilder(isolate)
  91         .SetCallAsFunctionHandler(&MyCallableObject::Call);
  92   }
  93
  94   MyCallableObject() : result_(0) {
  95   }
  96
  97   virtual ~MyCallableObject() {
  98   }
  99
 100   void Call(int val, const gin::Arguments& arguments) {
 101     if (arguments.IsConstructCall())
 102       arguments.ThrowTypeError("Cannot be called as constructor.");
 103     else
 104       result_ = val;
 105   }
 106
 107   int result_;
 108 };
 109
 110 class MyObject2 : public Wrappable<MyObject2> {
 111  public:
 112   static WrapperInfo kWrapperInfo;
 113 };
 114
 115 class MyObjectBlink : public Wrappable<MyObjectBlink> {
 116  public:
 117   static WrapperInfo kWrapperInfo;
 118 };
 119
 120 WrapperInfo MyObject::kWrapperInfo = { kEmbedderNativeGin };
 121 ObjectTemplateBuilder MyObject::GetObjectTemplateBuilder(v8::Isolate* isolate) {
 122   return Wrappable<MyObject>::GetObjectTemplateBuilder(isolate)
 123       .SetProperty("value", &MyObject::value, &MyObject::set_value);
 124 }
 125
 126 WrapperInfo MyCallableObject::kWrapperInfo = { kEmbedderNativeGin };
 127 WrapperInfo MyObject2::kWrapperInfo = { kEmbedderNativeGin };
 128 WrapperInfo MyObjectBlink::kWrapperInfo = { kEmbedderNativeGin };
 129
 130 typedef V8Test WrappableTest;
 131
 132 TEST_F(WrappableTest, WrapAndUnwrap) {
 133   v8::Isolate* isolate = instance_->isolate();
 134   v8::HandleScope handle_scope(isolate);
 135
 136   Handle<MyObject> obj = MyObject::Create(isolate);
 137
 138   v8::Handle<v8::Value> wrapper = ConvertToV8(isolate, obj.get());
 139   EXPECT_FALSE(wrapper.IsEmpty());
 140
 141   MyObject* unwrapped = NULL;
 142   EXPECT_TRUE(ConvertFromV8(isolate, wrapper, &unwrapped));
 143   EXPECT_EQ(obj.get(), unwrapped);
 144 }
 145
 146 TEST_F(WrappableTest, UnwrapFailures) {
 147   v8::Isolate* isolate = instance_->isolate();
 148   v8::HandleScope handle_scope(isolate);
 149
 150   // Something that isn't an object.
 151   v8::Handle<v8::Value> thing = v8::Number::New(isolate, 42);
 152   MyObject* unwrapped = NULL;
 153   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 154   EXPECT_FALSE(unwrapped);
 155
 156   // An object that's not wrapping anything.
 157   thing = v8::Object::New(isolate);
 158   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 159   EXPECT_FALSE(unwrapped);
 160
 161   // An object that's wrapping a C++ object from Blink.
 162   thing.Clear();
 163   thing = ConvertToV8(isolate, new MyObjectBlink());
 164   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 165   EXPECT_FALSE(unwrapped);
 166
 167   // An object that's wrapping a C++ object of the wrong type.
 168   thing.Clear();
 169   thing = ConvertToV8(isolate, new MyObject2());
 170   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 171   EXPECT_FALSE(unwrapped);
 172 }
 173
 174 TEST_F(WrappableTest, GetAndSetProperty) {
 175   v8::Isolate* isolate = instance_->isolate();
 176   v8::HandleScope handle_scope(isolate);
 177
 178   gin::Handle<MyObject> obj = MyObject::Create(isolate);
 179
 180   obj->set_value(42);
 181   EXPECT_EQ(42, obj->value());
 182
 183   v8::Handle<v8::String> source = StringToV8(isolate,
 184       "(function (obj) {"
 185       "   if (obj.value !== 42) throw 'FAIL';"
 186       "   else obj.value = 191; })");
 187   EXPECT_FALSE(source.IsEmpty());
 188
 189   gin::TryCatch try_catch;
 190   v8::Handle<v8::Script> script = v8::Script::Compile(source);
 191   EXPECT_FALSE(script.IsEmpty());
 192   v8::Handle<v8::Value> val = script->Run();
 193   EXPECT_FALSE(val.IsEmpty());
 194   v8::Handle<v8::Function> func;
 195   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
 196   v8::Handle<v8::Value> argv[] = {
 197     ConvertToV8(isolate, obj.get()),
 198   };
 199   func->Call(v8::Undefined(isolate), 1, argv);
 200   EXPECT_FALSE(try_catch.HasCaught());
 201   EXPECT_EQ("", try_catch.GetStackTrace());
 202
 203   EXPECT_EQ(191, obj->value());
 204 }
 205
 206 TEST_F(WrappableTest, WrappableSubclass) {
 207   v8::Isolate* isolate = instance_->isolate();
 208   v8::HandleScope handle_scope(isolate);
 209
 210   gin::Handle<MyObjectSubclass> object(MyObjectSubclass::Create(isolate));
 211   v8::Handle<v8::String> source = StringToV8(isolate,
 212                                              "(function(obj) {"
 213                                              "obj.sayHello('Lily');"
 214                                              "})");
 215   gin::TryCatch try_catch;
 216   v8::Handle<v8::Script> script = v8::Script::Compile(source);
 217   v8::Handle<v8::Value> val = script->Run();
 218   v8::Handle<v8::Function> func;
 219   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
 220   v8::Handle<v8::Value> argv[] = {
 221     ConvertToV8(isolate, object.get())
 222   };
 223   func->Call(v8::Undefined(isolate), 1, argv);
 224   EXPECT_FALSE(try_catch.HasCaught());
 225   EXPECT_EQ("Hello, Lily", object->result);
 226 }
 227
 228 TEST_F(WrappableTest, CallAsFunction) {
 229   v8::Isolate* isolate = instance_->isolate();
 230   v8::HandleScope handle_scope(isolate);
 231
 232   gin::Handle<MyCallableObject> object(MyCallableObject::Create(isolate));
 233   EXPECT_EQ(0, object->result());
 234   v8::Handle<v8::String> source = StringToV8(isolate,
 235                                              "(function(obj) {"
 236                                              "obj(42);"
 237                                              "})");
 238   gin::TryCatch try_catch;
 239   v8::Handle<v8::Script> script = v8::Script::Compile(source);
 240   v8::Handle<v8::Value> val = script->Run();
 241   v8::Handle<v8::Function> func;
 242   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
 243   v8::Handle<v8::Value> argv[] = {
 244     ConvertToV8(isolate, object.get())
 245   };
 246   func->Call(v8::Undefined(isolate), 1, argv);
 247   EXPECT_FALSE(try_catch.HasCaught());
 248   EXPECT_EQ(42, object->result());
 249 }
 250
 251 TEST_F(WrappableTest, CallAsConstructor) {
 252   v8::Isolate* isolate = instance_->isolate();
 253   v8::HandleScope handle_scope(isolate);
 254
 255   gin::Handle<MyCallableObject> object(MyCallableObject::Create(isolate));
 256   EXPECT_EQ(0, object->result());
 257   v8::Handle<v8::String> source = StringToV8(isolate,
 258                                              "(function(obj) {"
 259                                              "new obj(42);"
 260                                              "})");
 261   gin::TryCatch try_catch;
 262   v8::Handle<v8::Script> script = v8::Script::Compile(source);
 263   v8::Handle<v8::Value> val = script->Run();
 264   v8::Handle<v8::Function> func;
 265   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
 266   v8::Handle<v8::Value> argv[] = {
 267     ConvertToV8(isolate, object.get())
 268   };
 269   func->Call(v8::Undefined(isolate), 1, argv);
 270   EXPECT_TRUE(try_catch.HasCaught());
 271 }
 272
 273 }  // namespace gin