Fix some m_instVar instances in wtf/

third_party/WebKit/Source/platform/heap/ThreadState.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 72 matching lines @@
 // HeapHashMap<WeakMember<Foo>, std::unique_ptr<Disposer>> idiom usages with the
 // pre-finalizer if the replacement won't cause performance regressions.
 //
 // Usage:
 //
 // class Foo : GarbageCollected<Foo> {
 //     USING_PRE_FINALIZER(Foo, dispose);
 // private:
 //     void dispose()
 //     {
-//         m_bar->...; // It is safe to touch other on-heap objects.
+//         bar_->...; // It is safe to touch other on-heap objects.
 //     }
-//     Member<Bar> m_bar;
+//     Member<Bar> bar_;
 // };
 #define USING_PRE_FINALIZER(Class, preFinalizer)                           \
  public:                                                                   \
   static bool InvokePreFinalizer(void* object) {                           \
     Class* self = reinterpret_cast<Class*>(object);                        \
     if (ThreadHeap::IsHeapObjectAlive(self))                               \
       return false;                                                        \
     self->Class::preFinalizer();                                           \
     return true;                                                           \
   }                                                                        \
@@ skipping 365 matching lines @@
   // - a vector that meets the condition (*) is allocated on the arena
   //
   //   (*) More than 33% of the same type of vectors have been promptly
   //       freed since the last GC.
   //
   BaseArena* VectorBackingArena(size_t gc_info_index) {
     DCHECK(CheckThread());
     size_t entry_index = gc_info_index & kLikelyToBePromptlyFreedArrayMask;
     --likely_to_be_promptly_freed_[entry_index];
     int arena_index = vector_backing_arena_index_;
-    // If m_likelyToBePromptlyFreed[entryIndex] > 0, that means that
+    // If likely_to_be_promptly_freed_[entryIndex] > 0, that means that
     // more than 33% of vectors of the type have been promptly freed
     // since the last GC.
     if (likely_to_be_promptly_freed_[entry_index] > 0) {
       arena_ages_[arena_index] = ++current_arena_ages_;
       vector_backing_arena_index_ =
           ArenaIndexOfVectorArenaLeastRecentlyExpanded(
               BlinkGC::kVector1ArenaIndex, BlinkGC::kVector4ArenaIndex);
     }
     DCHECK(IsVectorArenaIndex(arena_index));
     return arenas_[arena_index];
@@ skipping 173 matching lines @@
   GarbageCollectedMixinConstructorMarker* gc_mixin_marker_;
 
   bool should_flush_heap_does_not_contain_cache_;
   GCState gc_state_;
 
   using PreFinalizerCallback = bool (*)(void*);
   using PreFinalizer = std::pair<void*, PreFinalizerCallback>;
 
   // Pre-finalizers are called in the reverse order in which they are
   // registered by the constructors (including constructors of Mixin objects)
-  // for an object, by processing the m_orderedPreFinalizers back-to-front.
+  // for an object, by processing the ordered_pre_finalizers_ back-to-front.
   ListHashSet<PreFinalizer> ordered_pre_finalizers_;
 
   v8::Isolate* isolate_;
   void (*trace_dom_wrappers_)(v8::Isolate*, Visitor*);
   void (*invalidate_dead_objects_in_wrappers_marking_deque_)(v8::Isolate*);
   void (*perform_cleanup_)(v8::Isolate*);
 
 #if defined(ADDRESS_SANITIZER)
   void* asan_fake_stack_;
 #endif
 
   // PersistentNodes that are stored in static references;
   // references that either have to be cleared upon the thread
   // detaching from Oilpan and shutting down or references we
   // have to clear before initiating LSan's leak detection.
   HashMap<PersistentNode*, PersistentClearCallback> static_persistents_;
 
 #if defined(LEAK_SANITIZER)
   // Count that controls scoped disabling of persistent registration.
-  size_t m_disabledStaticPersistentsRegistration;
+  size_t disabled_static_persistent_registration_;
 #endif
 
   // Ideally we want to allocate an array of size |gcInfoTableMax| but it will
   // waste memory. Thus we limit the array size to 2^8 and share one entry
   // with multiple types of vectors. This won't be an issue in practice,
   // since there will be less than 2^8 types of objects in common cases.
   static const int kLikelyToBePromptlyFreedArraySize = (1 << 8);
   static const int kLikelyToBePromptlyFreedArrayMask =
       kLikelyToBePromptlyFreedArraySize - 1;
   std::unique_ptr<int[]> likely_to_be_promptly_freed_;
@@ skipping 23 matching lines @@
 class ThreadStateFor<kAnyThread> {
   STATIC_ONLY(ThreadStateFor);
 
  public:
   static ThreadState* GetState() { return ThreadState::Current(); }
 };
 
 }  // namespace blink
 
 #endif  // ThreadState_h