Rewrap comments to 80 columns in Source/platform/image-decoders/.

third_party/WebKit/Source/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * Portions are Copyright (C) 2001-6 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  *
  * Alternatively, the contents of this file may be used under the terms
  * of either the Mozilla Public License Version 1.1, found at
  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
@@ skipping 318 matching lines @@
     if (m_needsRestart) {
       m_needsRestart = false;
       m_nextReadPosition = m_restartPosition;
     } else {
       updateRestartPosition();
     }
 
     const char* segment;
     const size_t bytes = m_data->getSomeData(segment, m_nextReadPosition);
     if (bytes == 0) {
-      // We had to suspend. When we resume, we will need to start from the restart position.
+      // We had to suspend. When we resume, we will need to start from the
+      // restart position.
       m_needsRestart = true;
       clearBuffer();
       return false;
     }
 
     m_nextReadPosition += bytes;
     m_info.src->bytes_in_buffer = bytes;
     const JOCTET* nextByte = reinterpret_cast_ptr<const JOCTET*>(segment);
     m_info.src->next_input_byte = nextByte;
     m_lastSetByte = nextByte;
     return true;
   }
 
   void setData(SegmentReader* data) {
     if (m_data.get() == data)
       return;
 
     m_data = data;
 
-    // If a restart is needed, the next call to fillBuffer will read from the new SegmentReader.
+    // If a restart is needed, the next call to fillBuffer will read from the
+    // new SegmentReader.
     if (m_needsRestart)
       return;
 
-    // Otherwise, empty the buffer, and leave the position the same, so fillBuffer continues
-    // reading from the same position in the new SegmentReader.
+    // Otherwise, empty the buffer, and leave the position the same, so
+    // fillBuffer continues reading from the same position in the new
+    // SegmentReader.
     m_nextReadPosition -= m_info.src->bytes_in_buffer;
     clearBuffer();
   }
 
   bool decode(bool onlySize) {
     // We need to do the setjmp here. Otherwise bad things will happen
     if (setjmp(m_err.setjmp_buffer))
       return m_decoder->setFailed();
 
     J_COLOR_SPACE overrideColorSpace = JCS_UNKNOWN;
@@ skipping 45 matching lines @@
           dimensionsLocationHistogram.count(m_nextReadPosition -
                                             m_info.src->bytes_in_buffer - 1);
         }
         // We can fill in the size now that the header is available.
         if (!m_decoder->setSize(m_info.image_width, m_info.image_height))
           return false;
 
         // Calculate and set decoded size.
         m_info.scale_num = m_decoder->desiredScaleNumerator();
         m_info.scale_denom = scaleDenominator;
-        // Scaling caused by running low on memory isn't supported by YUV decoding since
-        // YUV decoding is performed on full sized images. At this point, buffers and various
-        // image info structs have already been setup to the scaled size after reading the
-        // image header using this decoder, so using the full size is no longer possible.
+        // Scaling caused by running low on memory isn't supported by YUV
+        // decoding since YUV decoding is performed on full sized images. At
+        // this point, buffers and various image info structs have already been
+        // set up for the scaled size after reading the image header using this
+        // decoder, so using the full size is no longer possible.
         if (m_info.scale_num != m_info.scale_denom)
           overrideColorSpace = JCS_UNKNOWN;
         jpeg_calc_output_dimensions(&m_info);
         m_decoder->setDecodedSize(m_info.output_width, m_info.output_height);
 
         m_decoder->setOrientation(readImageOrientation(info()));
 
         // Allow color management of the decoded RGBA pixels if possible.
         if (!m_decoder->ignoresGammaAndColorProfile()) {
 #if USE(ICCJPEG)
@@ skipping 155 matching lines @@
     return true;
   }
 
   jpeg_decompress_struct* info() { return &m_info; }
   JSAMPARRAY samples() const { return m_samples; }
   JPEGImageDecoder* decoder() { return m_decoder; }
   IntSize uvSize() const { return m_uvSize; }
 
  private:
   JSAMPARRAY allocateSampleArray() {
-// Some output color spaces don't need the sample array: don't allocate in that case.
+// Some output color spaces don't need the sample array: don't allocate in that
+// case.
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
     if (turboSwizzled(m_info.out_color_space))
       return nullptr;
 #endif
 
     if (m_info.out_color_space != JCS_YCbCr)
       return (*m_info.mem->alloc_sarray)(
           reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE,
           4 * m_info.output_width, 1);
 
-    // Compute the width of the Y plane in bytes.  This may be larger than the output
-    // width, since the jpeg library requires that the allocated width be a multiple of
-    // DCTSIZE.  Note that this buffer will be used as garbage memory for rows that
-    // extend below the actual height of the image.  We can reuse the same memory for
-    // the U and V planes, since we are guaranteed that the Y plane width is at least
-    // as large as the U and V plane widths.
+    // Compute the width of the Y plane in bytes.  This may be larger than the
+    // output width, since the jpeg library requires that the allocated width be
+    // a multiple of DCTSIZE.  Note that this buffer will be used as garbage
+    // memory for rows that extend below the actual height of the image.  We can
+    // reuse the same memory for the U and V planes, since we are guaranteed
+    // that the Y plane width is at least as large as the U and V plane widths.
     int widthBytes = computeYUVWidthBytes(&m_info, 0);
     return (*m_info.mem->alloc_sarray)(
         reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE, widthBytes,
         1);
   }
 
   void updateRestartPosition() {
     if (m_lastSetByte != m_info.src->next_input_byte) {
-      // next_input_byte was updated by jpeg, meaning that it found a restart position.
+      // next_input_byte was updated by jpeg, meaning that it found a restart
+      // position.
       m_restartPosition = m_nextReadPosition - m_info.src->bytes_in_buffer;
     }
   }
 
   void clearBuffer() {
     // Let libjpeg know that the buffer needs to be refilled.
     m_info.src->bytes_in_buffer = 0;
     m_info.src->next_input_byte = nullptr;
     m_lastSetByte = nullptr;
   }
@@ skipping 354 matching lines @@
   // has failed.
   if (!m_reader->decode(onlySize) && isAllDataReceived())
     setFailed();
 
   // If decoding is done or failed, we don't need the JPEGImageReader anymore.
   if (isComplete(this, onlySize) || failed())
     m_reader.reset();
 }
 
 }  // namespace blink