bindings: Retires ScriptWrappable::init, etc.

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 18 matching lines @@
  */
 
 #ifndef ScriptWrappable_h
 #define ScriptWrappable_h
 
 #include "bindings/core/v8/WrapperTypeInfo.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/heap/Handle.h"
 #include <v8.h>
 
-// Helper to call webCoreInitializeScriptWrappableForInterface in the global namespace.
-template <class C> inline void initializeScriptWrappableHelper(C* object)
-{
-    void webCoreInitializeScriptWrappableForInterface(C*);
-    webCoreInitializeScriptWrappableForInterface(object);
-}
-
 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
@@ skipping 44 matching lines @@
     {
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(object.IsEmpty()
             || object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == toScriptWrappableBase());
     }
 };
 
 /**
  * ScriptWrappable wraps a V8 object and its WrapperTypeInfo.
  *
  * ScriptWrappable acts much like a v8::Persistent<> in that it keeps a
- * V8 object alive. Under the hood, however, it keeps either a TypeInfo
- * object or an actual v8 persistent (or is empty).
- *
- * The physical state space of ScriptWrappable is:
- * - uintptr_t m_wrapperOrTypeInfo;
- *   - if 0: the ScriptWrappable is uninitialized/empty.
- *   - if even: a pointer to blink::TypeInfo
- *   - if odd: a pointer to v8::Persistent<v8::Object> + 1.
- *
- * In other words, one integer represents one of two object pointers,
- * depending on its least signficiant bit, plus an uninitialized state.
- * This class is meant to mask the logistics behind this.
- *
- * typeInfo() and newLocalWrapper will return appropriate values (possibly
- * 0/empty) in all physical states.
+ * V8 object alive.
  *
  *  The state transitions are:
- *  - new: an empty and invalid ScriptWrappable.
- *  - init (to be called by all subclasses in their constructor):
- *        needs to call setTypeInfo
- *  - setTypeInfo: install a WrapperTypeInfo
+ *  - new: an empty ScriptWrappable.
  *  - setWrapper: install a v8::Persistent (or empty)
  *  - disposeWrapper (via setWeakCallback, triggered by V8 garbage collecter):
- *        remove v8::Persistent and install a TypeInfo of the previous value.
+ *        remove v8::Persistent and become empty.
  */
 class ScriptWrappable : public ScriptWrappableBase {
 public:
-    ScriptWrappable() : m_wrapperOrTypeInfo(0) { }
-
-    // Wrappables need to be initialized with their most derrived type for which
-    // bindings exist, in much the same way that certain other types need to be
-    // adopted and so forth. The overloaded initializeScriptWrappableForInterface()
-    // functions are implemented by the generated V8 bindings code. Declaring the
-    // extern function in the template avoids making a centralized header of all
-    // the bindings in the universe. C++11's extern template feature may provide
-    // a cleaner solution someday.
-    template <class C> static void init(C* object)
-    {
-        initializeScriptWrappableHelper(object);
-    }
+    ScriptWrappable() : m_wrapper(0) { }
 
     // Returns the WrapperTypeInfo of the instance.
     //
     // This method must be overridden by DEFINE_WRAPPERTYPEINFO macro.
     virtual const WrapperTypeInfo* wrapperTypeInfo() const = 0;
 
     // Creates and returns a new wrapper object.
     virtual v8::Handle<v8::Object> wrap(v8::Handle<v8::Object> creationContext, v8::Isolate*);
 
     void setWrapper(v8::Handle<v8::Object> wrapper, v8::Isolate* isolate, const WrapperTypeInfo* wrapperTypeInfo)
     {
         ASSERT(!containsWrapper());
         if (!*wrapper) {
-            m_wrapperOrTypeInfo = 0;
+            m_wrapper = 0;
             return;
         }
         v8::Persistent<v8::Object> persistent(isolate, wrapper);
         wrapperTypeInfo->configureWrapper(&persistent);
         persistent.SetWeak(this, &setWeakCallback);
-        m_wrapperOrTypeInfo = reinterpret_cast<uintptr_t>(persistent.ClearAndLeak()) | 1;
+        m_wrapper = persistent.ClearAndLeak();
         ASSERT(containsWrapper());
     }
 
     v8::Local<v8::Object> newLocalWrapper(v8::Isolate* isolate) const
     {
         v8::Persistent<v8::Object> persistent;
         getPersistent(&persistent);
         return v8::Local<v8::Object>::New(isolate, persistent);
     }
 
-    const WrapperTypeInfo* typeInfo()
-    {
-        if (containsTypeInfo())
-            return reinterpret_cast<const WrapperTypeInfo*>(m_wrapperOrTypeInfo);
-
-        if (containsWrapper()) {
-            v8::Persistent<v8::Object> persistent;
-            getPersistent(&persistent);
-            return toWrapperTypeInfo(persistent);
-        }
-
-        return 0;
-    }
-
-    void setTypeInfo(const WrapperTypeInfo* typeInfo)
-    {
-        m_wrapperOrTypeInfo = reinterpret_cast<uintptr_t>(typeInfo);
-        ASSERT(containsTypeInfo());
-    }
-
     bool isEqualTo(const v8::Local<v8::Object>& other) const
     {
         v8::Persistent<v8::Object> persistent;
         getPersistent(&persistent);
         return persistent == other;
     }
 
     static bool wrapperCanBeStoredInObject(const void*) { return false; }
     static bool wrapperCanBeStoredInObject(const ScriptWrappable*) { return true; }
 
@@ skipping 14 matching lines @@
         getPersistent(&persistent);
         returnValue.Set(persistent);
         return containsWrapper();
     }
 
     void markAsDependentGroup(ScriptWrappable* groupRoot, v8::Isolate* isolate)
     {
         ASSERT(containsWrapper());
         ASSERT(groupRoot && groupRoot->containsWrapper());
 
-        v8::UniqueId groupId(groupRoot->m_wrapperOrTypeInfo);
+        v8::UniqueId groupId(reinterpret_cast<intptr_t>(groupRoot->m_wrapper));
         v8::Persistent<v8::Object> wrapper;
         getPersistent(&wrapper);
         wrapper.MarkPartiallyDependent();
         isolate->SetObjectGroupId(v8::Persistent<v8::Value>::Cast(wrapper), groupId);
     }
 
     void setReference(const v8::Persistent<v8::Object>& parent, v8::Isolate* isolate)
     {
         v8::Persistent<v8::Object> persistent;
         getPersistent(&persistent);
@@ skipping 12 matching lines @@
     static void assertWrapperSanity(void* object, T* objectAsT)
     {
         ASSERT_NOT_REACHED();
     }
 
     template<typename V8T, typename T>
     static void assertWrapperSanity(ScriptWrappable* object, T* objectAsT)
     {
         ASSERT(object);
         ASSERT(objectAsT);
-        v8::Object* value = object->getRawValue();
+        v8::Object* value = object->m_wrapper;
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(value == 0
             || value->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex) == V8T::toScriptWrappableBase(objectAsT));
     }
 
     using ScriptWrappableBase::assertWrapperSanity;
 
-    inline bool containsWrapper() const { return (m_wrapperOrTypeInfo & 1); }
-    inline bool containsTypeInfo() const { return m_wrapperOrTypeInfo && !(m_wrapperOrTypeInfo & 1); }
+    bool containsWrapper() const { return m_wrapper != 0; }

[haraken, 2014/09/05 16:46:16]

return !!m_wrapper;

Blink's coding style doesn't prefer comparison with 0.

[Yuki, 2014/09/06 09:40:06]

Done.

 
 #if !ENABLE(OILPAN)
 protected:
     virtual ~ScriptWrappable()
     {
         // We must not get deleted as long as we contain a wrapper. If this happens, we screwed up ref
         // counting somewhere. Crash here instead of crashing during a later gc cycle.
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(!containsWrapper());
-        ASSERT(m_wrapperOrTypeInfo); // Assert initialization via init() even if not subsequently wrapped.
-        m_wrapperOrTypeInfo = 0; // Break UAF attempts to wrap.
+        m_wrapper = 0; // Break UAF attempts to wrap.
     }
 #endif
     // With Oilpan we don't need a ScriptWrappable destructor.
     //
     // - 'RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(!containsWrapper())' is not needed
     // because Oilpan is not using reference counting at all. If containsWrapper() is true,
     // it means that ScriptWrappable still has a wrapper. In this case, the destructor
     // must not be called since the wrapper has a persistent handle back to this ScriptWrappable object.
     // Assuming that Oilpan's GC is correct (If we cannot assume this, a lot of more things are
     // already broken), we must not hit the RELEASE_ASSERT.
     //
-    // - 'm_wrapperOrTypeInfo = 0' is not needed because Oilpan's GC zeroes out memory when
+    // - 'm_wrapper = 0' is not needed because Oilpan's GC zeroes out memory when
     // the memory is collected and added to a free list.
 
 private:
     void getPersistent(v8::Persistent<v8::Object>* persistent) const
     {
         ASSERT(persistent);
 
         // Horrible and super unsafe: Cast the Persistent to an Object*, so
         // that we can inject the wrapped value. This only works because
         // we previously 'stole' the object pointer from a Persistent in
         // the setWrapper() method.
-        *reinterpret_cast<v8::Object**>(persistent) = getRawValue();
+        *reinterpret_cast<v8::Object**>(persistent) = m_wrapper;
     }
 
-    inline v8::Object* getRawValue() const
-    {
-        v8::Object* object = containsWrapper() ? reinterpret_cast<v8::Object*>(m_wrapperOrTypeInfo & ~1) : 0;
-        return object;
-    }
-
-    inline void disposeWrapper(v8::Local<v8::Object> wrapper)
+    void disposeWrapper(v8::Local<v8::Object> wrapper)
     {
         ASSERT(containsWrapper());
 
         v8::Persistent<v8::Object> persistent;
         getPersistent(&persistent);
 
         ASSERT(wrapper == persistent);
         persistent.Reset();
-        setTypeInfo(toWrapperTypeInfo(wrapper));
+        m_wrapper = 0;
     }
 
-    // If zero, then this contains nothing, otherwise:
-    //   If the bottom bit it set, then this contains a pointer to a wrapper object in the remainging bits.
-    //   If the bottom bit is clear, then this contains a pointer to the wrapper type info in the remaining bits.
-    uintptr_t m_wrapperOrTypeInfo;
-
     static void setWeakCallback(const v8::WeakCallbackData<v8::Object, ScriptWrappable>& data)
     {
         v8::Persistent<v8::Object> persistent;
         data.GetParameter()->getPersistent(&persistent);
         ASSERT(persistent == data.GetValue());
         data.GetParameter()->disposeWrapper(data.GetValue());
 
         // FIXME: I noticed that 50%~ of minor GC cycle times can be consumed
         // inside data.GetParameter()->deref(), which causes Node destructions. We should
         // make Node destructions incremental.
         releaseObject(data.GetValue());
     }
+
+    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.
 #define DEFINE_WRAPPERTYPEINFO() \
 public: \
     virtual const WrapperTypeInfo* wrapperTypeInfo() const OVERRIDE \
     { \
         return &s_wrapperTypeInfo; \
     } \
 private: \
     static const WrapperTypeInfo& s_wrapperTypeInfo
 
 } // namespace blink
 
 #endif // ScriptWrappable_h