Oilpan: move AsyncMethodRunner to the heap.

third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 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
@@ skipping 329 matching lines @@
         return 0;
 
     return peerConnection;
 }
 
 RTCPeerConnection::RTCPeerConnection(ExecutionContext* context, RTCConfiguration* configuration, WebMediaConstraints constraints, ExceptionState& exceptionState)
     : ActiveDOMObject(context)
     , m_signalingState(SignalingStateStable)
     , m_iceGatheringState(ICEGatheringStateNew)
     , m_iceConnectionState(ICEConnectionStateNew)
-    , m_dispatchScheduledEventRunner(this, &RTCPeerConnection::dispatchScheduledEvent)
+    , m_dispatchScheduledEventRunner(AsyncMethodRunner<RTCPeerConnection>::create(this, &RTCPeerConnection::dispatchScheduledEvent))
     , m_stopped(false)
     , m_closed(false)
 {
     Document* document = toDocument(executionContext());
 
     // If we fail, set |m_closed| and |m_stopped| to true, to avoid hitting the assert in the destructor.
 
     if (!document->frame()) {
         m_closed = true;
         m_stopped = true;
@@ skipping 571 matching lines @@
     return EventTargetNames::RTCPeerConnection;
 }
 
 ExecutionContext* RTCPeerConnection::executionContext() const
 {
     return ActiveDOMObject::executionContext();
 }
 
 void RTCPeerConnection::suspend()
 {
-    m_dispatchScheduledEventRunner.suspend();
+    m_dispatchScheduledEventRunner->suspend();
 }
 
 void RTCPeerConnection::resume()
 {
-    m_dispatchScheduledEventRunner.resume();
+    m_dispatchScheduledEventRunner->resume();
 }
 
 void RTCPeerConnection::stop()
 {
     if (m_stopped)
         return;
 
     m_stopped = true;
     m_iceConnectionState = ICEConnectionStateClosed;
     m_signalingState = SignalingStateClosed;
 
     HeapVector<Member<RTCDataChannel>>::iterator i = m_dataChannels.begin();
     for (; i != m_dataChannels.end(); ++i)
         (*i)->stop();
     m_dataChannels.clear();
 
-    m_dispatchScheduledEventRunner.stop();
+    m_dispatchScheduledEventRunner->stop();
 
     m_peerHandler.clear();
 }
 
 void RTCPeerConnection::changeSignalingState(SignalingState signalingState)
 {
     if (m_signalingState != SignalingStateClosed && m_signalingState != signalingState) {
         m_signalingState = signalingState;
         scheduleDispatchEvent(Event::create(EventTypeNames::signalingstatechange));
     }
@@ skipping 35 matching lines @@
 void RTCPeerConnection::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     scheduleDispatchEvent(event, nullptr);
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event,
     PassOwnPtr<BoolFunction> setupFunction)
 {
     m_scheduledEvents.append(new EventWrapper(event, setupFunction));
 
-    m_dispatchScheduledEventRunner.runAsync();
+    m_dispatchScheduledEventRunner->runAsync();
 }
 
 void RTCPeerConnection::dispatchScheduledEvent()
 {
     if (m_stopped)
         return;
 
     HeapVector<Member<EventWrapper>> events;
     events.swap(m_scheduledEvents);
 
     HeapVector<Member<EventWrapper>>::iterator it = events.begin();
     for (; it != events.end(); ++it) {
         if ((*it)->setup()) {
             dispatchEvent((*it)->m_event.release());
         }
     }
 
     events.clear();
 }
 
 DEFINE_TRACE(RTCPeerConnection)
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dataChannels);
+    visitor->trace(m_dispatchScheduledEventRunner);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCPeerConnection>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink