Rewrap comments to 80 columns in platform/graphics/{compositing,cpu,gpu,skia}/.

third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp

 // Copyright 2014 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 "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
 #include "platform/graphics/cpu/mips/WebGLImageConversionMSA.h"
 #include "platform/graphics/cpu/x86/WebGLImageConversionSSE.h"
@@ skipping 238 matching lines @@
       break;
     case GL_UNSIGNED_INT_2_10_10_10_REV:
       dstFormat = WebGLImageConversion::DataFormatRGBA2_10_10_10;
       break;
     default:
       ASSERT_NOT_REACHED();
   }
   return dstFormat;
 }
 
-// Following Float to Half-Float converion code is from the implementation of ftp://www.fox-toolkit.org/pub/fasthalffloatconversion.pdf,
-// "Fast Half Float Conversions" by Jeroen van der Zijp, November 2008 (Revised September 2010).
-// Specially, the basetable[512] and shifttable[512] are generated as follows:
+// The following Float to Half-Float conversion code is from the implementation
+// of ftp://www.fox-toolkit.org/pub/fasthalffloatconversion.pdf, "Fast Half
+// Float Conversions" by Jeroen van der Zijp, November 2008 (Revised September
+// 2010). Specially, the basetable[512] and shifttable[512] are generated as
+// follows:
 /*
 unsigned short basetable[512];
 unsigned char shifttable[512];
 
 void generatetables(){
     unsigned int i;
     int e;
     for (i = 0; i < 256; ++i){
         e = i - 127;
         if (e < -24){ // Very small numbers map to zero
@@ skipping 109 matching lines @@
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13};
 
 unsigned short convertFloatToHalfFloat(float f) {
   unsigned temp = *(reinterpret_cast<unsigned*>(&f));
   unsigned signexp = (temp >> 23) & 0x1ff;
   return baseTable[signexp] + ((temp & 0x007fffff) >> shiftTable[signexp]);
 }
 
 /* BEGIN CODE SHARED WITH MOZILLA FIREFOX */
 
-// The following packing and unpacking routines are expressed in terms of function templates and inline functions to achieve generality and speedup.
+// The following packing and unpacking routines are expressed in terms of
+// function templates and inline functions to achieve generality and speedup.
 // Explicit template specializations correspond to the cases that would occur.
-// Some code are merged back from Mozilla code in http://mxr.mozilla.org/mozilla-central/source/content/canvas/src/WebGLTexelConversions.h
+// Some code are merged back from Mozilla code in
+// http://mxr.mozilla.org/mozilla-central/source/content/canvas/src/WebGLTexelConversions.h
 
 //----------------------------------------------------------------------
 // Pixel unpacking routines.
 template <int format, typename SourceType, typename DstType>
 void unpack(const SourceType*, DstType*, unsigned) {
   ASSERT_NOT_REACHED();
 }
 
 template <>
 void unpack<WebGLImageConversion::DataFormatARGB8, uint8_t, uint8_t>(
@@ skipping 1968 matching lines @@
       Format == WebGLImageConversion::DataFormatR16F ||
       Format == WebGLImageConversion::DataFormatRGBA5551 ||
       Format == WebGLImageConversion::DataFormatRGBA4444 ||
       Format == WebGLImageConversion::DataFormatRGB565;
 };
 
 template <WebGLImageConversion::DataFormat SrcFormat,
           WebGLImageConversion::DataFormat DstFormat,
           WebGLImageConversion::AlphaOp alphaOp>
 void FormatConverter::convert() {
-  // Many instantiations of this template function will never be entered, so we try
-  // to return immediately in these cases to avoid the compiler to generate useless code.
+  // Many instantiations of this template function will never be entered, so we
+  // try to return immediately in these cases to avoid generating useless code.
   if (SrcFormat == DstFormat &&
       alphaOp == WebGLImageConversion::AlphaDoNothing) {
     ASSERT_NOT_REACHED();
     return;
   }
   if (!IsFloatFormat<DstFormat>::value && IsFloatFormat<SrcFormat>::value) {
     ASSERT_NOT_REACHED();
     return;
   }
 
-  // Only textures uploaded from DOM elements or ImageData can allow DstFormat != SrcFormat.
+  // Only textures uploaded from DOM elements or ImageData can allow DstFormat
+  // != SrcFormat.
   const bool srcFormatComesFromDOMElementOrImageData =
       WebGLImageConversion::srcFormatComeFromDOMElementOrImageData(SrcFormat);
   if (!srcFormatComesFromDOMElementOrImageData && SrcFormat != DstFormat) {
     ASSERT_NOT_REACHED();
     return;
   }
-  // Likewise, only textures uploaded from DOM elements or ImageData can possibly have to be unpremultiplied.
+  // Likewise, only textures uploaded from DOM elements or ImageData can
+  // possibly need to be unpremultiplied.
   if (!srcFormatComesFromDOMElementOrImageData &&
       alphaOp == WebGLImageConversion::AlphaDoUnmultiply) {
     ASSERT_NOT_REACHED();
     return;
   }
   if (srcFormatComesFromDOMElementOrImageData &&
       alphaOp == WebGLImageConversion::AlphaDoUnmultiply &&
       !SupportsConversionFromDomElements<DstFormat>::value) {
     ASSERT_NOT_REACHED();
     return;
   }
   if ((!HasAlpha(SrcFormat) || !HasColor(SrcFormat) || !HasColor(DstFormat)) &&
       alphaOp != WebGLImageConversion::AlphaDoNothing) {
     ASSERT_NOT_REACHED();
     return;
   }
-  // If converting DOM element data to UNSIGNED_INT_5_9_9_9_REV or UNSIGNED_INT_10F_11F_11F_REV,
-  // we should always switch to FLOAT instead to avoid unpack/pack to these two types.
+  // If converting DOM element data to UNSIGNED_INT_5_9_9_9_REV or
+  // UNSIGNED_INT_10F_11F_11F_REV, we should always switch to FLOAT instead to
+  // avoid unpacking/packing these two types.
   if (srcFormatComesFromDOMElementOrImageData && SrcFormat != DstFormat &&
       (DstFormat == WebGLImageConversion::DataFormatRGB5999 ||
        DstFormat == WebGLImageConversion::DataFormatRGB10F11F11F)) {
     ASSERT_NOT_REACHED();
     return;
   }
 
   typedef typename DataTypeForFormat<SrcFormat>::Type SrcType;
   typedef typename DataTypeForFormat<DstFormat>::Type DstType;
   const int IntermFormat = IntermediateFormat<DstFormat>::value;
@@ skipping 284 matching lines @@
 
     // TODO(fmalita): Partial frames are not supported currently: only fully
     // decoded frames make it through.  We could potentially relax this and
     // use SkImage::MakeFromBitmap(bitmap) to make a copy.
     skiaImage = frame->finalizePixelsAndGetImage();
     info = bitmap.info();
 
     if (hasAlpha && premultiplyAlpha)
       m_alphaOp = AlphaDoPremultiply;
   } else if (!premultiplyAlpha && hasAlpha) {
-    // 1. For texImage2D with HTMLVideoElment input, assume no PremultiplyAlpha had been applied and the alpha value for each pixel is 0xFF
-    // which is true at present and may be changed in the future and needs adjustment accordingly.
-    // 2. For texImage2D with HTMLCanvasElement input in which Alpha is already Premultiplied in this port,
-    // do AlphaDoUnmultiply if UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to false.
+    // 1. For texImage2D with HTMLVideoElment input, assume no PremultiplyAlpha
+    //    had been applied and the alpha value for each pixel is 0xFF.  This is
+    //    true at present; if it is changed in the future it will need
+    //    adjustment accordingly.
+    // 2. For texImage2D with HTMLCanvasElement input in which alpha is already
+    //    premultiplied in this port, do AlphaDoUnmultiply if
+    //    UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to false.
     if (m_imageHtmlDomSource != HtmlDomVideo)
       m_alphaOp = AlphaDoUnmultiply;
   }
 
   if (!skiaImage)
     return;
 
   m_imageSourceFormat = SK_B32_SHIFT ? DataFormatRGBA8 : DataFormatBGRA8;
   m_imageSourceUnpackAlignment =
       0;  // FIXME: this seems to always be zero - why use at all?
@@ skipping 334 matching lines @@
       pack<WebGLImageConversion::DataFormatRGB565,
            WebGLImageConversion::AlphaDoNothing>(srcRowStart, dstRowStart,
                                                  pixelsPerRow);
     } break;
     default:
       break;
   }
 }
 
 }  // namespace blink