Clean up WebDOMEvent ownership of WebCore::Event.

Source/WebKit/chromium/src/WebDOMEvent.cpp

Index: Source/WebKit/chromium/src/WebDOMEvent.cpp
diff --git a/Source/WebKit/chromium/src/WebDOMEvent.cpp b/Source/WebKit/chromium/src/WebDOMEvent.cpp
index f72170cfa7eaba433ee127f0ee941985b5a965ec..5792796066f20d95216dba00356639c61ee14170 100644
--- a/Source/WebKit/chromium/src/WebDOMEvent.cpp
+++ b/Source/WebKit/chromium/src/WebDOMEvent.cpp
@@ -43,6 +43,11 @@ namespace WebKit {
 class WebDOMEventPrivate : public WebCore::Event {
 };
 
+WebDOMEvent::WebDOMEvent(const WebDOMEvent& event)
+    : m_private(event.m_private)
+{
+}

[abarth-chromium, 2013/05/22 17:16:11]

Is there some reason you don't want to use the same pattern we use for WebNode? 
There we put the copy constructor inline in the header and implement it using
"assign"

[dmichael (off chromium), 2013/05/22 17:37:33]

This copy constructor has to have WEBKIT_EXPORT, so can't be inlined. I could
use assign(), but it's usually considered best practice to use the initializer
list when you can (rather than allow m_private to be default initialized, then
assign to it). But that's pretty minor, so I'm happy to change  it if you want.

[abarth-chromium, 2013/05/22 18:06:23]

If you move the copy constructor inline in the header, then it won't need
WEBKIT_EXPORT because the caller will inline it.

I don't fully understand why we prefer to inline constructors and export assign
functions instead.  We could ask Darin, but I don't think there's any harm in
continuing the pattern.

[dmichael (off chromium), 2013/05/22 18:44:26]

Fine with me; consistency is valuable. Done.

+
 void WebDOMEvent::reset()
 {
     assign(0);
@@ -50,165 +55,159 @@ void WebDOMEvent::reset()
 
 void WebDOMEvent::assign(const WebDOMEvent& other)
 {
-    WebDOMEventPrivate* p = const_cast<WebDOMEventPrivate*>(other.m_private);
-    if (p)
-        p->ref();
-    assign(p);
+    m_private = other.m_private;
 }
 
-void WebDOMEvent::assign(WebDOMEventPrivate* p)
+void WebDOMEvent::assign(const WTF::PassRefPtr<WebDOMEventPrivate>& event)
 {
-    // p is already ref'd for us by the caller
-    if (m_private)
-        m_private->deref();
-    m_private = p;
+    m_private = event;
 }
 
 WebDOMEvent::WebDOMEvent(const WTF::PassRefPtr<WebCore::Event>& event)
-    : m_private(static_cast<WebDOMEventPrivate*>(event.leakRef()))
+    : m_private(event)
 {
 }
 
 WebDOMEvent::operator WTF::PassRefPtr<WebCore::Event>() const
 {
-    return static_cast<WebCore::Event*>(m_private);
+    return m_private.get();
 }
 
 WebString WebDOMEvent::type() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->type();
 }
 
 WebNode WebDOMEvent::target() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return WebNode(m_private->target()->toNode());
 }
 
 WebNode WebDOMEvent::currentTarget() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return WebNode(m_private->currentTarget()->toNode());
 }
 
 WebDOMEvent::PhaseType WebDOMEvent::eventPhase() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return static_cast<WebDOMEvent::PhaseType>(m_private->eventPhase());
 }
 
 bool WebDOMEvent::bubbles() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->bubbles();
 }
 
 bool WebDOMEvent::cancelable() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->cancelable();
 }
 
 bool WebDOMEvent::isUIEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->isUIEvent();
 }
 
 bool WebDOMEvent::isMouseEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->isMouseEvent();
 }
 
 bool WebDOMEvent::isKeyboardEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->isKeyboardEvent();
 }
 
 bool WebDOMEvent::isMutationEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(WebCore::eventNames().interfaceForMutationEvent);
 }
 
 bool WebDOMEvent::isTextEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForTextEvent);
 }
 
 bool WebDOMEvent::isCompositionEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForCompositionEvent);
 }
 
 bool WebDOMEvent::isDragEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->isDragEvent();
 }
 
 bool WebDOMEvent::isClipboardEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->isClipboardEvent();
 }
 
 bool WebDOMEvent::isMessageEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForMessageEvent);
 }
 
 bool WebDOMEvent::isWheelEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForWheelEvent);
 }
 
 bool WebDOMEvent::isBeforeTextInsertedEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->isBeforeTextInsertedEvent();
 }
 
 bool WebDOMEvent::isOverflowEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForOverflowEvent);
 }
 
 bool WebDOMEvent::isPageTransitionEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForPageTransitionEvent);
 }
 
 bool WebDOMEvent::isPopStateEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForPopStateEvent);
 }
 
 bool WebDOMEvent::isProgressEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForProgressEvent);
 }
 
 bool WebDOMEvent::isXMLHttpRequestProgressEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForXMLHttpRequestProgressEvent);
 }
 
 bool WebDOMEvent::isBeforeLoadEvent() const
 {
-    ASSERT(m_private);
+    ASSERT(m_private.get());
     return m_private->hasInterface(eventNames().interfaceForBeforeLoadEvent);
 }