Reflow comments in modules/peerconnection.

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 360 matching lines @@
   return rtcConfiguration;
 }
 
 RTCOfferOptionsPlatform* parseOfferOptions(const Dictionary& options) {
   if (options.isUndefinedOrNull())
     return 0;
 
   Vector<String> propertyNames;
   options.getPropertyNames(propertyNames);
 
-  // Treat |options| as MediaConstraints if it is empty or has "optional" or "mandatory" properties for compatibility.
-  // TODO(jiayl): remove constraints when RTCOfferOptions reaches Stable and client code is ready.
+  // Treat |options| as MediaConstraints if it is empty or has "optional" or
+  // "mandatory" properties for compatibility.
+  // TODO(jiayl): remove constraints when RTCOfferOptions reaches Stable and
+  // client code is ready.
   if (propertyNames.isEmpty() || propertyNames.contains("optional") ||
       propertyNames.contains("mandatory"))
     return 0;
 
   int32_t offerToReceiveVideo = -1;
   int32_t offerToReceiveAudio = -1;
   bool voiceActivityDetection = true;
   bool iceRestart = false;
 
   if (DictionaryHelper::get(options, "offerToReceiveVideo",
                             offerToReceiveVideo) &&
       offerToReceiveVideo < 0)
     offerToReceiveVideo = 0;
   if (DictionaryHelper::get(options, "offerToReceiveAudio",
                             offerToReceiveAudio) &&
       offerToReceiveAudio < 0)
     offerToReceiveAudio = 0;
   DictionaryHelper::get(options, "voiceActivityDetection",
                         voiceActivityDetection);
   DictionaryHelper::get(options, "iceRestart", iceRestart);
 
   RTCOfferOptionsPlatform* rtcOfferOptions =
       RTCOfferOptionsPlatform::create(offerToReceiveVideo, offerToReceiveAudio,
                                       voiceActivityDetection, iceRestart);
   return rtcOfferOptions;
 }
 
-// Helper class for |RTCPeerConnection::getStats(ScriptState*, MediaStreamTrack*)|
+// Helper class for
+// |RTCPeerConnection::getStats(ScriptState*, MediaStreamTrack*)|
 class WebRTCStatsReportCallbackResolver : public WebRTCStatsReportCallback {
  public:
   // Takes ownership of |resolver|.
   static std::unique_ptr<WebRTCStatsReportCallback> create(
       ScriptPromiseResolver* resolver) {
     return std::unique_ptr<WebRTCStatsReportCallback>(
         new WebRTCStatsReportCallbackResolver(resolver));
   }
 
   ~WebRTCStatsReportCallbackResolver() override {}
@@ skipping 31 matching lines @@
                                              const Dictionary& rtcConfiguration,
                                              const Dictionary& mediaConstraints,
                                              ExceptionState& exceptionState) {
   if (mediaConstraints.isObject())
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionConstructorConstraints);
   else
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionConstructorCompliant);
 
-  // Record the RtcpMuxPolicy for histogram "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
+  // Record the RtcpMuxPolicy for histogram
+  // "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
   RtcpMuxPolicy selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
   RTCConfiguration* configuration = parseConfiguration(
       rtcConfiguration, exceptionState, &selectedRtcpMuxPolicy);
   if (exceptionState.hadException())
     return 0;
 
   // Make sure no certificates have expired.
   if (configuration && configuration->numberOfCertificates() > 0) {
     DOMTimeStamp now = convertSecondsToDOMTimeStamp(currentTime());
     for (size_t i = 0; i < configuration->numberOfCertificates(); ++i) {
@@ skipping 37 matching lines @@
       m_iceConnectionState(ICEConnectionStateNew),
       m_dispatchScheduledEventRunner(
           AsyncMethodRunner<RTCPeerConnection>::create(
               this,
               &RTCPeerConnection::dispatchScheduledEvent)),
       m_stopped(false),
       m_closed(false) {
   ThreadState::current()->registerPreFinalizer(this);
   Document* document = toDocument(getExecutionContext());
 
-  // If we fail, set |m_closed| and |m_stopped| to true, to avoid hitting the assert in the destructor.
+  // If we fail, set |m_closed| and |m_stopped| to true, to avoid hitting the
+  // assert in the destructor.
 
   if (!document->frame()) {
     m_closed = true;
     m_stopped = true;
     exceptionState.throwDOMException(
         NotSupportedError,
         "PeerConnections may not be created in detached documents.");
     return;
   }
 
@@ skipping 17 matching lines @@
     m_closed = true;
     m_stopped = true;
     exceptionState.throwDOMException(
         NotSupportedError, "Failed to initialize native PeerConnection.");
     return;
   }
 }
 
 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.
+  // We are assuming that a wrapper is always created when RTCPeerConnection is
+  // created.
   DCHECK(m_closed || m_stopped);
 }
 
 void RTCPeerConnection::dispose() {
   // Promptly clears a raw reference from content/ to an on-heap object
   // so that content/ doesn't access it in a lazy sweeping phase.
   m_peerHandler.reset();
 }
 
 ScriptPromise RTCPeerConnection::createOffer(ScriptState* scriptState,
@@ skipping 41 matching lines @@
           context, UseCounter::RTCPeerConnectionCreateOfferLegacyOfferOptions);
     else
       UseCounter::count(
           context, UseCounter::RTCPeerConnectionCreateOfferLegacyCompliant);
 
     m_peerHandler->createOffer(request, WebRTCOfferOptions(offerOptions));
   } else {
     MediaErrorState mediaErrorState;
     WebMediaConstraints constraints =
         MediaConstraintsImpl::create(context, rtcOfferOptions, mediaErrorState);
-    // Report constraints parsing errors via the callback, but ignore unknown/unsupported constraints as they
-    // would be silently discarded by WebIDL.
+    // Report constraints parsing errors via the callback, but ignore
+    // unknown/unsupported constraints as they would be silently discarded by
+    // WebIDL.
     if (mediaErrorState.canGenerateException()) {
       String errorMsg = mediaErrorState.getErrorMessage();
       asyncCallErrorCallback(errorCallback,
                              DOMException::create(OperationError, errorMsg));
       return ScriptPromise::castUndefined(scriptState);
     }
 
     if (!constraints.isEmpty())
       UseCounter::count(
           context, UseCounter::RTCPeerConnectionCreateOfferLegacyConstraints);
@@ skipping 38 matching lines @@
   else
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionCreateAnswerLegacyCompliant);
 
   if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
     return ScriptPromise::castUndefined(scriptState);
 
   MediaErrorState mediaErrorState;
   WebMediaConstraints constraints =
       MediaConstraintsImpl::create(context, mediaConstraints, mediaErrorState);
-  // Report constraints parsing errors via the callback, but ignore unknown/unsupported constraints as they
-  // would be silently discarded by WebIDL.
+  // Report constraints parsing errors via the callback, but ignore
+  // unknown/unsupported constraints as they would be silently discarded by
+  // WebIDL.
   if (mediaErrorState.canGenerateException()) {
     String errorMsg = mediaErrorState.getErrorMessage();
     asyncCallErrorCallback(errorCallback,
                            DOMException::create(OperationError, errorMsg));
     return ScriptPromise::castUndefined(scriptState);
   }
 
   RTCSessionDescriptionRequest* request =
       RTCSessionDescriptionRequestImpl::create(getExecutionContext(), this,
                                                successCallback, errorCallback);
@@ skipping 146 matching lines @@
   if (!valid)
     exceptionState.throwDOMException(
         SyntaxError,
         "Could not update the ICE Agent with the given configuration.");
 }
 
 ScriptPromise RTCPeerConnection::generateCertificate(
     ScriptState* scriptState,
     const AlgorithmIdentifier& keygenAlgorithm,
     ExceptionState& exceptionState) {
-  // Normalize |keygenAlgorithm| with WebCrypto, making sure it is a recognized AlgorithmIdentifier.
+  // Normalize |keygenAlgorithm| with WebCrypto, making sure it is a recognized
+  // AlgorithmIdentifier.
   WebCryptoAlgorithm cryptoAlgorithm;
   AlgorithmError error;
   if (!normalizeAlgorithm(keygenAlgorithm, WebCryptoOperationGenerateKey,
                           cryptoAlgorithm, &error)) {
-    // Reject generateCertificate with the same error as was produced by WebCrypto.
-    // |result| is garbage collected, no need to delete.
+    // Reject generateCertificate with the same error as was produced by
+    // WebCrypto. |result| is garbage collected, no need to delete.
     CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
     ScriptPromise promise = result->promise();
     result->completeWithError(error.errorType, error.errorDetails);
     return promise;
   }
 
-  // Check if |keygenAlgorithm| contains the optional DOMTimeStamp |expires| attribute.
+  // Check if |keygenAlgorithm| contains the optional DOMTimeStamp |expires|
+  // attribute.
   Nullable<DOMTimeStamp> expires;
   if (keygenAlgorithm.isDictionary()) {
     Dictionary keygenAlgorithmDict = keygenAlgorithm.getAsDictionary();
     if (keygenAlgorithmDict.hasProperty("expires")) {
       v8::Local<v8::Value> expiresValue;
       keygenAlgorithmDict.get("expires", expiresValue);
       if (expiresValue->IsNumber()) {
         double expiresDouble =
             expiresValue->ToNumber(scriptState->isolate()->GetCurrentContext())
                 .ToLocalChecked()
                 ->Value();
         if (expiresDouble >= 0) {
           expires.set(static_cast<DOMTimeStamp>(expiresDouble));
         }
       }
     }
   }
 
-  // Convert from WebCrypto representation to recognized WebRTCKeyParams. WebRTC supports a small subset of what are valid AlgorithmIdentifiers.
+  // Convert from WebCrypto representation to recognized WebRTCKeyParams. WebRTC
+  // supports a small subset of what are valid AlgorithmIdentifiers.
   const char* unsupportedParamsString =
       "The 1st argument provided is an AlgorithmIdentifier with a supported "
       "algorithm name, but the parameters are not supported.";
   Nullable<WebRTCKeyParams> keyParams;
   switch (cryptoAlgorithm.id()) {
     case WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
       // name: "RSASSA-PKCS1-v1_5"
       unsigned publicExponent;
-      // "publicExponent" must fit in an unsigned int. The only recognized "hash" is "SHA-256".
+      // "publicExponent" must fit in an unsigned int. The only recognized
+      // "hash" is "SHA-256".
       if (cryptoAlgorithm.rsaHashedKeyGenParams()
               ->convertPublicExponentToUnsigned(publicExponent) &&
           cryptoAlgorithm.rsaHashedKeyGenParams()->hash().id() ==
               WebCryptoAlgorithmIdSha256) {
         unsigned modulusLength =
             cryptoAlgorithm.rsaHashedKeyGenParams()->modulusLengthBits();
         keyParams.set(
             WebRTCKeyParams::createRSA(modulusLength, publicExponent));
       } else {
         return ScriptPromise::rejectWithDOMException(
@@ skipping 19 matching lines @@
                                             "The 1st argument provided is an "
                                             "AlgorithmIdentifier, but the "
                                             "algorithm is not supported."));
       break;
   }
   DCHECK(!keyParams.isNull());
 
   std::unique_ptr<WebRTCCertificateGenerator> certificateGenerator =
       wrapUnique(Platform::current()->createRTCCertificateGenerator());
 
-  // |keyParams| was successfully constructed, but does the certificate generator support these parameters?
+  // |keyParams| was successfully constructed, but does the certificate
+  // generator support these parameters?
   if (!certificateGenerator->isSupportedKeyParams(keyParams.get())) {
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(NotSupportedError, unsupportedParamsString));
   }
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   std::unique_ptr<WebRTCCertificateObserver> certificateObserver(
       WebRTCCertificateObserver::create(resolver));
 
-  // Generate certificate. The |certificateObserver| will resolve the promise asynchronously upon completion.
-  // The observer will manage its own destruction as well as the resolver's destruction.
+  // Generate certificate. The |certificateObserver| will resolve the promise
+  // asynchronously upon completion. The observer will manage its own
+  // destruction as well as the resolver's destruction.
   if (expires.isNull()) {
     certificateGenerator->generateCertificate(keyParams.get(),
                                               std::move(certificateObserver));
   } else {
     certificateGenerator->generateCertificateWithExpiration(
         keyParams.get(), expires.get(), std::move(certificateObserver));
   }
 
   return promise;
 }
@@ skipping 526 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 }  // namespace blink