Fix issue of localDescription and remoteDescription getter.

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 223 matching lines @@
     RTCPeerConnection* peerConnection = new RTCPeerConnection(context, configuration, constraints, exceptionState);
     peerConnection->suspendIfNeeded();
     if (exceptionState.hadException())
         return 0;
 
     return peerConnection;
 }
 
 RTCPeerConnection::RTCPeerConnection(ExecutionContext* context, RTCConfiguration* configuration, WebMediaConstraints constraints, ExceptionState& exceptionState)
     : ActiveDOMObject(context)
+    , m_pendingLocalDescription(nullptr)
+    , m_pendingRemoteDescription(nullptr)
     , m_signalingState(SignalingStateStable)
     , m_iceGatheringState(ICEGatheringStateNew)
     , m_iceConnectionState(ICEConnectionStateNew)
     , m_dispatchScheduledEventRunner(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.
@@ skipping 14 matching lines @@
     }
 
     document->frame()->loader().client()->dispatchWillStartUsingPeerConnectionHandler(m_peerHandler.get());
 
     if (!m_peerHandler->initialize(configuration, constraints)) {
         m_closed = true;
         m_stopped = true;
         exceptionState.throwDOMException(NotSupportedError, "Failed to initialize native PeerConnection.");
         return;
     }
+    m_localDescription = RTCSessionDescription::create(m_peerHandler->localDescription());
+    m_remoteDescription = RTCSessionDescription::create(m_peerHandler->remoteDescription());
 }
 
 RTCPeerConnection::~RTCPeerConnection()
 {
     // This checks that close() or stop() is called before the destructor.
     // We are assuming that a wrapper is always created when RTCPeerConnection is created.
     ASSERT(m_closed || m_stopped);
 }
 
 void RTCPeerConnection::createOffer(RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback, const Dictionary& rtcOfferOptions, ExceptionState& exceptionState)
@@ skipping 38 matching lines @@
 void RTCPeerConnection::setLocalDescription(RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     if (!sessionDescription) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "RTCSessionDescription"));
         return;
     }
 
-    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback, RTCVoidRequestImpl::RequestTypeLocal);
     m_peerHandler->setLocalDescription(request, sessionDescription->webSessionDescription());
+    m_pendingLocalDescription = sessionDescription;
 }
 
-RTCSessionDescription* RTCPeerConnection::localDescription(ExceptionState& exceptionState)
+RTCSessionDescription* RTCPeerConnection::localDescription()
 {
+    if (!m_peerHandler)
+        return nullptr;
     WebRTCSessionDescription webSessionDescription = m_peerHandler->localDescription();
     if (webSessionDescription.isNull())
         return nullptr;
 
-    return RTCSessionDescription::create(webSessionDescription);
+    if (!m_localDescription || m_localDescription->webSessionDescription().isNull()
+        || m_localDescription->webSessionDescription() != webSessionDescription) {
+        m_localDescription = RTCSessionDescription::create(webSessionDescription);
+    }
+
+    return m_localDescription;
 }
 
 void RTCPeerConnection::setRemoteDescription(RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     if (!sessionDescription) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "RTCSessionDescription"));
         return;
     }
 
-    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback, RTCVoidRequestImpl::RequestTypeRemote);
     m_peerHandler->setRemoteDescription(request, sessionDescription->webSessionDescription());
+    m_pendingRemoteDescription = sessionDescription;
 }
 
-RTCSessionDescription* RTCPeerConnection::remoteDescription(ExceptionState& exceptionState)
+RTCSessionDescription* RTCPeerConnection::remoteDescription()
 {
+    if (!m_peerHandler)
+        return nullptr;
     WebRTCSessionDescription webSessionDescription = m_peerHandler->remoteDescription();
     if (webSessionDescription.isNull())
         return nullptr;
 
-    return RTCSessionDescription::create(webSessionDescription);
+    if (!m_remoteDescription || m_remoteDescription->webSessionDescription().isNull()
+        || m_remoteDescription->webSessionDescription() != webSessionDescription) {
+        m_remoteDescription = RTCSessionDescription::create(webSessionDescription);
+    }
+
+    return m_remoteDescription;
 }
 
 void RTCPeerConnection::updateIce(const Dictionary& rtcConfiguration, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     RTCConfiguration* configuration = parseConfiguration(rtcConfiguration, exceptionState);
     if (exceptionState.hadException())
         return;
@@ skipping 27 matching lines @@
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     if (!iceCandidate) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "RTCIceCandidate"));
         return;
     }
     ASSERT(successCallback);
     ASSERT(errorCallback);
 
-    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback, RTCVoidRequestImpl::RequestTypeNone);
 
     bool implemented = m_peerHandler->addICECandidate(request, iceCandidate->webCandidate());
     if (!implemented) {
         exceptionState.throwDOMException(NotSupportedError, "This method is not yet implemented.");
     }
 }
 
 String RTCPeerConnection::signalingState() const
 {
     switch (m_signalingState) {
@@ skipping 192 matching lines @@
 }
 
 void RTCPeerConnection::close(ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     closeInternal();
 }
 
+void RTCPeerConnection::requestSucceeded(RTCVoidRequestImpl::RequestType requestType)
+{
+    if (requestType == RTCVoidRequestImpl::RequestTypeLocal) {
+        commitPendingLocalSessionDescription();
+    } else if (requestType == RTCVoidRequestImpl::RequestTypeRemote) {
+        commitPendingRemoteSessionDescription();
+    }
+}
+
 void RTCPeerConnection::negotiationNeeded()
 {
     ASSERT(!m_closed);
     scheduleDispatchEvent(Event::create(EventTypeNames::negotiationneeded));
 }
 
 void RTCPeerConnection::didGenerateICECandidate(const WebRTCICECandidate& webCandidate)
 {
     ASSERT(!m_closed);
     ASSERT(executionContext()->isContextThread());
@@ skipping 150 matching lines @@
 {
     ASSERT(m_signalingState != RTCPeerConnection::SignalingStateClosed);
     m_peerHandler->stop();
     m_closed = true;
 
     changeIceConnectionState(ICEConnectionStateClosed);
     changeIceGatheringState(ICEGatheringStateComplete);
     changeSignalingState(SignalingStateClosed);
 }
 
+void RTCPeerConnection::commitPendingLocalSessionDescription()
+{
+    m_localDescription = m_pendingLocalDescription;
+}
+
+void RTCPeerConnection::commitPendingRemoteSessionDescription()
+{
+    m_remoteDescription = m_pendingRemoteDescription;
+}
+
 void RTCPeerConnection::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     m_scheduledEvents.append(event);
 
     m_dispatchScheduledEventRunner.runAsync();
 }
 
 void RTCPeerConnection::dispatchScheduledEvent()
 {
     if (m_stopped)
         return;
 
     WillBeHeapVector<RefPtrWillBeMember<Event>> events;
     events.swap(m_scheduledEvents);
 
     WillBeHeapVector<RefPtrWillBeMember<Event>>::iterator it = events.begin();
     for (; it != events.end(); ++it)
         dispatchEvent((*it).release());
 
     events.clear();
 }
 
 DEFINE_TRACE(RTCPeerConnection)
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dataChannels);
+    visitor->trace(m_localDescription);
+    visitor->trace(m_remoteDescription);
+    visitor->trace(m_pendingLocalDescription);
+    visitor->trace(m_pendingRemoteDescription);
 #if ENABLE(OILPAN)
     visitor->trace(m_scheduledEvents);
 #endif
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCPeerConnection>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink