Add WTF::String::emptyString16Bit

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 123 matching lines @@
         , m_is8Bit(true)
         , m_isStatic(true)
     {
         // Ensure that the hash is computed so that AtomicStringHash can call existingHash()
         // with impunity. The empty string is special because it is never entered into
         // AtomicString's HashKey, but still needs to compare correctly.
         STRING_STATS_ADD_8BIT_STRING(m_length);
         hash();
     }
 
+    enum ConstructEmptyString16BitTag { ConstructEmptyString16Bit };
+    explicit StringImpl(ConstructEmptyString16BitTag)
+        : m_refCount(1)
+        , m_length(0)
+        , m_hash(0)
+        , m_isAtomic(false)
+        , m_is8Bit(false)
+        , m_isStatic(true)
+    {
+        STRING_STATS_ADD_16BIT_STRING(m_length);
+        hash();
+    }
+
     // FIXME: there has to be a less hacky way to do this.
     enum Force8Bit { Force8BitConstructor };
     StringImpl(unsigned length, Force8Bit)
         : m_refCount(1)
         , m_length(length)
         , m_hash(0)
         , m_isAtomic(false)
         , m_is8Bit(true)
         , m_isStatic(false)
     {
@@ skipping 130 matching lines @@
     {
         if (hasOneRef()) {
             destroyIfNotStatic();
             return;
         }
 
         --m_refCount;
     }
 
     static StringImpl* empty();
+    static StringImpl* empty16Bit();
 
     // FIXME: Does this really belong in StringImpl?
     template <typename T> static void copyChars(T* destination, const T* source, unsigned numCharacters)
     {
         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)
@@ skipping 427 matching lines @@
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif