Fix some m_instVar instances in wtf/

third_party/WebKit/Source/platform/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * 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 34 matching lines @@
 #include <type_traits>
 #endif
 
 #if DUMP_HASHTABLE_STATS
 #if DUMP_HASHTABLE_STATS_PER_TABLE
 
 #define UPDATE_PROBE_COUNTS()                                    \
   ++probeCount;                                                  \
   HashTableStats::instance().recordCollisionAtCount(probeCount); \
   ++perTableProbeCount;                                          \
-  m_stats->recordCollisionAtCount(perTableProbeCount)
+  stats_->recordCollisionAtCount(perTableProbeCount)
 #define UPDATE_ACCESS_COUNTS()                              \
   atomicIncrement(&HashTableStats::instance().numAccesses); \
   int probeCount = 0;                                       \
-  ++m_stats->numAccesses;                                   \
+  ++stats_->numAccesses;                                    \
   int perTableProbeCount = 0
 #else
 #define UPDATE_PROBE_COUNTS() \
   ++probeCount;               \
   HashTableStats::instance().recordCollisionAtCount(probeCount)
 #define UPDATE_ACCESS_COUNTS()                              \
   atomicIncrement(&HashTableStats::instance().numAccesses); \
   int probeCount = 0
 #endif
 #else
 #if DUMP_HASHTABLE_STATS_PER_TABLE
 #define UPDATE_PROBE_COUNTS() \
   ++perTableProbeCount;       \
-  m_stats->recordCollisionAtCount(perTableProbeCount)
+  stats_->recordCollisionAtCount(perTableProbeCount)
 #define UPDATE_ACCESS_COUNTS() \
-  ++m_stats->numAccesses;      \
+  ++stats_->numAccesses;       \
   int perTableProbeCount = 0
 #else
 #define UPDATE_PROBE_COUNTS() \
   do {                        \
   } while (0)
 #define UPDATE_ACCESS_COUNTS() \
   do {                         \
   } while (0)
 #endif
 #endif
@@ skipping 278 matching lines @@
   bool operator==(const iterator& other) const {
     return *this == static_cast<const_iterator>(other);
   }
   bool operator!=(const iterator& other) const {
     return *this != static_cast<const_iterator>(other);
   }
 
   std::ostream& PrintTo(std::ostream& stream) const {
     if (position_ == end_position_)
       return stream << "iterator representing <end>";
-    // TODO(tkent): Change |m_position| to |*m_position| to show the
+    // TODO(tkent): Change |position_| to |*position_| to show the
     // pointed object. It requires a lot of new stream printer functions.
     return stream << "iterator pointing to " << position_;
   }
 
  private:
   PointerType position_;
   PointerType end_position_;
 #if DCHECK_IS_ON()
   const HashTableType* container_;
   int64_t container_modifications_;
@@ skipping 513 matching lines @@
 #else
   unsigned deleted_count_ : 31;
   unsigned queue_flag_ : 1;
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
  public:
   mutable
       typename std::conditional<Allocator::isGarbageCollected,
                                 HashTableStats*,
-                                std::unique_ptr<HashTableStats>>::type m_stats;
+                                std::unique_ptr<HashTableStats>>::type stats_;
 #endif
 
   template <WeakHandlingFlag x,
             typename T,
             typename U,
             typename V,
             typename W,
             typename X,
             typename Y,
             typename Z>
@@ skipping 21 matching lines @@
       key_count_(0),
       deleted_count_(0),
       queue_flag_(false)
 #if DCHECK_IS_ON()
       ,
       access_forbidden_(false),
       modifications_(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
-      m_stats(nullptr)
+      stats_(nullptr)
 #endif
 {
   static_assert(Allocator::kIsGarbageCollected ||
                     (!IsPointerToGarbageCollectedType<Key>::value &&
                      !IsPointerToGarbageCollectedType<Value>::value),
                 "Cannot put raw pointers to garbage-collected classes into an "
                 "off-heap collection.");
 }
 
 inline unsigned DoubleHash(unsigned key) {
@@ skipping 410 matching lines @@
     Reinsert(ValueType&& entry) {
   DCHECK(table_);
   RegisterModification();
   DCHECK(!LookupForWriting(Extractor::Extract(entry)).second);
   DCHECK(
       !IsDeletedBucket(*(LookupForWriting(Extractor::Extract(entry)).first)));
 #if DUMP_HASHTABLE_STATS
   atomicIncrement(&HashTableStats::instance().numReinserts);
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-  ++m_stats->numReinserts;
+  ++stats_->numReinserts;
 #endif
   Value* new_entry = LookupForWriting(Extractor::Extract(entry)).first;
   Mover<ValueType, Allocator,
         Traits::template NeedsToForbidGCOnMove<>::value>::Move(std::move(entry),
                                                                *new_entry);
 
   return new_entry;
 }
 
 template <typename Key,
@@ skipping 74 matching lines @@
                Extractor,
                HashFunctions,
                Traits,
                KeyTraits,
                Allocator>::erase(ValueType* pos) {
   RegisterModification();
 #if DUMP_HASHTABLE_STATS
   atomicIncrement(&HashTableStats::instance().numRemoves);
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-  ++m_stats->numRemoves;
+  ++stats_->numRemoves;
 #endif
 
   EnterAccessForbiddenScope();
   DeleteBucket(*pos);
   LeaveAccessForbiddenScope();
   ++deleted_count_;
   --key_count_;
 
   if (ShouldShrink())
     Shrink();
@@ skipping 214 matching lines @@
   unsigned old_table_size = table_size_;
   ValueType* old_table = table_;
 
 #if DUMP_HASHTABLE_STATS
   if (oldTableSize != 0)
     atomicIncrement(&HashTableStats::instance().numRehashes);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   if (oldTableSize != 0)
-    ++m_stats->numRehashes;
+    ++stats_->numRehashes;
 #endif
 
   table_ = new_table;
   table_size_ = new_table_size;
 
   Value* new_entry = nullptr;
   for (unsigned i = 0; i != old_table_size; ++i) {
     if (IsEmptyOrDeletedBucket(old_table[i])) {
       DCHECK_NE(&old_table[i], entry);
       continue;
     }
     Value* reinserted_entry = Reinsert(std::move(old_table[i]));
     if (&old_table[i] == entry) {
       DCHECK(!new_entry);
       new_entry = reinserted_entry;
     }
   }
 
   deleted_count_ = 0;
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-  if (!m_stats)
-    m_stats = HashTableStatsPtr<Allocator>::create();
+  if (!stats_)
+    stats_ = HashTableStatsPtr<Allocator>::create();
 #endif
 
   return new_entry;
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 Value*
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     Rehash(unsigned new_table_size, Value* entry) {
   unsigned old_table_size = table_size_;
   ValueType* old_table = table_;
 
 #if DUMP_HASHTABLE_STATS
   if (oldTableSize != 0)
     atomicIncrement(&HashTableStats::instance().numRehashes);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   if (oldTableSize != 0)
-    ++m_stats->numRehashes;
+    ++stats_->numRehashes;
 #endif
 
   // The Allocator::isGarbageCollected check is not needed.  The check is just
   // a static hint for a compiler to indicate that Base::expandBuffer returns
   // false if Allocator is a PartitionAllocator.
   if (Allocator::kIsGarbageCollected && new_table_size > old_table_size) {
     bool success;
     Value* new_entry = ExpandBuffer(new_table_size, entry, success);
     if (success)
       return new_entry;
@@ skipping 49 matching lines @@
       key_count_(0),
       deleted_count_(0),
       queue_flag_(false)
 #if DCHECK_IS_ON()
       ,
       access_forbidden_(false),
       modifications_(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
-      m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
+      stats_(HashTableStatsPtr<Allocator>::copy(other.stats_))
 #endif
 {
   if (other.size())
     ReserveCapacityForSize(other.size());
   // Copy the hash table the dumb way, by adding each element to the new
   // table.  It might be more efficient to copy the table slots, but it's not
   // clear that efficiency is needed.
   for (const auto& element : other)
     insert(element);
 }
@@ skipping 12 matching lines @@
       key_count_(0),
       deleted_count_(0),
       queue_flag_(false)
 #if DCHECK_IS_ON()
       ,
       access_forbidden_(false),
       modifications_(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
-      m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
+      stats_(HashTableStatsPtr<Allocator>::copy(other.stats_))
 #endif
 {
   swap(other);
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
@@ skipping 15 matching lines @@
   deleted_count_ = other.deleted_count_;
   other.deleted_count_ = deleted;
   DCHECK(!queue_flag_);
   DCHECK(!other.queue_flag_);
 
 #if DCHECK_IS_ON()
   std::swap(modifications_, other.modifications_);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-  HashTableStatsPtr<Allocator>::swap(m_stats, other.m_stats);
+  HashTableStatsPtr<Allocator>::swap(stats_, other.stats_);
 #endif
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
@@ skipping 147 matching lines @@
           typename Allocator>
 template <typename VisitorDispatcher>
 void HashTable<Key,
                Value,
                Extractor,
                HashFunctions,
                Traits,
                KeyTraits,
                Allocator>::Trace(VisitorDispatcher visitor) {
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-  Allocator::markNoTracing(visitor, m_stats);
+  Allocator::markNoTracing(visitor, stats_);
 #endif
 
   // If someone else already marked the backing and queued up the trace and/or
   // weak callback then we are done. This optimization does not happen for
   // ListHashSet since its iterator does not point at the backing.
   if (!table_ || Allocator::IsHeapObjectAlive(table_))
     return;
 
   // Normally, we mark the backing store without performing trace. This means
   // it is marked live, but the pointers inside it are not marked.  Instead we
@@ skipping 197 matching lines @@
   CollectionIterator end(to_be_removed.end());
   for (CollectionIterator it(to_be_removed.begin()); it != end; ++it)
     collection.erase(*it);
 }
 
 }  // namespace WTF
 
 #include "platform/wtf/HashIterators.h"
 
 #endif  // WTF_HashTable_h