Make sure peer connection states are updated properly

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 110 matching lines @@
     {
         m_resolver->reject();
         delete this;
     }
 
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 } // namespace
 
+RTCPeerConnection::EventWrapper::EventWrapper(
+    PassRefPtrWillBeRawPtr<Event> event,
+    PassOwnPtrWillBeRawPtr<BoolFunction> function)
+    : m_event(event)
+    , m_setupFunction(function)
+{
+}
+
+bool RTCPeerConnection::EventWrapper::setup()
+{
+    if (m_setupFunction) {
+        return (*m_setupFunction)();
+    }
+    return true;
+}
+
 RTCConfiguration* RTCPeerConnection::parseConfiguration(const Dictionary& configuration, ExceptionState& exceptionState)
 {
     if (configuration.isUndefinedOrNull())
         return 0;
 
     RTCIceTransports iceTransports = RTCIceTransportsAll;
     String iceTransportsString;
     if (DictionaryHelper::get(configuration, "iceTransports", iceTransportsString)) {
         if (iceTransportsString == "none") {
             iceTransports = RTCIceTransportsNone;
@@ skipping 811 matching lines @@
         m_signalingState = signalingState;
         scheduleDispatchEvent(Event::create(EventTypeNames::signalingstatechange));
     }
 }
 
 void RTCPeerConnection::changeIceGatheringState(ICEGatheringState iceGatheringState)
 {
     m_iceGatheringState = iceGatheringState;
 }
 
+bool RTCPeerConnection::setIceConnectionState(ICEConnectionState iceConnectionState)
+{
+    if (m_iceConnectionState != ICEConnectionStateClosed && m_iceConnectionState != iceConnectionState) {
+        m_iceConnectionState = iceConnectionState;
+        return true;
+    }
+    return false;
+}
+
 void RTCPeerConnection::changeIceConnectionState(ICEConnectionState iceConnectionState)
 {
-    if (m_iceConnectionState != ICEConnectionStateClosed && m_iceConnectionState != iceConnectionState) {
-        m_iceConnectionState = iceConnectionState;
-        scheduleDispatchEvent(Event::create(EventTypeNames::iceconnectionstatechange));
+    if (m_iceConnectionState != ICEConnectionStateClosed) {
+        scheduleDispatchEvent(Event::create(EventTypeNames::iceconnectionstatechange),
+            WTF::bind(&RTCPeerConnection::setIceConnectionState, this, iceConnectionState));
     }
 }
 
 void RTCPeerConnection::closeInternal()
 {
     ASSERT(m_signalingState != RTCPeerConnection::SignalingStateClosed);
     m_peerHandler->stop();
     m_closed = true;
 
     changeIceConnectionState(ICEConnectionStateClosed);
     changeIceGatheringState(ICEGatheringStateComplete);
     changeSignalingState(SignalingStateClosed);
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
-    m_scheduledEvents.append(event);
+    scheduleDispatchEvent(event, nullptr);
+}
+
+void RTCPeerConnection::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event,
+    PassOwnPtrWillBeRawPtr<BoolFunction> setupFunction)
+{
+    m_scheduledEvents.append(EventWrapper(event, setupFunction));
 
     m_dispatchScheduledEventRunner.runAsync();
 }
 
 void RTCPeerConnection::dispatchScheduledEvent()
 {
     if (m_stopped)
         return;
 
-    WillBeHeapVector<RefPtrWillBeMember<Event>> events;
+    WillBeHeapVector<EventWrapper> events;
     events.swap(m_scheduledEvents);
 
-    WillBeHeapVector<RefPtrWillBeMember<Event>>::iterator it = events.begin();
-    for (; it != events.end(); ++it)
-        dispatchEvent((*it).release());
+    WillBeHeapVector<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_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCPeerConnection>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink