reflow comments in wtf/text

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

 /*
  * Copyright (C) 2006, 2009, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 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
@@ skipping 78 matching lines @@
     if (!isMainThread()) {
       internal::callOnMainThread(&deallocateOnMainThread, header);
     } else {
       underlyingString->deref();  // Balanced by call to ref in allocate above.
       WTF::Partitions::fastFree(header);
     }
   }
 }
 
 static CFIndex preferredSize(CFIndex size, CFOptionFlags, void*) {
-  // FIXME: If FastMalloc provided a "good size" callback, we'd want to use it here.
-  // Note that this optimization would help performance for strings created with the
-  // allocator that are mutable, and those typically are only created by callers who
-  // make a new string using the old string's allocator, such as some of the call
-  // sites in CFURL.
+  // FIXME: If FastMalloc provided a "good size" callback, we'd want to use it
+  // here.  Note that this optimization would help performance for strings
+  // created with the allocator that are mutable, and those typically are only
+  // created by callers who make a new string using the old string's allocator,
+  // such as some of the call sites in CFURL.
   return size;
 }
 
 static CFAllocatorRef create() {
   CFAllocatorContext context = {
       0,        0,          retain,     release,      copyDescription,
       allocate, reallocate, deallocate, preferredSize};
   return CFAllocatorCreate(0, &context);
 }
 
@@ skipping 10 matching lines @@
   if (!m_length || !isMainThread()) {
     if (is8Bit())
       return adoptCF(CFStringCreateWithBytes(
           0, reinterpret_cast<const UInt8*>(characters8()), m_length,
           kCFStringEncodingISOLatin1, false));
     return adoptCF(CFStringCreateWithCharacters(
         0, reinterpret_cast<const UniChar*>(characters16()), m_length));
   }
   CFAllocatorRef allocator = StringWrapperCFAllocator::allocator();
 
-  // Put pointer to the StringImpl in a global so the allocator can store it with the CFString.
+  // Put pointer to the StringImpl in a global so the allocator can store it
+  // with the CFString.
   ASSERT(!StringWrapperCFAllocator::currentString);
   StringWrapperCFAllocator::currentString = this;
 
   CFStringRef string;
   if (is8Bit())
     string = CFStringCreateWithBytesNoCopy(
         allocator, reinterpret_cast<const UInt8*>(characters8()), m_length,
         kCFStringEncodingISOLatin1, false, kCFAllocatorNull);
   else
     string = CFStringCreateWithCharactersNoCopy(
         allocator, reinterpret_cast<const UniChar*>(characters16()), m_length,
         kCFAllocatorNull);
-  // CoreFoundation might not have to allocate anything, we clear currentString in case we did not execute allocate().
+  // CoreFoundation might not have to allocate anything, we clear currentString
+  // in case we did not execute allocate().
   StringWrapperCFAllocator::currentString = 0;
 
   return adoptCF(string);
 }
 
-// On StringImpl creation we could check if the allocator is the StringWrapperCFAllocator.
-// If it is, then we could find the original StringImpl and just return that. But to
-// do that we'd have to compute the offset from CFStringRef to the allocated block;
-// the CFStringRef is *not* at the start of an allocated block. Testing shows 1000x
-// more calls to createCFString than calls to the create functions with the appropriate
+// On StringImpl creation we could check if the allocator is the
+// StringWrapperCFAllocator.  If it is, then we could find the original
+// StringImpl and just return that.  But to do that we'd have to compute the

[dcheng, 2016/10/01 03:06:14]

Out of curiosity, why are the spaces inconsistent between comments? There are
extra here, but no extra in StringUTF8Adaptor.h.

[Nico, 2016/10/01 16:42:24]

I used vim's gq to reflow comments. The . was at end of line, so I guess my vim
config tells vim to keep the space in that case, but in the other file there was
no '.' at line end.

+// offset from CFStringRef to the allocated block; the CFStringRef is *not* at
+// the start of an allocated block. Testing shows 1000x more calls to
+// createCFString than calls to the create functions with the appropriate
 // allocator, so it's probably not urgent optimize that case.
 
 }  // namespace WTF
 
 #endif  // OS(MACOSX)