Reflow comments in Source/modules/{geolocation,imagecapture,mediacapturefromelem…

third_party/WebKit/Source/modules/mediarecorder/MediaRecorder.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/mediarecorder/MediaRecorder.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/events/Event.h"
 #include "core/fileapi/Blob.h"
 #include "core/inspector/ConsoleMessage.h"
@@ skipping 43 matching lines @@
 void AllocateVideoAndAudioBitrates(ExceptionState& exceptionState,
                                    ExecutionContext* context,
                                    const MediaRecorderOptions& options,
                                    MediaStream* stream,
                                    int* audioBitsPerSecond,
                                    int* videoBitsPerSecond) {
   const bool useVideo = !stream->getVideoTracks().isEmpty();
   const bool useAudio = !stream->getAudioTracks().isEmpty();
 
   // Clamp incoming values into a signed integer's range.
-  // TODO(mcasas): This section would no be needed if the bit rates are signed or double, see https://github.com/w3c/mediacapture-record/issues/48.
+  // TODO(mcasas): This section would no be needed if the bit rates are signed
+  // or double, see https://github.com/w3c/mediacapture-record/issues/48.
   const unsigned kMaxIntAsUnsigned = std::numeric_limits<int>::max();
 
   int overallBps = 0;
   if (options.hasBitsPerSecond())
     overallBps = std::min(options.bitsPerSecond(), kMaxIntAsUnsigned);
   int videoBps = 0;
   if (options.hasVideoBitsPerSecond() && useVideo)
     videoBps = std::min(options.videoBitsPerSecond(), kMaxIntAsUnsigned);
   int audioBps = 0;
   if (options.hasAudioBitsPerSecond() && useAudio)
@@ skipping 28 matching lines @@
       }
     } else {
       DCHECK(!audioBps);
     }
   }
 
   if (useVideo) {
     // Allocate the remaining |overallBps|, if any, to video.
     if (options.hasBitsPerSecond())
       videoBps = overallBps - audioBps;
-    // Clamp the video bit rate. Avoid clamping if the user has not set it explicitly.
+    // Clamp the video bit rate. Avoid clamping if the user has not set it
+    // explicitly.
     if (options.hasVideoBitsPerSecond() || options.hasBitsPerSecond()) {
       if (videoBps < kSmallestPossibleVpxBitRate) {
         context->addConsoleMessage(ConsoleMessage::create(
             JSMessageSource, WarningMessageLevel,
             "Clamping calculated video bitrate (" + String::number(videoBps) +
                 "bps) to the minimum (" +
                 String::number(kSmallestPossibleVpxBitRate) + "bps)"));
         videoBps = kSmallestPossibleVpxBitRate;
       }
     } else {
@@ skipping 202 matching lines @@
                               bool lastInSlice) {
   if (m_stopped && !lastInSlice) {
     m_stopped = false;
     scheduleDispatchEvent(Event::create(EventTypeNames::start));
   }
   if (m_stream && m_streamAmountOfTracks != m_stream->getTracks().size()) {
     m_streamAmountOfTracks = m_stream->getTracks().size();
     onError("Amount of tracks in MediaStream has changed.");
   }
 
-  // TODO(mcasas): Act as |m_ignoredMutedMedia| instructs if |m_stream| track(s) is in muted() state.
+  // TODO(mcasas): Act as |m_ignoredMutedMedia| instructs if |m_stream| track(s)
+  // is in muted() state.
 
   if (!m_blobData) {
     m_blobData = BlobData::create();
     m_blobData->setContentType(m_mimeType);
   }
   if (data)
     m_blobData->appendBytes(data, length);
 
   if (!lastInSlice)
     return;
 
   // Cache |m_blobData->length()| before release()ng it.
   const long long blobDataLength = m_blobData->length();
   createBlobEvent(Blob::create(
       BlobDataHandle::create(std::move(m_blobData), blobDataLength)));
 }
 
 void MediaRecorder::onError(const WebString& message) {
-  // TODO(mcasas): Beef up the Error Event and add the |message|, see https://github.com/w3c/mediacapture-record/issues/31
+  // TODO(mcasas): Beef up the Error Event and add the |message|, see
+  // https://github.com/w3c/mediacapture-record/issues/31
   scheduleDispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void MediaRecorder::createBlobEvent(Blob* blob) {
-  // TODO(mcasas): Consider launching an Event with a TypedArray inside, see https://github.com/w3c/mediacapture-record/issues/17.
+  // TODO(mcasas): Consider launching an Event with a TypedArray inside, see
+  // https://github.com/w3c/mediacapture-record/issues/17.
   scheduleDispatchEvent(BlobEvent::create(EventTypeNames::dataavailable, blob));
 }
 
 void MediaRecorder::stopRecording() {
   DCHECK(m_state != State::Inactive);
   m_state = State::Inactive;
 
   m_recorderHandler->stop();
 
   writeData(nullptr /* data */, 0 /* length */, true /* lastInSlice */);
@@ skipping 16 matching lines @@
 
 DEFINE_TRACE(MediaRecorder) {
   visitor->trace(m_stream);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 }  // namespace blink