bindings: Retires ScriptWrappableBase mostly.

Source/bindings/core/v8/ScriptWrappable.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ScriptWrappable_h
 #define ScriptWrappable_h
 
 #include "bindings/core/v8/WrapperTypeInfo.h"
 #include "platform/heap/Handle.h"
+#include "wtf/Noncopyable.h"
 #include <v8.h>
 
 namespace blink {
 
 /**
  * The base class of all wrappable objects.
  *
  * This class provides the internal pointer to be stored in the wrapper objects,
  * and its conversions from / to the DOM instances.
  *
  * Note that this class must not have vtbl (any virtual function) or any member
  * variable which increase the size of instances. Some of the classes sensitive
  * to the size inherit from this class. So this class must be zero size.
  */
 #if COMPILER(MSVC)

[haraken, 2014/11/14 08:21:20]

Can we remove this comment now, since ScriptWrappableBase is used only by
NPObject?

Also let's mention that ScriptWrappable is just for NPObjects and thus
deprecated.

[Yuki, 2014/11/14 11:25:09]

ScriptWrappableBase is still used as the internal pointers everywhere, so let me
keep the comment as is for now.

However, it seems I can retire ScriptWrappableBase completely making NPObject
not use ScriptWrappableBase.

Let me investigate what I can do here in a separate CL, and allow me to commit
this CL first so it's easy to move on.

 // VC++ 2013 doesn't support EBCO (Empty Base Class Optimization). It causes
 // that not always pointers to an empty base class are aligned to 4 byte
 // alignment. For example,
 //
 //   class EmptyBase1 {};
 //   class EmptyBase2 {};
 //   class Derived : public EmptyBase1, public EmptyBase2 {};
 //   Derived d;
 //   // &d                           == 0x1000
 //   // static_cast<EmptyBase1*>(&d) == 0x1000
 //   // static_cast<EmptyBase2*>(&d) == 0x1001  // Not 4 byte alignment!
 //
 // This doesn't happen with other compilers which support EBCO. All the
 // addresses in the above example will be 0x1000 with EBCO supported.
 //
 // Since v8::Object::SetAlignedPointerInInternalField requires the pointers to
 // be aligned, we need a hack to specify at least 4 byte alignment to MSVC.
 __declspec(align(4))
 #endif
 class ScriptWrappableBase {
+    WTF_MAKE_NONCOPYABLE(ScriptWrappableBase);
+    friend class ScriptWrappable;
 public:
     template<typename T>
     T* toImpl()
     {
         // Check if T* is castable to ScriptWrappableBase*, which means T
         // doesn't have two or more ScriptWrappableBase as superclasses.
         // If T has two ScriptWrappableBase as superclasses, conversions
         // from T* to ScriptWrappableBase* are ambiguous.
         ASSERT(static_cast<ScriptWrappableBase*>(static_cast<T*>(this)));
         // The internal pointers must be aligned to at least 4 byte alignment.
         ASSERT((reinterpret_cast<intptr_t>(this) & 0x3) == 0);
         return static_cast<T*>(this);
     }
     ScriptWrappableBase* toScriptWrappableBase()
     {
         ASSERT(this);
         // The internal pointers must be aligned to at least 4 byte alignment.
         ASSERT((reinterpret_cast<intptr_t>(this) & 0x3) == 0);
         return this;
     }
 
-    // Creates and returns a new wrapper object.
-    // Do not call this method for a ScriptWrappable or its subclasses. This
-    // non-virtual version of "wrap" is meant only for non-ScriptWrappable
-    // objects. This wrap takes an extra third argument of type WrapperTypeInfo
-    // because ScriptWrappableBase doesn't have wrapperTypeInfo() method unlike
-    // ScriptWrappable.
-    v8::Handle<v8::Object> wrap(v8::Handle<v8::Object> creationContext, v8::Isolate*, const WrapperTypeInfo*);
-
     void assertWrapperSanity(v8::Local<v8::Object> object)
     {
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(object.IsEmpty()
             || object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == toScriptWrappableBase());
     }
+
+private:
+    // Do not allow DOM classes to inherit directly from ScriptWrappableBase.
+    // DOM classes must inherit from ScriptWrappable instead.
+    ScriptWrappableBase() { }
 };
 
 /**
  * ScriptWrappable wraps a V8 object and its WrapperTypeInfo.
  *
  * ScriptWrappable acts much like a v8::Persistent<> in that it keeps a
  * V8 object alive.
  *
  *  The state transitions are:
  *  - new: an empty ScriptWrappable.
@@ skipping 114 matching lines @@
         releaseObject(data.GetValue());
     }
 
     v8::Persistent<v8::Object> m_wrapper;
 };
 
 // Defines 'wrapperTypeInfo' virtual method which returns the WrapperTypeInfo of
 // the instance. Also declares a static member of type WrapperTypeInfo, of which
 // the definition is given by the IDL code generator.
 //
-// Every DOM Class T must meet either of the following conditions:
-// - T.idl inherits from [NotScriptWrappable].
-// - T inherits from ScriptWrappable and has DEFINE_WRAPPERTYPEINFO().
-//
-// If a DOM class T does not inherit from ScriptWrappable, you have to write
-// [NotScriptWrappable] in the IDL file as an extended attribute in order to let
-// IDL code generator know that T does not inherit from ScriptWrappable. Note
-// that [NotScriptWrappable] is inheritable.
-//
 // All the derived classes of ScriptWrappable, regardless of directly or
-// indirectly, must write this macro in the class definition.
+// indirectly, must write this macro in the class definition as long as the
+// class has a corresponding .idl file.
 #define DEFINE_WRAPPERTYPEINFO() \
 public: \
     virtual const WrapperTypeInfo* wrapperTypeInfo() const override \
     { \
         return &s_wrapperTypeInfo; \
     } \
 private: \
     static const WrapperTypeInfo& s_wrapperTypeInfo
 
 // Defines 'wrapperTypeInfo' virtual method, which should never be called.
@@ skipping 11 matching lines @@
     { \
         ASSERT_NOT_REACHED(); \
         return 0; \
     } \
 private: \
     typedef void end_of_define_wrappertypeinfo_not_reached_t
 
 } // namespace blink
 
 #endif // ScriptWrappable_h