DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

third_party/WebKit/Source/modules/peerconnection/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 114 matching lines @@
       WTF::bind(&RTCPeerConnectionErrorCallback::handleEvent,
                 wrapPersistent(errorCallback), wrapPersistent(exception)));
 }
 
 bool callErrorCallbackIfSignalingStateClosed(
     RTCPeerConnection::SignalingState state,
     RTCPeerConnectionErrorCallback* errorCallback) {
   if (state == RTCPeerConnection::SignalingStateClosed) {
     if (errorCallback)
       asyncCallErrorCallback(
-          errorCallback, DOMException::create(InvalidStateError,
-                                              kSignalingStateClosedMessage));
+          errorCallback,
+          DOMException::create(InvalidStateError,
+                               kSignalingStateClosedMessage));
 
     return true;
   }
 
   return false;
 }
 
 bool isIceCandidateMissingSdp(
     const RTCIceCandidateInitOrRTCIceCandidate& candidate) {
   if (candidate.isRTCIceCandidateInit()) {
@@ skipping 153 matching lines @@
       for (const String& urlString : urlStrings) {
         KURL url(KURL(), urlString);
         if (!url.isValid()) {
           exceptionState.throwDOMException(
               SyntaxError, "'" + urlString + "' is not a valid URL.");
           return WebRTCConfiguration();
         }
         if (!(url.protocolIs("turn") || url.protocolIs("turns") ||
               url.protocolIs("stun"))) {
           exceptionState.throwDOMException(
-              SyntaxError, "'" + url.protocol() +
-                               "' is not one of the supported URL schemes "
-                               "'stun', 'turn' or 'turns'.");
+              SyntaxError,
+              "'" + url.protocol() +
+                  "' is not one of the supported URL schemes "
+                  "'stun', 'turn' or 'turns'.");
           return WebRTCConfiguration();
         }
         if ((url.protocolIs("turn") || url.protocolIs("turns")) &&
             (username.isNull() || credential.isNull())) {
           exceptionState.throwDOMException(InvalidAccessError,
                                            "Both username and credential are "
                                            "required when the URL scheme is "
                                            "\"turn\" or \"turns\".");
         }
         iceServers.push_back(WebRTCIceServer{url, username, credential});
@@ skipping 356 matching lines @@
     const RTCSessionDescriptionInit& sessionDescriptionInit) {
   if (m_signalingState == SignalingStateClosed)
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   RTCVoidRequest* request = RTCVoidRequestPromiseImpl::create(this, resolver);
   m_peerHandler->setLocalDescription(
-      request, WebRTCSessionDescription(sessionDescriptionInit.type(),
-                                        sessionDescriptionInit.sdp()));
+      request,
+      WebRTCSessionDescription(sessionDescriptionInit.type(),
+                               sessionDescriptionInit.sdp()));
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::setLocalDescription(
     ScriptState* scriptState,
     const RTCSessionDescriptionInit& sessionDescriptionInit,
     VoidCallback* successCallback,
     RTCPeerConnectionErrorCallback* errorCallback) {
   ExecutionContext* context = scriptState->getExecutionContext();
   if (successCallback && errorCallback) {
@@ skipping 12 matching lines @@
           UseCounter::
               RTCPeerConnectionSetLocalDescriptionLegacyNoFailureCallback);
   }
 
   if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
     return ScriptPromise::castUndefined(scriptState);
 
   RTCVoidRequest* request = RTCVoidRequestImpl::create(
       getExecutionContext(), this, successCallback, errorCallback);
   m_peerHandler->setLocalDescription(
-      request, WebRTCSessionDescription(sessionDescriptionInit.type(),
-                                        sessionDescriptionInit.sdp()));
+      request,
+      WebRTCSessionDescription(sessionDescriptionInit.type(),
+                               sessionDescriptionInit.sdp()));
   return ScriptPromise::castUndefined(scriptState);
 }
 
 RTCSessionDescription* RTCPeerConnection::localDescription() {
   WebRTCSessionDescription webSessionDescription =
       m_peerHandler->localDescription();
   if (webSessionDescription.isNull())
     return nullptr;
 
   return RTCSessionDescription::create(webSessionDescription);
 }
 
 ScriptPromise RTCPeerConnection::setRemoteDescription(
     ScriptState* scriptState,
     const RTCSessionDescriptionInit& sessionDescriptionInit) {
   if (m_signalingState == SignalingStateClosed)
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   RTCVoidRequest* request = RTCVoidRequestPromiseImpl::create(this, resolver);
   m_peerHandler->setRemoteDescription(
-      request, WebRTCSessionDescription(sessionDescriptionInit.type(),
-                                        sessionDescriptionInit.sdp()));
+      request,
+      WebRTCSessionDescription(sessionDescriptionInit.type(),
+                               sessionDescriptionInit.sdp()));
   return promise;
 }
 
 ScriptPromise RTCPeerConnection::setRemoteDescription(
     ScriptState* scriptState,
     const RTCSessionDescriptionInit& sessionDescriptionInit,
     VoidCallback* successCallback,
     RTCPeerConnectionErrorCallback* errorCallback) {
   ExecutionContext* context = scriptState->getExecutionContext();
   if (successCallback && errorCallback) {
@@ skipping 12 matching lines @@
           UseCounter::
               RTCPeerConnectionSetRemoteDescriptionLegacyNoFailureCallback);
   }
 
   if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
     return ScriptPromise::castUndefined(scriptState);
 
   RTCVoidRequest* request = RTCVoidRequestImpl::create(
       getExecutionContext(), this, successCallback, errorCallback);
   m_peerHandler->setRemoteDescription(
-      request, WebRTCSessionDescription(sessionDescriptionInit.type(),
-                                        sessionDescriptionInit.sdp()));
+      request,
+      WebRTCSessionDescription(sessionDescriptionInit.type(),
+                               sessionDescriptionInit.sdp()));
   return ScriptPromise::castUndefined(scriptState);
 }
 
 RTCSessionDescription* RTCPeerConnection::remoteDescription() {
   WebRTCSessionDescription webSessionDescription =
       m_peerHandler->remoteDescription();
   if (webSessionDescription.isNull())
     return nullptr;
 
   return RTCSessionDescription::create(webSessionDescription);
@@ skipping 108 matching lines @@
           WebCryptoNamedCurveP256) {
         keyParams.set(WebRTCKeyParams::createECDSA(WebRTCECCurveNistP256));
       } else {
         return ScriptPromise::rejectWithDOMException(
             scriptState,
             DOMException::create(NotSupportedError, unsupportedParamsString));
       }
       break;
     default:
       return ScriptPromise::rejectWithDOMException(
-          scriptState, DOMException::create(NotSupportedError,
-                                            "The 1st argument provided is an "
-                                            "AlgorithmIdentifier, but the "
-                                            "algorithm is not supported."));
+          scriptState,
+          DOMException::create(NotSupportedError,
+                               "The 1st argument provided is an "
+                               "AlgorithmIdentifier, but the "
+                               "algorithm is not supported."));
       break;
   }
   DCHECK(!keyParams.isNull());
 
   std::unique_ptr<WebRTCCertificateGenerator> certificateGenerator =
       WTF::wrapUnique(Platform::current()->createRTCCertificateGenerator());
 
   // |keyParams| was successfully constructed, but does the certificate
   // generator support these parameters?
   if (!certificateGenerator->isSupportedKeyParams(keyParams.get())) {
@@ skipping 567 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink