Fix some m_instVar instances in wtf/

third_party/WebKit/Source/platform/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 51 matching lines @@
   // features.
   kTextCaseUnicodeInsensitive
 };
 
 enum StripBehavior { kStripExtraWhiteSpace, kDoNotStripWhiteSpace };
 
 typedef bool (*CharacterMatchFunctionPtr)(UChar);
 typedef bool (*IsWhiteSpaceFunctionPtr)(UChar);
 typedef HashMap<unsigned, StringImpl*, AlreadyHashed> StaticStringsTable;
 
-// Define STRING_STATS to turn on run time statistics of string sizes and memory
-// usage
-#undef STRING_STATS
-
-#ifdef STRING_STATS
-struct StringStats {
-  inline void add8BitString(unsigned length) {
-    ++m_totalNumberStrings;
-    ++m_number8BitStrings;
-    m_total8BitData += length;
-  }
-
-  inline void add16BitString(unsigned length) {
-    ++m_totalNumberStrings;
-    ++m_number16BitStrings;
-    m_total16BitData += length;
-  }
-
-  void removeString(StringImpl*);
-  void printStats();
-
-  static const unsigned s_printStringStatsFrequency = 5000;
-  static unsigned s_stringRemovesTillPrintStats;
-
-  unsigned m_totalNumberStrings;
-  unsigned m_number8BitStrings;
-  unsigned m_number16BitStrings;
-  unsigned long long m_total8BitData;
-  unsigned long long m_total16BitData;
-};
-
-void addStringForStats(StringImpl*);
-void removeStringForStats(StringImpl*);
-
-#define STRING_STATS_ADD_8BIT_STRING(length)       \
-  StringImpl::stringStats().add8BitString(length); \
-  addStringForStats(this)
-#define STRING_STATS_ADD_16BIT_STRING(length)       \
-  StringImpl::stringStats().add16BitString(length); \
-  addStringForStats(this)
-#define STRING_STATS_REMOVE_STRING(string)        \
-  StringImpl::stringStats().removeString(string); \
-  removeStringForStats(this)
-#else
-#define STRING_STATS_ADD_8BIT_STRING(length) ((void)0)
-#define STRING_STATS_ADD_16BIT_STRING(length) ((void)0)
-#define STRING_STATS_REMOVE_STRING(string) ((void)0)
-#endif
-
 // You can find documentation about this class in this doc:
 // https://docs.google.com/document/d/1kOCUlJdh2WJMJGDf-WoEQhmnjKLaOYRbiHz5TiGJl14/edit?usp=sharing
 class WTF_EXPORT StringImpl {
   WTF_MAKE_NONCOPYABLE(StringImpl);
 
  private:
   // StringImpls are allocated out of the WTF buffer partition.
   void* operator new(size_t);
   void* operator new(size_t, void* ptr) { return ptr; }
   void operator delete(void*);
 
   // 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 ConstructEmptyStringTag { kConstructEmptyString };
   explicit StringImpl(ConstructEmptyStringTag)
       : ref_count_(1),
         length_(0),
         hash_(0),
         contains_only_ascii_(true),
         needs_ascii_check_(false),
         is_atomic_(false),
         is8_bit_(true),
         is_static_(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);
     GetHash();
   }
 
   enum ConstructEmptyString16BitTag { kConstructEmptyString16Bit };
   explicit StringImpl(ConstructEmptyString16BitTag)
       : ref_count_(1),
         length_(0),
         hash_(0),
         contains_only_ascii_(true),
         needs_ascii_check_(false),
         is_atomic_(false),
         is8_bit_(false),
         is_static_(true) {
-    STRING_STATS_ADD_16BIT_STRING(m_length);
     GetHash();
   }
 
   // FIXME: there has to be a less hacky way to do this.
   enum Force8Bit { kForce8BitConstructor };
   StringImpl(unsigned length, Force8Bit)
       : ref_count_(1),
         length_(length),
         hash_(0),
         contains_only_ascii_(!length),
         needs_ascii_check_(static_cast<bool>(length)),
         is_atomic_(false),
         is8_bit_(true),
         is_static_(false) {
     DCHECK(length_);
-    STRING_STATS_ADD_8BIT_STRING(m_length);
   }
 
   StringImpl(unsigned length)
       : ref_count_(1),
         length_(length),
         hash_(0),
         contains_only_ascii_(!length),
         needs_ascii_check_(static_cast<bool>(length)),
         is_atomic_(false),
         is8_bit_(false),
         is_static_(false) {
     DCHECK(length_);
-    STRING_STATS_ADD_16BIT_STRING(m_length);
   }
 
   enum StaticStringTag { kStaticString };
   StringImpl(unsigned length, unsigned hash, StaticStringTag)
       : ref_count_(1),
         length_(length),
         hash_(hash),
         contains_only_ascii_(!length),
         needs_ascii_check_(static_cast<bool>(length)),
         is_atomic_(false),
@@ skipping 269 matching lines @@
                  unsigned start = 0,
                  unsigned length = UINT_MAX) const;
 
 #if OS(MACOSX)
   RetainPtr<CFStringRef> CreateCFString();
 #endif
 #ifdef __OBJC__
   operator NSString*();
 #endif
 
-#ifdef STRING_STATS
-  ALWAYS_INLINE static StringStats& stringStats() { return m_stringStats; }
-#endif
   static const UChar kLatin1CaseFoldTable[256];
 
  private:
   template <typename CharType>
   static size_t AllocationSize(unsigned length) {
     CHECK_LE(length,
              ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) /
               sizeof(CharType)));
     return sizeof(StringImpl) + length * sizeof(CharType);
   }
@@ skipping 12 matching lines @@
                                                           StripBehavior);
   NEVER_INLINE unsigned HashSlowCase() const;
 
   void DestroyIfNotStatic() const;
   void UpdateContainsOnlyASCII() const;
 
 #if DCHECK_IS_ON()
   std::string AsciiForDebugging() const;
 #endif
 
-#ifdef STRING_STATS
-  static StringStats m_stringStats;
-#endif
-
   static unsigned highest_static_string_length_;
 
 #if DCHECK_IS_ON()
   void AssertHashIsCorrect() {
     DCHECK(HasHash());
     DCHECK_EQ(ExistingHash(), StringHasher::ComputeHashAndMaskTop8Bits(
                                   Characters8(), length()));
   }
 #endif
 
@@ skipping 366 matching lines @@
 using WTF::kTextCaseASCIIInsensitive;
 using WTF::kTextCaseUnicodeInsensitive;
 using WTF::kTextCaseSensitive;
 using WTF::TextCaseSensitivity;
 using WTF::Equal;
 using WTF::EqualNonNull;
 using WTF::LengthOfNullTerminatedString;
 using WTF::ReverseFind;
 
 #endif