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 MyObject2 : public Wrappable<MyObject2> {
  78  public:
  79   static WrapperInfo kWrapperInfo;
  80 };
  81
  82 class MyObjectBlink : public Wrappable<MyObjectBlink> {
  83  public:
  84   static WrapperInfo kWrapperInfo;
  85 };
  86
  87 WrapperInfo MyObject::kWrapperInfo = { kEmbedderNativeGin };
  88 ObjectTemplateBuilder MyObject::GetObjectTemplateBuilder(v8::Isolate* isolate) {
  89   return Wrappable<MyObject>::GetObjectTemplateBuilder(isolate)
  90       .SetProperty("value", &MyObject::value, &MyObject::set_value);
  91 }
  92
  93 WrapperInfo MyObject2::kWrapperInfo = { kEmbedderNativeGin };
  94 WrapperInfo MyObjectBlink::kWrapperInfo = { kEmbedderNativeGin };
  95
  96 typedef V8Test WrappableTest;
  97
  98 TEST_F(WrappableTest, WrapAndUnwrap) {
  99   v8::Isolate* isolate = instance_->isolate();
 100   v8::HandleScope handle_scope(isolate);
 101
 102   Handle<MyObject> obj = MyObject::Create(isolate);
 103
 104   v8::Handle<v8::Value> wrapper = ConvertToV8(isolate, obj.get());
 105   EXPECT_FALSE(wrapper.IsEmpty());
 106
 107   MyObject* unwrapped = NULL;
 108   EXPECT_TRUE(ConvertFromV8(isolate, wrapper, &unwrapped));
 109   EXPECT_EQ(obj.get(), unwrapped);
 110 }
 111
 112 TEST_F(WrappableTest, UnwrapFailures) {
 113   v8::Isolate* isolate = instance_->isolate();
 114   v8::HandleScope handle_scope(isolate);
 115
 116   // Something that isn't an object.
 117   v8::Handle<v8::Value> thing = v8::Number::New(isolate, 42);
 118   MyObject* unwrapped = NULL;
 119   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 120   EXPECT_FALSE(unwrapped);
 121
 122   // An object that's not wrapping anything.
 123   thing = v8::Object::New(isolate);
 124   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 125   EXPECT_FALSE(unwrapped);
 126
 127   // An object that's wrapping a C++ object from Blink.
 128   thing.Clear();
 129   thing = ConvertToV8(isolate, new MyObjectBlink());
 130   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 131   EXPECT_FALSE(unwrapped);
 132
 133   // An object that's wrapping a C++ object of the wrong type.
 134   thing.Clear();
 135   thing = ConvertToV8(isolate, new MyObject2());
 136   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
 137   EXPECT_FALSE(unwrapped);
 138 }
 139
 140 TEST_F(WrappableTest, GetAndSetProperty) {
 141   v8::Isolate* isolate = instance_->isolate();
 142   v8::HandleScope handle_scope(isolate);
 143
 144   gin::Handle<MyObject> obj = MyObject::Create(isolate);
 145
 146   obj->set_value(42);
 147   EXPECT_EQ(42, obj->value());
 148
 149   v8::Handle<v8::String> source = StringToV8(isolate,
 150       "(function (obj) {"
 151       "   if (obj.value !== 42) throw 'FAIL';"
 152       "   else obj.value = 191; })");
 153   EXPECT_FALSE(source.IsEmpty());
 154
 155   gin::TryCatch try_catch;
 156   v8::Handle<v8::Script> script = v8::Script::New(source);
 157   EXPECT_FALSE(script.IsEmpty());
 158   v8::Handle<v8::Value> val = script->Run();
 159   EXPECT_FALSE(val.IsEmpty());
 160   v8::Handle<v8::Function> func;
 161   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
 162   v8::Handle<v8::Value> argv[] = {
 163     ConvertToV8(isolate, obj.get()),
 164   };
 165   func->Call(v8::Undefined(isolate), 1, argv);
 166   EXPECT_FALSE(try_catch.HasCaught());
 167   EXPECT_EQ("", try_catch.GetStackTrace());
 168
 169   EXPECT_EQ(191, obj->value());
 170 }
 171
 172 TEST_F(WrappableTest, WrappableSubclass) {
 173   v8::Isolate* isolate = instance_->isolate();
 174   v8::HandleScope handle_scope(isolate);
 175
 176   gin::Handle<MyObjectSubclass> object(MyObjectSubclass::Create(isolate));
 177   v8::Handle<v8::String> source = StringToV8(isolate,
 178                                              "(function(obj) {"
 179                                              "obj.sayHello('Lily');"
 180                                              "})");
 181   gin::TryCatch try_catch;
 182   v8::Handle<v8::Script> script = v8::Script::New(source);
 183   v8::Handle<v8::Value> val = script->Run();
 184   v8::Handle<v8::Function> func;
 185   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
 186   v8::Handle<v8::Value> argv[] = {
 187     ConvertToV8(isolate, object.get())
 188   };
 189   func->Call(v8::Undefined(isolate), 1, argv);
 190   EXPECT_FALSE(try_catch.HasCaught());
 191   EXPECT_EQ("Hello, Lily", object->result);
 192 }
 193
 194 }  // namespace gin