Oilpan: Replace most of RefPtrs for Event objects with oilpan's transition types

Source/core/xml/XMLHttpRequestProgressEventThrottle.cpp

 /*
  * Copyright (C) 2010 Julien Chaffraix <jchaffraix@webkit.org>  All right reserved.
  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 57 matching lines @@
         startRepeating(minimumProgressEventDispatchingIntervalInSeconds, FROM_HERE);
         return;
     }
 
     // The timer is already active so minimumProgressEventDispatchingIntervalInSeconds is the least frequent event.
     m_lengthComputable = lengthComputable;
     m_loaded = loaded;
     m_total = total;
 }
 
-void XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent(PassRefPtr<Event> event, ProgressEventAction progressEventAction)
+void XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent(PassRefPtrWillBeRawPtr<Event> event, ProgressEventAction progressEventAction)
 {
     if (progressEventAction == FlushProgressEvent || progressEventAction == FlushDeferredProgressEvent) {
         if (!flushDeferredProgressEvent() && progressEventAction == FlushProgressEvent)
             deliverProgressEvent();
     }
 
     dispatchEvent(event);
 }
 
-void XMLHttpRequestProgressEventThrottle::dispatchEvent(PassRefPtr<Event> event)
+void XMLHttpRequestProgressEventThrottle::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ASSERT(event);
     if (m_deferEvents) {
         if (m_deferredEvents.size() > 1 && event->type() == EventTypeNames::readystatechange && event->type() == m_deferredEvents.last()->type()) {
             // Readystatechange events are state-less so avoid repeating two identical events in a row on resume.
             return;
         }
         m_deferredEvents.append(event);
     } else
         m_target->dispatchEvent(event);
@@ skipping 16 matching lines @@
         return true;
     }
     return false;
 }
 
 void XMLHttpRequestProgressEventThrottle::deliverProgressEvent()
 {
     if (!hasEventToDispatch())
         return;
 
-    PassRefPtr<Event> event = XMLHttpRequestProgressEvent::create(EventTypeNames::progress, m_lengthComputable, m_loaded, m_total);
+    RefPtrWillBeRawPtr<Event> event = XMLHttpRequestProgressEvent::create(EventTypeNames::progress, m_lengthComputable, m_loaded, m_total);
     m_loaded = 0;
     m_total = 0;
 
     // We stop the timer as this is called when no more events are supposed to occur.
     stop();
 
     dispatchEvent(event);
 }
 
 void XMLHttpRequestProgressEventThrottle::dispatchDeferredEvents(Timer<XMLHttpRequestProgressEventThrottle>* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_dispatchDeferredEventsTimer);
     ASSERT(m_deferEvents);
     m_deferEvents = false;
 
     // Take over the deferred events before dispatching them which can potentially add more.
-    Vector<RefPtr<Event> > deferredEvents;
+    WillBeHeapVector<RefPtrWillBeMember<Event> > deferredEvents;
     m_deferredEvents.swap(deferredEvents);
 
-    RefPtr<Event> deferredProgressEvent = m_deferredProgressEvent;
+    RefPtrWillBeRawPtr<Event> deferredProgressEvent = m_deferredProgressEvent;
     m_deferredProgressEvent = nullptr;
 
-    Vector<RefPtr<Event> >::const_iterator it = deferredEvents.begin();
-    const Vector<RefPtr<Event> >::const_iterator end = deferredEvents.end();
+    WillBeHeapVector<RefPtrWillBeMember<Event> >::const_iterator it = deferredEvents.begin();
+    const WillBeHeapVector<RefPtrWillBeMember<Event> >::const_iterator end = deferredEvents.end();
     for (; it != end; ++it)
         dispatchEvent(*it);
 
     // The progress event will be in the m_deferredEvents vector if the load was finished while suspended.
     // If not, just send the most up-to-date progress on resume.
     if (deferredProgressEvent)
         dispatchEvent(deferredProgressEvent);
 }
 
 void XMLHttpRequestProgressEventThrottle::fired()
@@ skipping 49 matching lines @@
         return;
     }
 
     // Do not dispatch events inline here, since ExecutionContext is iterating over
     // the list of active DOM objects to resume them, and any activated JS event-handler
     // could insert new active DOM objects to the list.
     // m_deferEvents is kept true until all deferred events have been dispatched.
     m_dispatchDeferredEventsTimer.startOneShot(0, FROM_HERE);
 }
 
+void XMLHttpRequestProgressEventThrottle::trace(Visitor* visitor)
+{
+    visitor->trace(m_deferredProgressEvent);
+    visitor->trace(m_deferredEvents);
+}
+
 } // namespace WebCore