Fix some m_instVar instances in wtf/

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

 /*
  * 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 105 matching lines @@
       gc_mixin_marker_(nullptr),
       should_flush_heap_does_not_contain_cache_(false),
       gc_state_(kNoGCScheduled),
       isolate_(nullptr),
       trace_dom_wrappers_(nullptr),
       invalidate_dead_objects_in_wrappers_marking_deque_(nullptr),
 #if defined(ADDRESS_SANITIZER)
       asan_fake_stack_(__asan_get_current_fake_stack()),
 #endif
 #if defined(LEAK_SANITIZER)
-      m_disabledStaticPersistentsRegistration(0),
+      disabled_static_persistent_registration_(0),
 #endif
       allocated_object_size_(0),
       marked_object_size_(0),
       reported_memory_to_v8_(0) {
   DCHECK(CheckThread());
   DCHECK(!**thread_specific_);
   **thread_specific_ = this;
 
   heap_ = WTF::WrapUnique(new ThreadHeap(this));
 
@@ skipping 1078 matching lines @@
   safe_point_stack_copy_.resize(slot_count);
   for (size_t i = 0; i < slot_count; ++i) {
     safe_point_stack_copy_[i] = from[i];
   }
 }
 
 void ThreadState::RegisterStaticPersistentNode(
     PersistentNode* node,
     PersistentClearCallback callback) {
 #if defined(LEAK_SANITIZER)
-  if (m_disabledStaticPersistentsRegistration)
+  if (disabled_static_persistent_registration_)
     return;
 #endif
 
   DCHECK(!static_persistents_.Contains(node));
   static_persistents_.insert(node, callback);
 }
 
 void ThreadState::ReleaseStaticPersistentNodes() {
   HashMap<PersistentNode*, ThreadState::PersistentClearCallback>
       static_persistents;
@@ skipping 10 matching lines @@
   // Do not allow static persistents to be freed before
   // they're all released in releaseStaticPersistentNodes().
   //
   // There's no fundamental reason why this couldn't be supported,
   // but no known use for it.
   DCHECK(!static_persistents_.Contains(persistent_node));
 }
 
 #if defined(LEAK_SANITIZER)
 void ThreadState::enterStaticReferenceRegistrationDisabledScope() {
-  m_disabledStaticPersistentsRegistration++;
+  disabled_static_persistent_registration_++;
 }
 
 void ThreadState::leaveStaticReferenceRegistrationDisabledScope() {
-  DCHECK(m_disabledStaticPersistentsRegistration);
-  m_disabledStaticPersistentsRegistration--;
+  DCHECK(disabled_static_persistent_registration_);
+  disabled_static_persistent_registration_--;
 }
 #endif
 
 void ThreadState::InvokePreFinalizers() {
   DCHECK(CheckThread());
   DCHECK(!SweepForbidden());
   TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
   SweepForbiddenScope sweep_forbidden(this);
   ScriptForbiddenIfMainThreadScope script_forbidden;
@@ skipping 287 matching lines @@
     CollectGarbage(BlinkGC::kNoHeapPointersOnStack, BlinkGC::kGCWithSweep,
                    BlinkGC::kForcedGC);
     size_t live_objects = Heap().HeapStats().MarkedObjectSize();
     if (live_objects == previous_live_objects)
       break;
     previous_live_objects = live_objects;
   }
 }
 
 }  // namespace blink