Inherit EventTarget interface instead of duplicating its code

Source/core/css/FontLoader.h

 /*
  * Copyright (C) 2013 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:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 29 matching lines @@
 
 class CachedFont;
 class CSSFontFaceRule;
 class CSSFontFaceSource;
 class Dictionary;
 class Document;
 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)
     {
         return adoptRef<FontLoader>(new FontLoader(document));
     }
     virtual ~FontLoader();
 
     DEFINE_ATTRIBUTE_EVENT_LISTENER(loading);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(loadingdone);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(loadstart);
@@ skipping 54 matching lines @@
     Vector<RefPtr<VoidCallback> > m_pendingCallbacks;
     Vector<RefPtr<VoidCallback> > m_fontsReadyCallbacks;
     RefPtr<Event> m_pendingDoneEvent;
     Timer<FontLoader> m_timer;
     FontLoadHistogram m_histogram;
 };
 
 } // namespace WebCore
 
 #endif // FontLoader_h