Replace StringImpl::empty{16Bit}() with a static member

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 10 matching lines @@
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "wtf/text/StringImpl.h"
 
 #include "wtf/DynamicAnnotations.h"
 #include "wtf/LeakAnnotations.h"
 #include "wtf/PtrUtil.h"
+#include "wtf/StaticConstructors.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/allocator/Partitions.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/AtomicStringTable.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/StringToNumber.h"
 #include <algorithm>
@@ skipping 296 matching lines @@
 std::string StringImpl::asciiForDebugging() const {
   CString ascii = String(isolatedCopy()->substring(0, 128)).ascii();
   return std::string(ascii.data(), ascii.length());
 }
 #endif
 
 PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length,
                                                        LChar*& data) {
   if (!length) {
     data = 0;
-    return empty();
+    return empty;
   }
 
   // Allocate a single buffer large enough to contain the StringImpl
   // struct as well as the data which it contains. This removes one
   // heap allocation from this call.
   StringImpl* string = static_cast<StringImpl*>(Partitions::bufferMalloc(
       allocationSize<LChar>(length), "WTF::StringImpl"));
 
   data = reinterpret_cast<LChar*>(string + 1);
   return adoptRef(new (string) StringImpl(length, Force8BitConstructor));
 }
 
 PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length,
                                                        UChar*& data) {
   if (!length) {
     data = 0;
-    return empty();
+    return empty;
   }
 
   // Allocate a single buffer large enough to contain the StringImpl
   // struct as well as the data which it contains. This removes one
   // heap allocation from this call.
   StringImpl* string = static_cast<StringImpl*>(Partitions::bufferMalloc(
       allocationSize<UChar>(length), "WTF::StringImpl"));
 
   data = reinterpret_cast<UChar*>(string + 1);
   return adoptRef(new (string) StringImpl(length));
@@ skipping 15 matching lines @@
 void StringImpl::freezeStaticStrings() {
   DCHECK(isMainThread());
 
 #if DCHECK_IS_ON()
   s_allowCreationOfStaticStrings = false;
 #endif
 }
 
 unsigned StringImpl::m_highestStaticStringLength = 0;
 
+DEFINE_GLOBAL(StringImpl, globalEmpty);
+DEFINE_GLOBAL(StringImpl, globalEmpty16Bit);
+// Callers need the global empty strings to be non-const.
+StringImpl* StringImpl::empty = const_cast<StringImpl*>(&globalEmpty);
+StringImpl* StringImpl::empty16Bit = const_cast<StringImpl*>(&globalEmpty16Bit);
+void StringImpl::initStatics() {
+  new ((void*)empty) StringImpl(ConstructEmptyString);
+  new ((void*)empty16Bit) StringImpl(ConstructEmptyString16Bit);
+}
+
 StringImpl* StringImpl::createStatic(const char* string,
                                      unsigned length,
                                      unsigned hash) {
 #if DCHECK_IS_ON()
   DCHECK(s_allowCreationOfStaticStrings);
 #endif
   DCHECK(string);
   DCHECK(length);
 
   StaticStringsTable::const_iterator it = staticStrings().find(hash);
@@ skipping 34 matching lines @@
 void StringImpl::reserveStaticStringsCapacityForSize(unsigned size) {
 #if DCHECK_IS_ON()
   DCHECK(s_allowCreationOfStaticStrings);
 #endif
   staticStrings().reserveCapacityForSize(size);
 }
 
 PassRefPtr<StringImpl> StringImpl::create(const UChar* characters,
                                           unsigned length) {
   if (!characters || !length)
-    return empty();
+    return empty;
 
   UChar* data;
   RefPtr<StringImpl> string = createUninitialized(length, data);
   memcpy(data, characters, length * sizeof(UChar));
   return string.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::create(const LChar* characters,
                                           unsigned length) {
   if (!characters || !length)
-    return empty();
+    return empty;
 
   LChar* data;
   RefPtr<StringImpl> string = createUninitialized(length, data);
   memcpy(data, characters, length * sizeof(LChar));
   return string.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::create8BitIfPossible(const UChar* characters,
                                                         unsigned length) {
   if (!characters || !length)
-    return empty();
+    return empty;
 
   LChar* data;
   RefPtr<StringImpl> string = createUninitialized(length, data);
 
   for (size_t i = 0; i < length; ++i) {
     if (characters[i] & 0xff00)
       return create(characters, length);
     data[i] = static_cast<LChar>(characters[i]);
   }
 
   return string.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::create(const LChar* string) {
   if (!string)
-    return empty();
+    return empty;
   size_t length = strlen(reinterpret_cast<const char*>(string));
   RELEASE_ASSERT(length <= numeric_limits<unsigned>::max());
   return create(string, length);
 }
 
 bool StringImpl::containsOnlyWhitespace() {
   // FIXME: The definition of whitespace here includes a number of characters
   // that are not whitespace from the point of view of LayoutText; I wonder if
   // that's a problem in practice.
   if (is8Bit()) {
@@ skipping 10 matching lines @@
     UChar c = characters16()[i];
     if (!isASCIISpace(c))
       return false;
   }
   return true;
 }
 
 PassRefPtr<StringImpl> StringImpl::substring(unsigned start,
                                              unsigned length) const {
   if (start >= m_length)
-    return empty();
+    return empty;
   unsigned maxLength = m_length - start;
   if (length >= maxLength) {
     // PassRefPtr has trouble dealing with const arguments. It should be updated
     // so this const_cast is not necessary.
     if (!start)
       return const_cast<StringImpl*>(this);
     length = maxLength;
   }
   if (is8Bit())
     return create(characters8() + start, length);
@@ skipping 418 matching lines @@
     return this;
   if (is8Bit())
     return create(characters8(), length);
   return create(characters16(), length);
 }
 
 template <class UCharPredicate>
 inline PassRefPtr<StringImpl> StringImpl::stripMatchedCharacters(
     UCharPredicate predicate) {
   if (!m_length)
-    return empty();
+    return empty;
 
   unsigned start = 0;
   unsigned end = m_length - 1;
 
   // skip white space from start
   while (start <= end &&
          predicate(is8Bit() ? characters8()[start] : characters16()[start]))
     ++start;
 
   // only white space
   if (start > end)
-    return empty();
+    return empty;
 
   // skip white space from end
   while (end && predicate(is8Bit() ? characters8()[end] : characters16()[end]))
     --end;
 
   if (!start && end == m_length - 1)
     return this;
   if (is8Bit())
     return create(characters8() + start, end + 1 - start);
   return create(characters16() + start, end + 1 - start);
@@ skipping 1211 matching lines @@
     } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
       // TODO(rob.buis) implement upper-casing rules for lt
       // like in StringImpl::upper(locale).
     }
   }
 
   return toUpper(c);
 }
 
 }  // namespace WTF