Rely on 'memcpy' in WTF::copyChars

Source/wtf/text/StringImpl.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google 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.
  *
@@ skipping 280 matching lines @@
     }
 
     static StringImpl* empty();
 
     // FIXME: Does this really belong in StringImpl?
     template <typename T> static void copyChars(T* destination, const T* source, unsigned numCharacters)
     {
         if (numCharacters == 1) {
             *destination = *source;
             return;
         }

[abarth-chromium, 2014/03/24 16:46:54]

Should we remove this branch too?

[Mikhail, 2014/03/25 10:30:26]

This makes a bit better assembly, on the other hand I do not think we can ever
feel it in the real world, so IMO branch can be removed indeed for the code
simplification, wdyt?

 
-        // FIXME: Is this implementation really faster than memcpy?
-        if (numCharacters <= s_copyCharsInlineCutOff) {
-            unsigned i = 0;
-#if (CPU(X86) || CPU(X86_64))
-            const unsigned charsPerInt = sizeof(uint32_t) / sizeof(T);
-
-            if (numCharacters > charsPerInt) {
-                unsigned stopCount = numCharacters & ~(charsPerInt - 1);
-
-                const uint32_t* srcCharacters = reinterpret_cast<const uint32_t*>(source);
-                uint32_t* destCharacters = reinterpret_cast<uint32_t*>(destination);
-                for (unsigned j = 0; i < stopCount; i += charsPerInt, ++j)
-                    destCharacters[j] = srcCharacters[j];
-            }
-#endif
-            for (; i < numCharacters; ++i)
-                destination[i] = source[i];
-        } else
-            memcpy(destination, source, numCharacters * sizeof(T));
+        memcpy(destination, source, numCharacters * sizeof(T));
     }
 
     ALWAYS_INLINE static void copyChars(UChar* destination, const LChar* source, unsigned numCharacters)
     {
         for (unsigned i = 0; i < numCharacters; ++i)
             destination[i] = source[i];
     }
 
     // Some string features, like refcounting and the atomicity flag, are not
     // thread-safe. We achieve thread safety by isolation, giving each thread
@@ skipping 101 matching lines @@
     ALWAYS_INLINE static StringStats& stringStats() { return m_stringStats; }
 #endif
 
 private:
     template<typename CharType> static size_t allocationSize(unsigned length)
     {
         RELEASE_ASSERT(length <= ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(CharType)));
         return sizeof(StringImpl) + length * sizeof(CharType);
     }
 
-    // This number must be at least 2 to avoid sharing empty, null as well as 1 character strings from SmallStrings.

[abarth-chromium, 2014/03/24 16:46:54]

I take it this comment is no longer accurate?  It doesn't make much sense to
me...

-    static const unsigned s_copyCharsInlineCutOff = 20;
-
     template <class UCharPredicate> PassRefPtr<StringImpl> stripMatchedCharacters(UCharPredicate);
     template <typename CharType, class UCharPredicate> PassRefPtr<StringImpl> simplifyMatchedCharactersToSpace(UCharPredicate, StripBehavior);
     NEVER_INLINE unsigned hashSlowCase() const;
 
 #ifdef STRING_STATS
     static StringStats m_stringStats;
 #endif
 
     static unsigned m_highestStaticStringLength;
 
@@ skipping 301 matching lines @@
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif