DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

third_party/WebKit/Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 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 155 matching lines @@
   static void swap(T* src, T* srcEnd, T* dst) {
     std::swap_ranges(src, srcEnd, dst);
   }
 };
 
 template <typename T>
 struct VectorMover<true, T> {
   STATIC_ONLY(VectorMover);
   static void move(const T* src, const T* srcEnd, T* dst) {
     if (LIKELY(dst && src))
-      memcpy(dst, src, reinterpret_cast<const char*>(srcEnd) -
-                           reinterpret_cast<const char*>(src));
+      memcpy(dst, src,
+             reinterpret_cast<const char*>(srcEnd) -
+                 reinterpret_cast<const char*>(src));
   }
   static void moveOverlapping(const T* src, const T* srcEnd, T* dst) {
     if (LIKELY(dst && src))
-      memmove(dst, src, reinterpret_cast<const char*>(srcEnd) -
-                            reinterpret_cast<const char*>(src));
+      memmove(dst, src,
+              reinterpret_cast<const char*>(srcEnd) -
+                  reinterpret_cast<const char*>(src));
   }
   static void swap(T* src, T* srcEnd, T* dst) {
     std::swap_ranges(reinterpret_cast<char*>(src),
                      reinterpret_cast<char*>(srcEnd),
                      reinterpret_cast<char*>(dst));
   }
 };
 
 template <bool canCopyWithMemcpy, typename T>
 struct VectorCopier;
 
 template <typename T>
 struct VectorCopier<false, T> {
   STATIC_ONLY(VectorCopier);
   template <typename U>
   static void uninitializedCopy(const U* src, const U* srcEnd, T* dst) {
     while (src != srcEnd) {
       new (NotNull, dst) T(*src);
       ++dst;
       ++src;
     }
   }
 };
 
 template <typename T>
 struct VectorCopier<true, T> {
   STATIC_ONLY(VectorCopier);
   static void uninitializedCopy(const T* src, const T* srcEnd, T* dst) {
     if (LIKELY(dst && src))
-      memcpy(dst, src, reinterpret_cast<const char*>(srcEnd) -
-                           reinterpret_cast<const char*>(src));
+      memcpy(dst, src,
+             reinterpret_cast<const char*>(srcEnd) -
+                 reinterpret_cast<const char*>(src));
   }
   template <typename U>
   static void uninitializedCopy(const U* src, const U* srcEnd, T* dst) {
     VectorCopier<false, T>::uninitializedCopy(src, srcEnd, dst);
   }
 };
 
 template <bool canFillWithMemset, typename T>
 struct VectorFiller;
 
@@ skipping 1569 matching lines @@
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h