Inherit EventTarget interface instead of duplicating its code

Source/core/css/FontLoader.h

Index: Source/core/css/FontLoader.h
diff --git a/Source/core/css/FontLoader.h b/Source/core/css/FontLoader.h
index b8e39d80ac41be59a310822abc908320ec9830fd..11de3de3030b5248defbfe1201df296ee8bbd181 100644
--- a/Source/core/css/FontLoader.h
+++ b/Source/core/css/FontLoader.h
@@ -47,7 +47,7 @@ class Event;
 class Font;
 class ScriptExecutionContext;
 
-class FontLoader : public RefCounted<FontLoader>, public ActiveDOMObject, public EventTarget {
+class FontLoader : public EventTarget, public RefCounted<FontLoader>, public ActiveDOMObject {

[do-not-use, 2013/07/05 14:44:04]

FYI, I'm changing the other because we hit the following assertion in the
bindings otherwise:
STDERR: ASSERTION FAILED:
static_cast<void*>(static_cast<EventTarget*>(impl.get())) ==
static_cast<void*>(impl.get())
STDERR: gen/webkit/bindings/V8MediaStream.cpp(470) : static
v8::Handle<v8::Object>
WebCore::V8MediaStream::createWrapper(WTF::PassRefPtr<WebCore::MediaStream>,
v8::Handle<v8::Object>, v8::Isolate*)

[do-not-use, 2013/07/05 14:47:44]

changing the *order* (not *other*).

[haraken, 2013/07/06 00:29:56]

In your CL, the order swap doesn't matter.

The order sometimes matters for an object size. For example, in case of Node:

class TreeShared {
  uint32_t m_count;
};

class Node : public TreeShared<Node>, public EventTarget {
  uint32_t m_flags;
  Node* m_firstChild;
  ...;
};

By putting TreeShared<Node> at the first inheritance, we can pack the m_count
(32 bit) and m_flags (32 bit) into one 64 bit integer.

For objects where size matters, I think we already have ASSERTs about the object
size to guarantee that we don't regress the size. So I think your CL would be OK
as long as you don't hit any ASSERT.

[haraken, 2013/07/06 01:21:01]

On the other hand, we might not want to change the inheritance order just for
the ASSERT. In other words, we might not want to introduce some dependency about
the inheritance order.

Wouldn't it be possible to check:

  static_cast<void*>(static_cast<EventTarget*>(impl.get())) ==
static_cast<void*>(impl.get())

without changing the inheritance order? (Sorry I have no idea since I'm not a
C++ expert:-)

[dominicc (has gone to gerrit), 2013/07/07 00:14:28]

The issue is basically this one:
<http://stackoverflow.com/questions/3327631/casting-with-multiple-inheritance>

I think we should learn a trick from JSC here. Basically in V8 it would look
like this:

in V8EventTarget.h, in V8EventTarget (or any base type):

static inline void* toWrappedType(EventTarget* impl)
{
    return impl;
}

in V8Element.h, in V8Element (or any derived type):

static inline void* toWrappedType(Element* impl)
{
    return V8Node::toWrappedType(impl);
}

And similarly the other way:

static inline EventTarget* fromWrappedType(void* impl)
{
    return static_cast<EventTarget*>(impl);
}

static inline Element* fromWrappedType(void* impl)
{
    return static_cast<Element*>(V8Node::fromWrappedType(impl));
}

Then minimize static casting in the bindings. Most uses can be replaced with
these. For example the generated toNative uses fromWrappedType.

IIRC there might be places where the bindings store objects at different pointer
types. If they could be brought into a similar scheme that would be good.

 public:
     static PassRefPtr<FontLoader> create(Document* document)
     {