Fix check-webkit-style errors in Source/wtf/text/.

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

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Google 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
@@ skipping 152 matching lines @@
     // If the buffer has only one ref (by this StringBuilder), reallocate it,
     // otherwise fall back to "allocate and copy" method.
     m_string = String();
 
     ASSERT(m_is8Bit);
     ASSERT(m_buffer->is8Bit());
 
     if (m_buffer->hasOneRef()) {
         m_buffer = StringImpl::reallocate(m_buffer.release(), requiredLength);
         m_bufferCharacters8 = const_cast<LChar*>(m_buffer->characters8());
-    } else
+    } else {
         allocateBuffer(m_buffer->characters8(), requiredLength);
+    }
 }
 
 template <>
 void StringBuilder::reallocateBuffer<UChar>(unsigned requiredLength)
 {
     // If the buffer has only one ref (by this StringBuilder), reallocate it,
     // otherwise fall back to "allocate and copy" method.
     m_string = String();
 
     if (m_buffer->is8Bit()) {
         allocateBufferUpConvert(m_buffer->characters8(), requiredLength);
     } else if (m_buffer->hasOneRef()) {
         m_buffer = StringImpl::reallocate(m_buffer.release(), requiredLength);
         m_bufferCharacters16 = const_cast<UChar*>(m_buffer->characters16());
-    } else
+    } else {
         allocateBuffer(m_buffer->characters16(), requiredLength);
+    }
 }
 
 void StringBuilder::reserveCapacity(unsigned newCapacity)
 {
     if (m_buffer) {
         // If there is already a buffer, then grow if necessary.
         if (newCapacity > m_buffer->length()) {
             if (m_buffer->is8Bit())
                 reallocateBuffer<LChar>(newCapacity);
             else
                 reallocateBuffer<UChar>(newCapacity);
         }
     } else {
         // Grow the string, if necessary.
         if (newCapacity > m_length) {
             if (!m_length) {
                 LChar* nullPlaceholder = 0;
                 allocateBuffer(nullPlaceholder, newCapacity);
-            } else if (m_string.is8Bit())
+            } else if (m_string.is8Bit()) {
                 allocateBuffer(m_string.characters8(), newCapacity);
-            else
+            } else {
                 allocateBuffer(m_string.characters16(), newCapacity);
+            }
         }
     }
 }
 
 // Make 'length' additional capacity be available in m_buffer, update m_string & m_length,
 // return a pointer to the newly allocated storage.
 template <typename CharType>
 ALWAYS_INLINE CharType* StringBuilder::appendUninitialized(unsigned length)
 {
     ASSERT(length);
@@ skipping 60 matching lines @@
             ASSERT(m_buffer->length() >= m_length);
 
             allocateBufferUpConvert(m_buffer->characters8(), expandedCapacity(capacity(), requiredLength));
         } else {
             ASSERT(m_string.length() == m_length);
             allocateBufferUpConvert(m_string.isNull() ? 0 : m_string.characters8(), expandedCapacity(capacity(), requiredLength));
         }
 
         memcpy(m_bufferCharacters16 + m_length, characters, static_cast<size_t>(length) * sizeof(UChar));
         m_length = requiredLength;
-    } else
+    } else {
         memcpy(appendUninitialized<UChar>(length), characters, static_cast<size_t>(length) * sizeof(UChar));
+    }
 }
 
 void StringBuilder::append(const LChar* characters, unsigned length)
 {
     if (!length)
         return;
     ASSERT(characters);
 
     if (m_is8Bit) {
         LChar* dest = appendUninitialized<LChar>(length);
-        if (length > 8)
+        if (length > 8) {
             memcpy(dest, characters, static_cast<size_t>(length) * sizeof(LChar));
-        else {
+        } else {
             const LChar* end = characters + length;
             while (characters < end)
                 *(dest++) = *(characters++);
         }
     } else {
         UChar* dest = appendUninitialized<UChar>(length);
         const LChar* end = characters + length;
         while (characters < end)
             *(dest++) = *(characters++);
     }
@@ skipping 69 matching lines @@
     if (!canShrink())
         return;
     if (m_is8Bit)
         reallocateBuffer<LChar>(m_length);
     else
         reallocateBuffer<UChar>(m_length);
     m_string = m_buffer.release();
 }
 
 } // namespace WTF