Merge 132420

Source/WebCore/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 109 matching lines @@
 
     return peerConnection.release();
 }
 
 RTCPeerConnection::RTCPeerConnection(ScriptExecutionContext* context, PassRefPtr<RTCConfiguration> configuration, PassRefPtr<MediaConstraints> constraints, ExceptionCode& ec)
     : ActiveDOMObject(context, this)
     , m_readyState(ReadyStateNew)
     , m_iceState(IceStateClosed)
     , m_localStreams(MediaStreamList::create())
     , m_remoteStreams(MediaStreamList::create())
+    , m_scheduledEventTimer(this, &RTCPeerConnection::scheduledEventTimerFired)
 {
     m_peerHandler = RTCPeerConnectionHandler::create(this);
     if (!m_peerHandler || !m_peerHandler->initialize(configuration, constraints))
         ec = NOT_SUPPORTED_ERR;
 }
 
 RTCPeerConnection::~RTCPeerConnection()
 {
 }
 
@@ skipping 246 matching lines @@
         return;
     }
 
     changeIceState(IceStateClosed);
     changeReadyState(ReadyStateClosed);
     stop();
 }
 
 void RTCPeerConnection::negotiationNeeded()
 {
-    dispatchEvent(Event::create(eventNames().negotiationneededEvent, false, false));
+    scheduleDispatchEvent(Event::create(eventNames().negotiationneededEvent, false, false));
 }
 
 void RTCPeerConnection::didGenerateIceCandidate(PassRefPtr<RTCIceCandidateDescriptor> iceCandidateDescriptor)
 {
     ASSERT(scriptExecutionContext()->isContextThread());
     if (!iceCandidateDescriptor)
-        dispatchEvent(RTCIceCandidateEvent::create(false, false, 0));
+        scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, 0));
     else {
         RefPtr<RTCIceCandidate> iceCandidate = RTCIceCandidate::create(iceCandidateDescriptor);
-        dispatchEvent(RTCIceCandidateEvent::create(false, false, iceCandidate.release()));
+        scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, iceCandidate.release()));
     }
 }
 
 void RTCPeerConnection::didChangeReadyState(ReadyState newState)
 {
     ASSERT(scriptExecutionContext()->isContextThread());
     changeReadyState(newState);
 }
 
 void RTCPeerConnection::didChangeIceState(IceState newState)
 {
     ASSERT(scriptExecutionContext()->isContextThread());
     changeIceState(newState);
 }
 
 void RTCPeerConnection::didAddRemoteStream(PassRefPtr<MediaStreamDescriptor> streamDescriptor)
 {
     ASSERT(scriptExecutionContext()->isContextThread());
 
     if (m_readyState == ReadyStateClosed)
         return;
 
     RefPtr<MediaStream> stream = MediaStream::create(scriptExecutionContext(), streamDescriptor);
     m_remoteStreams->append(stream);
 
-    dispatchEvent(MediaStreamEvent::create(eventNames().addstreamEvent, false, false, stream.release()));
+    scheduleDispatchEvent(MediaStreamEvent::create(eventNames().addstreamEvent, false, false, stream.release()));
 }
 
 void RTCPeerConnection::didRemoveRemoteStream(MediaStreamDescriptor* streamDescriptor)
 {
     ASSERT(scriptExecutionContext()->isContextThread());
     ASSERT(streamDescriptor->owner());
 
     RefPtr<MediaStream> stream = static_cast<MediaStream*>(streamDescriptor->owner());
     stream->streamEnded();
 
     if (m_readyState == ReadyStateClosed)
         return;
 
     ASSERT(m_remoteStreams->contains(stream.get()));
     m_remoteStreams->remove(stream.get());
 
-    dispatchEvent(MediaStreamEvent::create(eventNames().removestreamEvent, false, false, stream.release()));
+    scheduleDispatchEvent(MediaStreamEvent::create(eventNames().removestreamEvent, false, false, stream.release()));
 }
 
 const AtomicString& RTCPeerConnection::interfaceName() const
 {
     return eventNames().interfaceForRTCPeerConnection;
 }
 
 ScriptExecutionContext* RTCPeerConnection::scriptExecutionContext() const
 {
     return ActiveDOMObject::scriptExecutionContext();
@@ skipping 24 matching lines @@
 {
     if (readyState == m_readyState || m_readyState == ReadyStateClosed)
         return;
 
     m_readyState = readyState;
 
     switch (m_readyState) {
     case ReadyStateOpening:
         break;
     case ReadyStateActive:
-        dispatchEvent(Event::create(eventNames().openEvent, false, false));
+        scheduleDispatchEvent(Event::create(eventNames().openEvent, false, false));
         break;
     case ReadyStateClosing:
     case ReadyStateClosed:
         break;
     case ReadyStateNew:
         ASSERT_NOT_REACHED();
         break;
     }
 
-    dispatchEvent(Event::create(eventNames().statechangeEvent, false, false));
+    scheduleDispatchEvent(Event::create(eventNames().statechangeEvent, false, false));
 }
 
 void RTCPeerConnection::changeIceState(IceState iceState)
 {
     if (iceState == m_iceState || m_readyState == ReadyStateClosed)
         return;
 
     m_iceState = iceState;
-    dispatchEvent(Event::create(eventNames().icechangeEvent, false, false));
+    scheduleDispatchEvent(Event::create(eventNames().icechangeEvent, false, false));
+}
+
+void RTCPeerConnection::scheduleDispatchEvent(PassRefPtr<Event> event)
+{
+    m_scheduledEvents.append(event);
+
+    if (!m_scheduledEventTimer.isActive())
+        m_scheduledEventTimer.startOneShot(0);
+}
+
+void RTCPeerConnection::scheduledEventTimerFired(Timer<RTCPeerConnection>*)
+{
+    Vector<RefPtr<Event> > events;
+    events.swap(m_scheduledEvents);
+
+    Vector<RefPtr<Event> >::iterator it = events.begin();
+    for (; it != events.end(); ++it)
+        dispatchEvent((*it).release());
+
+    events.clear();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM)