Shrink the binary by not super inlining all string concatenations.

Source/wtf/text/StringConcatenate.h

 /*
  * Copyright (C) 2010 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 97 matching lines @@
         *destination = static_cast<LChar>(m_buffer);
     }
 
     void writeTo(UChar* destination) { *destination = m_buffer; }
 
 private:
     UChar m_buffer;
 };
 
 template<>
-class StringTypeAdapter<char*> {
+class WTF_EXPORT StringTypeAdapter<char*> {
 public:
     StringTypeAdapter<char*>(char* buffer)
         : m_buffer(buffer)
         , m_length(strlen(buffer))
     {
     }
 
     unsigned length() { return m_length; }
 
     bool is8Bit() { return true; }
 
-    void writeTo(LChar* destination)
-    {
-        for (unsigned i = 0; i < m_length; ++i)
-            destination[i] = static_cast<LChar>(m_buffer[i]);
-    }
+    void writeTo(LChar* destination);
 
-    void writeTo(UChar* destination)
-    {
-        for (unsigned i = 0; i < m_length; ++i) {
-            unsigned char c = m_buffer[i];
-            destination[i] = c;
-        }
-    }
+    void writeTo(UChar* destination);
 
 private:
     const char* m_buffer;
     unsigned m_length;
 };
 
 template<>
-class StringTypeAdapter<LChar*> {
+class WTF_EXPORT StringTypeAdapter<LChar*> {
 public:
-    StringTypeAdapter<LChar*>(LChar* buffer)
-    : m_buffer(buffer)
-    , m_length(strlen(reinterpret_cast<char*>(buffer)))
-    {
-    }
+    StringTypeAdapter<LChar*>(LChar* buffer);
 
     unsigned length() { return m_length; }
 
     bool is8Bit() { return true; }
 
-    void writeTo(LChar* destination)
-    {
-        memcpy(destination, m_buffer, m_length * sizeof(LChar));
-    }
+    void writeTo(LChar* destination);
 
-    void writeTo(UChar* destination)
-    {
-        StringImpl::copyChars(destination, m_buffer, m_length);
-    }
+    void writeTo(UChar* destination);
 
 private:
     const LChar* m_buffer;
     unsigned m_length;
 };
 
 template<>
-class StringTypeAdapter<const UChar*> {
+class WTF_EXPORT StringTypeAdapter<const UChar*> {
 public:
-    StringTypeAdapter<const UChar*>(const UChar* buffer)
-        : m_buffer(buffer)
-    {
-        size_t len = 0;
-        while (m_buffer[len] != UChar(0))
-            ++len;
-
-        RELEASE_ASSERT(len <= std::numeric_limits<unsigned>::max());
-
-        m_length = len;
-    }
+    StringTypeAdapter(const UChar* buffer);
 
     unsigned length() { return m_length; }
 
     bool is8Bit() { return false; }
 
     NO_RETURN_DUE_TO_CRASH void writeTo(LChar*)
     {
         RELEASE_ASSERT(false);
     }
 
-    void writeTo(UChar* destination)
-    {
-        memcpy(destination, m_buffer, m_length * sizeof(UChar));
-    }
+    void writeTo(UChar* destination);
 
 private:
     const UChar* m_buffer;
     unsigned m_length;
 };
 
 template<>
-class StringTypeAdapter<const char*> {
+class WTF_EXPORT StringTypeAdapter<const char*> {
 public:
-    StringTypeAdapter<const char*>(const char* buffer)
-        : m_buffer(buffer)
-        , m_length(strlen(buffer))
-    {
-    }
+    StringTypeAdapter<const char*>(const char* buffer);
 
     unsigned length() { return m_length; }
 
     bool is8Bit() { return true; }
 
-    void writeTo(LChar* destination)
-    {
-        memcpy(destination, m_buffer, static_cast<size_t>(m_length) * sizeof(LChar));
-    }
+    void writeTo(LChar* destination);
 
-    void writeTo(UChar* destination)
-    {
-        for (unsigned i = 0; i < m_length; ++i) {
-            unsigned char c = m_buffer[i];
-            destination[i] = c;
-        }
-    }
+    void writeTo(UChar* destination);
 
 private:
     const char* m_buffer;
     unsigned m_length;
 };
 
 template<>
-class StringTypeAdapter<const LChar*> {
+class WTF_EXPORT StringTypeAdapter<const LChar*> {
 public:
-    StringTypeAdapter<const LChar*>(const LChar* buffer)
-        : m_buffer(buffer)
-        , m_length(strlen(reinterpret_cast<const char*>(buffer)))
-    {
-    }
+    StringTypeAdapter<const LChar*>(const LChar* buffer);
 
     unsigned length() { return m_length; }
 
     bool is8Bit() { return true; }
 
-    void writeTo(LChar* destination)
-    {
-        memcpy(destination, m_buffer, static_cast<size_t>(m_length) * sizeof(LChar));
-    }
+    void writeTo(LChar* destination);
 
-    void writeTo(UChar* destination)
-    {
-        StringImpl::copyChars(destination, m_buffer, m_length);
-    }
+    void writeTo(UChar* destination);
 
 private:
     const LChar* m_buffer;
     unsigned m_length;
 };
 
 template<>
-class StringTypeAdapter<Vector<char> > {
+class WTF_EXPORT StringTypeAdapter<Vector<char> > {
 public:
     StringTypeAdapter<Vector<char> >(const Vector<char>& buffer)
         : m_buffer(buffer)
     {
     }
 
     size_t length() { return m_buffer.size(); }
 
     bool is8Bit() { return true; }
 
-    void writeTo(LChar* destination)
-    {
-        for (size_t i = 0; i < m_buffer.size(); ++i)
-            destination[i] = static_cast<unsigned char>(m_buffer[i]);
-    }
+    void writeTo(LChar* destination);
 
-    void writeTo(UChar* destination)
-    {
-        for (size_t i = 0; i < m_buffer.size(); ++i)
-            destination[i] = static_cast<unsigned char>(m_buffer[i]);
-    }
+    void writeTo(UChar* destination);
 
 private:
     const Vector<char>& m_buffer;
 };
 
 template<>
 class StringTypeAdapter<Vector<LChar> > {
 public:
     StringTypeAdapter<Vector<LChar> >(const Vector<LChar>& buffer)
         : m_buffer(buffer)
     {
     }
 
     size_t length() { return m_buffer.size(); }
 
     bool is8Bit() { return true; }
 
-    void writeTo(LChar* destination)
-    {
-        for (size_t i = 0; i < m_buffer.size(); ++i)
-            destination[i] = m_buffer[i];
-    }
+    void writeTo(LChar* destination);
 
-    void writeTo(UChar* destination)
-    {
-        for (size_t i = 0; i < m_buffer.size(); ++i)
-            destination[i] = m_buffer[i];
-    }
+    void writeTo(UChar* destination);
 
 private:
     const Vector<LChar>& m_buffer;
 };
 
 template<>
-class StringTypeAdapter<String> {
+class WTF_EXPORT StringTypeAdapter<String> {
 public:
     StringTypeAdapter<String>(const String& string)
         : m_buffer(string)
     {
     }
 
     unsigned length() { return m_buffer.length(); }
 
     bool is8Bit() { return m_buffer.isNull() || m_buffer.is8Bit(); }
 
-    void writeTo(LChar* destination)
-    {
-        unsigned length = m_buffer.length();
+    void writeTo(LChar* destination);
 
-        ASSERT(is8Bit());
-        const LChar* data = m_buffer.characters8();
-        for (unsigned i = 0; i < length; ++i)
-            destination[i] = data[i];
-
-        WTF_STRINGTYPEADAPTER_COPIED_WTF_STRING();

[Nico, 2016/10/01 16:47:29]

FWIW, this made parts of StringOperatorsTest.cpp fairly pointless since that
test redefines the macro before including the header. Not sure what to do about
this; maybe the two functions using the macro should move back to the header?

-    }
-
-    void writeTo(UChar* destination)
-    {
-        unsigned length = m_buffer.length();
-
-        if (is8Bit()) {
-            const LChar* data = m_buffer.characters8();
-            for (unsigned i = 0; i < length; ++i)
-                destination[i] = data[i];
-        } else {
-            const UChar* data = m_buffer.characters16();
-            for (unsigned i = 0; i < length; ++i)
-                destination[i] = data[i];
-        }
-
-        WTF_STRINGTYPEADAPTER_COPIED_WTF_STRING();
-    }
+    void writeTo(UChar* destination);
 
 private:
     const String& m_buffer;
 };
 
 template<>
 class StringTypeAdapter<AtomicString> {
 public:
     StringTypeAdapter<AtomicString>(const AtomicString& string)
         : m_adapter(string.string())
@@ skipping 55 matching lines @@
     result += adapter1.length();
     adapter2.writeTo(result);
 
     return resultImpl.release();
 }
 
 } // namespace WTF
 
 #include "wtf/text/StringOperators.h"
 #endif