Replace RTCErrorCallback with RTCPeerConnectionErrorCallback.

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

Index: third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp b/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
index e9d8a83a8216914370e554a463933fb421ee3a09..242c7341a8249410a0b7cc9b3331e1fc86715b0e 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
@@ -55,8 +55,8 @@
 #include "modules/mediastream/RTCDTMFSender.h"
 #include "modules/mediastream/RTCDataChannel.h"
 #include "modules/mediastream/RTCDataChannelEvent.h"
-#include "modules/mediastream/RTCErrorCallback.h"
 #include "modules/mediastream/RTCIceCandidateEvent.h"
+#include "modules/mediastream/RTCPeerConnectionErrorCallback.h"
 #include "modules/mediastream/RTCSessionDescription.h"
 #include "modules/mediastream/RTCSessionDescriptionCallback.h"
 #include "modules/mediastream/RTCSessionDescriptionInit.h"
@@ -103,40 +103,40 @@ bool throwExceptionIfSignalingStateClosed(RTCPeerConnection::SignalingState stat
 // Helper class for running error callbacks asynchronously
 class ErrorCallbackTask : public WebTaskRunner::Task {
 public:
-    static PassOwnPtr<ErrorCallbackTask> create(RTCErrorCallback* errorCallback, const String& errorMessage)
+    static PassOwnPtr<ErrorCallbackTask> create(RTCPeerConnectionErrorCallback* errorCallback, DOMException* exception)
     {
-        return adoptPtr(new ErrorCallbackTask(errorCallback, errorMessage));
+        return adoptPtr(new ErrorCallbackTask(errorCallback, exception));
     }
 
     ~ErrorCallbackTask() override = default;
 
     void run() override
     {
-        m_errorCallback->handleEvent(m_errorMessage);
+        m_errorCallback->handleEvent(m_exception);
     }
 
 private:
-    ErrorCallbackTask(RTCErrorCallback* errorCallback, const String& errorMessage)
+    ErrorCallbackTask(RTCPeerConnectionErrorCallback* errorCallback, DOMException* exception)
         : m_errorCallback(errorCallback)
-        , m_errorMessage(errorMessage)
+        , m_exception(exception)
     {
         ASSERT(errorCallback);
     }
 
-    Persistent<RTCErrorCallback> m_errorCallback;
-    String m_errorMessage;
+    Persistent<RTCPeerConnectionErrorCallback> m_errorCallback;
+    Persistent<DOMException> m_exception;
 };
 
-void asyncCallErrorCallback(RTCErrorCallback* errorCallback, const String& errorMessage)
+void asyncCallErrorCallback(RTCPeerConnectionErrorCallback* errorCallback, DOMException* exception)
 {
-    Microtask::enqueueMicrotask(ErrorCallbackTask::create(errorCallback, errorMessage));
+    Microtask::enqueueMicrotask(ErrorCallbackTask::create(errorCallback, exception));
 }
 
-bool callErrorCallbackIfSignalingStateClosed(RTCPeerConnection::SignalingState state, RTCErrorCallback* errorCallback)
+bool callErrorCallbackIfSignalingStateClosed(RTCPeerConnection::SignalingState state, RTCPeerConnectionErrorCallback* errorCallback)
 {
     if (state == RTCPeerConnection::SignalingStateClosed) {
         if (errorCallback)
-            asyncCallErrorCallback(errorCallback, kSignalingStateClosedMessage);
+            asyncCallErrorCallback(errorCallback, DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
         return true;
     }
@@ -465,7 +465,7 @@ RTCPeerConnection::~RTCPeerConnection()
     ASSERT(m_closed || m_stopped);
 }
 
-void RTCPeerConnection::createOffer(ExecutionContext* context, RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback, const Dictionary& rtcOfferOptions, ExceptionState& exceptionState)
+void RTCPeerConnection::createOffer(ExecutionContext* context, RTCSessionDescriptionCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback, const Dictionary& rtcOfferOptions, ExceptionState& exceptionState)
 {
     if (errorCallback)
         UseCounter::count(context, UseCounter::RTCPeerConnectionCreateOfferLegacyFailureCallback);
@@ -481,7 +481,7 @@ void RTCPeerConnection::createOffer(ExecutionContext* context, RTCSessionDescrip
     if (exceptionState.hadException())
         return;
 
-    RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestImpl::create(this, successCallback, errorCallback);
 
     if (offerOptions) {
         if (offerOptions->offerToReceiveAudio() != -1 || offerOptions->offerToReceiveVideo() != -1)
@@ -507,7 +507,7 @@ void RTCPeerConnection::createOffer(ExecutionContext* context, RTCSessionDescrip
     }
 }
 
-void RTCPeerConnection::createAnswer(ExecutionContext* context, RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
+void RTCPeerConnection::createAnswer(ExecutionContext* context, RTCSessionDescriptionCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
 {
     if (errorCallback)
         UseCounter::count(context, UseCounter::RTCPeerConnectionCreateAnswerLegacyFailureCallback);
@@ -531,7 +531,7 @@ void RTCPeerConnection::createAnswer(ExecutionContext* context, RTCSessionDescri
         return;
     }
 
-    RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestImpl::create(this, successCallback, errorCallback);
     m_peerHandler->createAnswer(request, constraints);
 }
 
@@ -547,7 +547,7 @@ ScriptPromise RTCPeerConnection::setLocalDescription(ScriptState* scriptState, c
     return promise;
 }
 
-ScriptPromise RTCPeerConnection::setLocalDescription(ScriptState* scriptState, RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCErrorCallback* errorCallback)
+ScriptPromise RTCPeerConnection::setLocalDescription(ScriptState* scriptState, RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback)
 {
     ExecutionContext* context = scriptState->executionContext();
     if (successCallback && errorCallback) {
@@ -564,7 +564,7 @@ ScriptPromise RTCPeerConnection::setLocalDescription(ScriptState* scriptState, R
 
     ASSERT(sessionDescription);
 
-    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCVoidRequest* request = RTCVoidRequestImpl::create(this, successCallback, errorCallback, InvalidAccessError);
     m_peerHandler->setLocalDescription(request, sessionDescription->webSessionDescription());
     return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
 }
@@ -590,7 +590,7 @@ ScriptPromise RTCPeerConnection::setRemoteDescription(ScriptState* scriptState,
     return promise;
 }
 
-ScriptPromise RTCPeerConnection::setRemoteDescription(ScriptState* scriptState, RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCErrorCallback* errorCallback)
+ScriptPromise RTCPeerConnection::setRemoteDescription(ScriptState* scriptState, RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback)
 {
     ExecutionContext* context = scriptState->executionContext();
     if (successCallback && errorCallback) {
@@ -607,7 +607,7 @@ ScriptPromise RTCPeerConnection::setRemoteDescription(ScriptState* scriptState,
 
     ASSERT(sessionDescription);
 
-    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCVoidRequest* request = RTCVoidRequestImpl::create(this, successCallback, errorCallback, InvalidAccessError);
     m_peerHandler->setRemoteDescription(request, sessionDescription->webSessionDescription());
     return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
 }
@@ -724,14 +724,13 @@ ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, const
     RTCVoidRequest* request = RTCVoidRequestPromiseImpl::create(this, resolver, OperationError);
     WebRTCICECandidate webCandidate = convertToWebRTCIceCandidate(candidate);
     bool implemented = m_peerHandler->addICECandidate(request, webCandidate);
-    // TODO(guidou): replace NotSupportedError when error handling in the spec is finalized. crbug.com/585621
     if (!implemented)
-        resolver->reject(DOMException::create(NotSupportedError, "This method is not yet implemented."));
+        resolver->reject(DOMException::create(OperationError, "This operation could not be completed."));
 
     return promise;
 }
 
-ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, RTCIceCandidate* iceCandidate, VoidCallback* successCallback, RTCErrorCallback* errorCallback)
+ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, RTCIceCandidate* iceCandidate, VoidCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback)
 {
     ASSERT(iceCandidate);
     ASSERT(successCallback);
@@ -740,10 +739,10 @@ ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, RTCIc
     if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
         return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
 
-    RTCVoidRequest* request = RTCVoidRequestImpl::create(executionContext(), this, successCallback, errorCallback);
+    RTCVoidRequest* request = RTCVoidRequestImpl::create(this, successCallback, errorCallback, OperationError);
     bool implemented = m_peerHandler->addICECandidate(request, iceCandidate->webCandidate());
     if (!implemented)
-        asyncCallErrorCallback(errorCallback, "This method is not yet implemented.");
+        asyncCallErrorCallback(errorCallback, DOMException::create(OperationError, "This operation could not be completed."));
 
     return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
 }