Reland: Plugin Placeholders: Refactor for platforms that don't support plugins

gin/wrappable_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/test/v8_test.h"
 #include "gin/try_catch.h"
 #include "gin/wrappable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gin {
 
-class BaseClass {
- public:
-  BaseClass() : value_(23) {}
-  virtual ~BaseClass() {}
-
- private:
-  int value_;
-
-  DISALLOW_COPY_AND_ASSIGN(BaseClass);
-};
-
-class MyObject : public BaseClass,
-                 public Wrappable<MyObject> {
+class MyObject : public Wrappable<MyObject> {
  public:
   static WrapperInfo kWrapperInfo;
 
   static gin::Handle<MyObject> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyObject());
   }
 
   int value() const { return value_; }
   void set_value(int value) { value_ = value; }
 
  protected:
   MyObject() : value_(0) {}
-  ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) override;
+  ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override {
+    return Wrappable<MyObject>::GetObjectTemplateBuilder(isolate)
+        .SetProperty("value", &MyObject::value, &MyObject::set_value);
+  }
   ~MyObject() override {}
 
  private:
   int value_;
 };
 
-class MyObjectSubclass : public MyObject {
+class SpacerClass {
  public:
+  SpacerClass() : value_(23) {}
+  virtual ~SpacerClass() {}
+
+ private:
+  int value_;
+
+  DISALLOW_COPY_AND_ASSIGN(SpacerClass);
+};
+
+class MyObjectSubclass : public SpacerClass, public MyObject {
+ public:
+  static WrapperInfo kWrapperInfo;
+
   static gin::Handle<MyObjectSubclass> Create(v8::Isolate* isolate) {
     return CreateHandle(isolate, new MyObjectSubclass());
   }
 
+  WrapperInfo* GetWrapperInfo() override {
+    return &MyObjectSubclass::kWrapperInfo;
+  }
+
   void SayHello(const std::string& name) {
     result = std::string("Hello, ") + name;
   }
 
   std::string result;
 
  private:
   ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override {
     return MyObject::GetObjectTemplateBuilder(isolate)
@@ skipping 31 matching lines @@
   void Call(int val1, int val2, int val3, const gin::Arguments& arguments) {
     if (arguments.IsConstructCall())
       arguments.ThrowTypeError("Cannot be called as constructor.");
     else
       result_ = val1;
   }
 
   int result_;
 };
 
-class MyObject2 : public Wrappable<MyObject2> {
- public:
-  static WrapperInfo kWrapperInfo;
-};
-
-class MyObjectBlink : public Wrappable<MyObjectBlink> {
- public:
-  static WrapperInfo kWrapperInfo;
-};
-
 WrapperInfo MyObject::kWrapperInfo = { kEmbedderNativeGin };
-ObjectTemplateBuilder MyObject::GetObjectTemplateBuilder(v8::Isolate* isolate) {
-  return Wrappable<MyObject>::GetObjectTemplateBuilder(isolate)
-      .SetProperty("value", &MyObject::value, &MyObject::set_value);
-}
-
+WrapperInfo MyObjectSubclass::kWrapperInfo = { kEmbedderNativeGin };
 WrapperInfo MyCallableObject::kWrapperInfo = { kEmbedderNativeGin };
-WrapperInfo MyObject2::kWrapperInfo = { kEmbedderNativeGin };
-WrapperInfo MyObjectBlink::kWrapperInfo = { kEmbedderNativeGin };
 
 typedef V8Test WrappableTest;
 
 TEST_F(WrappableTest, WrapAndUnwrap) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(isolate);
 
   Handle<MyObject> obj = MyObject::Create(isolate);
 
   v8::Local<v8::Value> wrapper = ConvertToV8(isolate, obj.get());
@@ skipping 11 matching lines @@
   // Something that isn't an object.
   v8::Local<v8::Value> thing = v8::Number::New(isolate, 42);
   MyObject* unwrapped = NULL;
   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
   EXPECT_FALSE(unwrapped);
 
   // An object that's not wrapping anything.
   thing = v8::Object::New(isolate);
   EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
   EXPECT_FALSE(unwrapped);
-
-  // An object that's wrapping a C++ object from Blink.
-  thing.Clear();
-  thing = ConvertToV8(isolate, new MyObjectBlink());
-  EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
-  EXPECT_FALSE(unwrapped);
-
-  // An object that's wrapping a C++ object of the wrong type.
-  thing.Clear();
-  thing = ConvertToV8(isolate, new MyObject2());
-  EXPECT_FALSE(ConvertFromV8(isolate, thing, &unwrapped));
-  EXPECT_FALSE(unwrapped);
 }
 
 TEST_F(WrappableTest, GetAndSetProperty) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(isolate);
 
   gin::Handle<MyObject> obj = MyObject::Create(isolate);
 
   obj->set_value(42);
   EXPECT_EQ(42, obj->value());
@@ skipping 18 matching lines @@
   EXPECT_FALSE(try_catch.HasCaught());
   EXPECT_EQ("", try_catch.GetStackTrace());
 
   EXPECT_EQ(191, obj->value());
 }
 
 TEST_F(WrappableTest, WrappableSubclass) {
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(isolate);
 
+  // Create a base class first to ensure that MyObjectSubclass instances can
+  // co-exist and be distinguished from the base class. This will fail if
+  // the subclass doesn't provide an overridden GetWrapperInfo().
+  gin::Handle<MyObject> base_class_instance = MyObject::Create(isolate);

[tommycli, 2015/06/02 22:01:23]

This test tickles the problem that caused those mystery crashes that perplexed
us all last week. (Subclass and base class using same WrapperInfo* and caching
incorrect object templates)

+  base_class_instance->set_value(42);
+
   gin::Handle<MyObjectSubclass> object(MyObjectSubclass::Create(isolate));
   v8::Local<v8::String> source = StringToV8(isolate,
                                              "(function(obj) {"
                                              "obj.sayHello('Lily');"
                                              "})");
+
+  v8::Local<v8::Value> wrapper = ConvertToV8(isolate, object.get());
+  EXPECT_FALSE(wrapper.IsEmpty());
+
+  // Ensure wrap and unwrap works for the subclass.
+  MyObjectSubclass* unwrapped = nullptr;
+  EXPECT_TRUE(ConvertFromV8(isolate, wrapper, &unwrapped));
+  EXPECT_EQ(object.get(), unwrapped);
+
+  // Ensure wrap and unwrap to the base class correctly adjusts the pointer.
+  // The static_cast is strictly speaking unnecessary, as MyObjectSubclass*
+  // pointers are transparently adjusted when compared to MyObject* pointers.
+  // MyObject* unwrapped_base = nullptr;
+  // EXPECT_TRUE(ConvertFromV8(isolate, wrapper, &unwrapped_base));
+  // EXPECT_EQ(static_cast<MyObject*>(object.get()), unwrapped_base);
+
+  // Ensure subclass-defined Javascript calls work.
   gin::TryCatch try_catch(isolate);
   v8::Local<v8::Script> script = v8::Script::Compile(source);
   v8::Local<v8::Value> val = script->Run();
   v8::Local<v8::Function> func;
   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
   v8::Local<v8::Value> argv[] = {
     ConvertToV8(isolate, object.get())
   };
   func->Call(v8::Undefined(isolate), 1, argv);
   EXPECT_FALSE(try_catch.HasCaught());
@@ skipping 39 matching lines @@
   v8::Local<v8::Function> func;
   EXPECT_TRUE(ConvertFromV8(isolate, val, &func));
   v8::Local<v8::Value> argv[] = {
     ConvertToV8(isolate, object.get())
   };
   func->Call(v8::Undefined(isolate), 1, argv);
   EXPECT_TRUE(try_catch.HasCaught());
 }
 
 }  // namespace gin