reflow comments in wtf/text

third_party/WebKit/Source/wtf/text/TextCodecUTF8.cpp

 /*
  * Copyright (C) 2004, 2006, 2008, 2011 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 37 matching lines @@
 
   // Additional aliases that originally were present in the encoding
   // table in WebKit on Macintosh, and subsequently added by
   // TextCodecICU. Perhaps we can prove some are not used on the web
   // and remove them.
   registrar("unicode11utf8", "UTF-8");
   registrar("unicode20utf8", "UTF-8");
   registrar("utf8", "UTF-8");
   registrar("x-unicode20utf8", "UTF-8");
 
-  // Additional aliases present in the WHATWG Encoding Standard (http://encoding.spec.whatwg.org/)
+  // Additional aliases present in the WHATWG Encoding Standard
+  // (http://encoding.spec.whatwg.org/)
   // and Firefox (24), but not in ICU 4.6.
   registrar("unicode-1-1-utf-8", "UTF-8");
 }
 
 void TextCodecUTF8::registerCodecs(TextCodecRegistrar registrar) {
   registrar("UTF-8", create, 0);
 }
 
 static inline int nonASCIISequenceLength(uint8_t firstByte) {
   static const uint8_t lengths[256] = {
@@ skipping 115 matching lines @@
     if (count > m_partialSequenceSize) {
       if (count - m_partialSequenceSize > end - source) {
         if (!flush) {
           // The new data is not enough to complete the sequence, so
           // add it to the existing partial sequence.
           memcpy(m_partialSequence + m_partialSequenceSize, source,
                  end - source);
           m_partialSequenceSize += end - source;
           return false;
         }
-        // An incomplete partial sequence at the end is an error, but it will create
-        // a 16 bit string due to the replacementCharacter. Let the 16 bit path handle
-        // the error.
+        // An incomplete partial sequence at the end is an error, but it will
+        // create a 16 bit string due to the replacementCharacter. Let the 16
+        // bit path handle the error.
         return true;
       }
       memcpy(m_partialSequence + m_partialSequenceSize, source,
              count - m_partialSequenceSize);
       source += count - m_partialSequenceSize;
       m_partialSequenceSize = count;
     }
     int character = decodeNonASCIISequence(m_partialSequence, count);
     if (character & ~0xff)
       return true;
@@ skipping 72 matching lines @@
   // each byte in an invalid sequence will turn into a replacement character.
   StringBuffer<LChar> buffer(m_partialSequenceSize + length);
 
   const uint8_t* source = reinterpret_cast<const uint8_t*>(bytes);
   const uint8_t* end = source + length;
   const uint8_t* alignedEnd = alignToMachineWord(end);
   LChar* destination = buffer.characters();
 
   do {
     if (m_partialSequenceSize) {
-      // Explicitly copy destination and source pointers to avoid taking pointers to the
-      // local variables, which may harm code generation by disabling some optimizations
-      // in some compilers.
+      // Explicitly copy destination and source pointers to avoid taking
+      // pointers to the local variables, which may harm code generation by
+      // disabling some optimizations in some compilers.
       LChar* destinationForHandlePartialSequence = destination;
       const uint8_t* sourceForHandlePartialSequence = source;
       if (handlePartialSequence(destinationForHandlePartialSequence,
                                 sourceForHandlePartialSequence, end, flush,
                                 stopOnError, sawError)) {
         source = sourceForHandlePartialSequence;
         goto upConvertTo16Bit;
       }
       destination = destinationForHandlePartialSequence;
       source = sourceForHandlePartialSequence;
@@ skipping 61 matching lines @@
   StringBuffer<UChar> buffer16(m_partialSequenceSize + length);
 
   UChar* destination16 = buffer16.characters();
 
   // Copy the already converted characters
   for (LChar* converted8 = buffer.characters(); converted8 < destination;)
     *destination16++ = *converted8++;
 
   do {
     if (m_partialSequenceSize) {
-      // Explicitly copy destination and source pointers to avoid taking pointers to the
-      // local variables, which may harm code generation by disabling some optimizations
-      // in some compilers.
+      // Explicitly copy destination and source pointers to avoid taking
+      // pointers to the local variables, which may harm code generation by
+      // disabling some optimizations in some compilers.
       UChar* destinationForHandlePartialSequence = destination16;
       const uint8_t* sourceForHandlePartialSequence = source;
       handlePartialSequence(destinationForHandlePartialSequence,
                             sourceForHandlePartialSequence, end, flush,
                             stopOnError, sawError);
       destination16 = destinationForHandlePartialSequence;
       source = sourceForHandlePartialSequence;
       if (m_partialSequenceSize)
         break;
     }
@@ skipping 50 matching lines @@
   } while (flush && m_partialSequenceSize);
 
   buffer16.shrink(destination16 - buffer16.characters());
 
   return String::adopt(buffer16);
 }
 
 template <typename CharType>
 CString TextCodecUTF8::encodeCommon(const CharType* characters, size_t length) {
   // The maximum number of UTF-8 bytes needed per UTF-16 code unit is 3.
-  // BMP characters take only one UTF-16 code unit and can take up to 3 bytes (3x).
-  // Non-BMP characters take two UTF-16 code units and can take up to 4 bytes (2x).
+  // BMP characters take only one UTF-16 code unit and can take up to 3 bytes
+  // (3x).
+  // Non-BMP characters take two UTF-16 code units and can take up to 4 bytes
+  // (2x).
   if (length > std::numeric_limits<size_t>::max() / 3)
     CRASH();
   Vector<uint8_t> bytes(length * 3);
 
   size_t i = 0;
   size_t bytesWritten = 0;
   while (i < length) {
     UChar32 character;
     U16_NEXT(characters, i, length, character);
-    // U16_NEXT will simply emit a surrogate code point if an unmatched surrogate
-    // is encountered; we must convert it to a U+FFFD (REPLACEMENT CHARACTER) here.
+    // U16_NEXT will simply emit a surrogate code point if an unmatched
+    // surrogate is encountered; we must convert it to a
+    // U+FFFD (REPLACEMENT CHARACTER) here.
     if (0xD800 <= character && character <= 0xDFFF)
       character = replacementCharacter;
     U8_APPEND_UNSAFE(bytes.data(), bytesWritten, character);
   }
 
   return CString(reinterpret_cast<char*>(bytes.data()), bytesWritten);
 }
 
 CString TextCodecUTF8::encode(const UChar* characters,
                               size_t length,
                               UnencodableHandling) {
   return encodeCommon(characters, length);
 }
 
 CString TextCodecUTF8::encode(const LChar* characters,
                               size_t length,
                               UnencodableHandling) {
   return encodeCommon(characters, length);
 }
 
 }  // namespace WTF