Removing a bunch of unused platform code.

Source/WTF/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 13 matching lines @@
 #define StringImpl_h
 
 #include <limits.h>
 #include <wtf/ASCIICType.h>
 #include <wtf/Forward.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/StringHasher.h>
 #include <wtf/Vector.h>
 #include <wtf/unicode/Unicode.h>
 
-#if PLATFORM(QT)
-#include <QString>
-#endif
-
 #if USE(CF)
 typedef const struct __CFString * CFStringRef;
 #endif
 
 #ifdef __OBJC__
 @class NSString;
 #endif
 
 #if PLATFORM(BLACKBERRY)
 #include <BlackBerryPlatformString.h>
@@ skipping 98 matching lines @@
     friend struct WTF::UCharBufferTranslator;
     friend class AtomicStringImpl;
     friend class JSC::LLInt::Data;
     friend class JSC::LLIntOffsetsExtractor;
     
 private:
     enum BufferOwnership {
         BufferInternal,
         BufferOwned,
         BufferSubstring,
-#if PLATFORM(QT)
-        BufferAdoptedQString
-#endif
         // NOTE: Adding more ownership types needs to extend m_hashAndFlags as we're at capacity
     };
 
     // Used to construct static strings, which have an special refCount that can never hit zero.
     // This means that the static string will never be destroyed, which is important because
     // static strings will be shared across threads & ref-counted in a non-threadsafe manner.
     enum ConstructStaticStringTag { ConstructStaticString };
     StringImpl(const UChar* characters, unsigned length, ConstructStaticStringTag)
         : m_refCount(s_refCountFlagIsStaticString)
         , m_length(length)
@@ skipping 146 matching lines @@
         // that's exactly the oposite of what we want!), and teh normal hash would
         // lead to lots of conflicts.
         unsigned hash = reinterpret_cast<uintptr_t>(this);
         hash <<= s_flagCount;
         if (!hash)
             hash = 1 << s_flagCount;
         m_hashAndFlags = hash | BufferInternal;
 
         STRING_STATS_ADD_16BIT_STRING(m_length);
     }
-
-#if PLATFORM(QT)
-    // Used to create new strings that adopt an existing QString's data
-    enum ConstructAdoptedQStringTag { ConstructAdoptedQString };
-    StringImpl(QStringData* qStringData, ConstructAdoptedQStringTag)
-        : m_refCount(s_refCountIncrement)
-        , m_length(qStringData->size)
-        , m_data16(0)
-        , m_qStringData(qStringData)
-        , m_hashAndFlags(BufferAdoptedQString)
-    {
-        ASSERT(m_length);
-
-        // We ref the string-data to ensure it will be valid for the lifetime of
-        // this string. We then deref it in the destructor, so that the string
-        // data can eventually be freed.
-        m_qStringData->ref.ref();
-
-        // Now that we have a ref we can safely reference the string data
-        m_data16 = reinterpret_cast_ptr<const UChar*>(qStringData->data());
-        ASSERT(m_data16);
-
-        STRING_STATS_ADD_16BIT_STRING(m_length);
-    }
-#endif
-
 public:
     WTF_EXPORT_STRING_API ~StringImpl();
 
     WTF_EXPORT_STRING_API static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
     WTF_EXPORT_STRING_API static PassRefPtr<StringImpl> create(const LChar*, unsigned length);
     WTF_EXPORT_STRING_API static PassRefPtr<StringImpl> create8BitIfPossible(const UChar*, unsigned length);
     template<size_t inlineCapacity>
     static PassRefPtr<StringImpl> create8BitIfPossible(const Vector<UChar, inlineCapacity>& vector)
     {
         return create8BitIfPossible(vector.data(), vector.size());
@@ skipping 91 matching lines @@
             if (size > std::numeric_limits<unsigned>::max())
                 CRASH();
             return adoptRef(new StringImpl(vector.releaseBuffer(), size));
         }
         return empty();
     }
 
     WTF_EXPORT_STRING_API static PassRefPtr<StringImpl> adopt(StringBuffer<UChar>&);
     WTF_EXPORT_STRING_API static PassRefPtr<StringImpl> adopt(StringBuffer<LChar>&);
 
-#if PLATFORM(QT)
-    static PassRefPtr<StringImpl> adopt(QStringData*);
-#endif
-
     unsigned length() const { return m_length; }
     bool is8Bit() const { return m_hashAndFlags & s_hashFlag8BitBuffer; }
     bool hasInternalBuffer() const { return bufferOwnership() == BufferInternal; }
     bool hasOwnedBuffer() const { return bufferOwnership() == BufferOwned; }
     StringImpl* baseString() const { return bufferOwnership() == BufferSubstring ? m_substringBuffer : 0; }
 
     // FIXME: Remove all unnecessary usages of characters()
     ALWAYS_INLINE const LChar* characters8() const { ASSERT(is8Bit()); return m_data8; }
     ALWAYS_INLINE const UChar* characters16() const { ASSERT(!is8Bit()); return m_data16; }
     ALWAYS_INLINE const UChar* characters() const
@@ skipping 48 matching lines @@
         if (isAtomic)
             m_hashAndFlags |= s_hashFlagIsAtomic;
         else
             m_hashAndFlags &= ~s_hashFlagIsAtomic;
     }
 
 #ifdef STRING_STATS
     bool isSubString() const { return  bufferOwnership() == BufferSubstring; }
 #endif
 
-#if PLATFORM(QT)
-    QStringData* qStringData() { return bufferOwnership() == BufferAdoptedQString ? m_qStringData : 0; }
-#endif
-
 private:
     // The high bits of 'hash' are always empty, but we prefer to store our flags
     // in the low bits because it makes them slightly more efficient to access.
     // So, we shift left and right when setting and getting our hash code.
     void setHash(unsigned hash) const
     {
         ASSERT(!hasHash());
         // Multiple clients assume that StringHasher is the canonical string hash function.
         ASSERT(hash == (is8Bit() ? StringHasher::computeHashAndMaskTop8Bits(m_data8, m_length) : StringHasher::computeHashAndMaskTop8Bits(m_data16, m_length)));
         ASSERT(!(hash & (s_flagMask << (8 * sizeof(hash) - s_flagCount)))); // Verify that enough high bits are empty.
@@ skipping 254 matching lines @@
     unsigned m_refCount;
     unsigned m_length;
     union {
         const LChar* m_data8;
         const UChar* m_data16;
     };
     union {
         void* m_buffer;
         StringImpl* m_substringBuffer;
         mutable UChar* m_copyData16;
-#if PLATFORM(QT)
-        QStringData* m_qStringData;
-#endif
     };
     mutable unsigned m_hashAndFlags;
 };
 
 COMPILE_ASSERT(sizeof(StringImpl) == sizeof(StringImpl::StaticASCIILiteral), StringImpl_should_match_its_StaticASCIILiteral);
 
 #if !ASSERT_DISABLED
 // StringImpls created from StaticASCIILiteral will ASSERT
 // in the generic ValueCheck<T>::checkConsistency
 // as they are not allocated by fastMalloc.
@@ skipping 513 matching lines @@
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif