Fix some m_instVar instances in wtf/

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

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple 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.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 584 matching lines @@
     capacity_ = new_size / sizeof(T);
     return true;
   }
 
   void ResetBufferPointer() {
     buffer_ = InlineBuffer();
     capacity_ = inlineCapacity;
   }
 
   void AllocateBuffer(size_t new_capacity) {
-    // FIXME: This should DCHECK(!m_buffer) to catch misuse/leaks.
+    // FIXME: This should DCHECK(!buffer_) to catch misuse/leaks.
     if (new_capacity > inlineCapacity)
       Base::AllocateBuffer(new_capacity);
     else
       ResetBufferPointer();
   }
 
   void AllocateExpandedBuffer(size_t new_capacity) {
     if (new_capacity > inlineCapacity)
       Base::AllocateExpandedBuffer(new_capacity);
     else
@@ skipping 10 matching lines @@
   // capacity.
   //
   // If the data is in an out-of-line buffer, we can just pass the pointers
   // across the two buffers.  If the data is in an inline buffer, we need to
   // either swap or move each element, depending on whether each slot is
   // occupied or not.
   //
   // Further complication comes from the fact that VectorBuffer is also used as
   // the backing store of a Deque.  Deque allocates the objects like a ring
   // buffer, so there may be a "hole" (unallocated region) in the middle of the
-  // buffer. This function assumes elements in a range [m_buffer, m_buffer +
-  // m_size) are all allocated except for elements within |thisHole|. The same
-  // applies for |other.m_buffer| and |otherHole|.
+  // buffer. This function assumes elements in a range [buffer_, buffer_ +
+  // size_) are all allocated except for elements within |thisHole|. The same
+  // applies for |other.buffer_| and |otherHole|.
   void SwapVectorBuffer(VectorBuffer<T, inlineCapacity, Allocator>& other,
                         OffsetRange this_hole,
                         OffsetRange other_hole) {
     using TypeOperations = VectorTypeOperations<T>;
 
     static_assert(VectorTraits<T>::kCanSwapUsingCopyOrMove,
                   "Cannot swap HeapVectors of TraceWrapperMembers.");
 
     if (Buffer() != InlineBuffer() && other.Buffer() != other.InlineBuffer()) {
       // The easiest case: both buffers are non-inline. We just need to swap the
@@ skipping 216 matching lines @@
 //       a local variable.
 //
 // In this context, pointers or references to an element of a Vector are
 // essentially equivalent to iterators, in that they also become invalid
 // whenever corresponding iterators are invalidated.
 //
 // 2. Inline buffer
 //
 // Vectors may have an _inline buffer_. An inline buffer is a storage area
 // that is contained in the vector itself, along with other metadata like
-// m_size. It is used as a storage space when the vector's elements fit in
+// size_. It is used as a storage space when the vector's elements fit in
 // that space. If the inline buffer becomes full and further space is
 // necessary, an out-of-line buffer is allocated in the heap, and it will
 // take over the role of the inline buffer.
 //
 // The existence of an inline buffer is indicated by non-zero |inlineCapacity|
 // template argument. The value represents the number of elements that can be
 // stored in the inline buffer. Zero |inlineCapacity| means the vector has no
 // inline buffer.
 //
 // An inline buffer increases the size of the Vector instances, and, in trade
@@ skipping 858 matching lines @@
 // vector's capacity is large enough for the append to succeed.
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::UncheckedAppend(
     U&& val) {
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
   // Vectors in ASAN builds don't have inlineCapacity.
   push_back(std::forward<U>(val));
 #else
   DCHECK_LT(size(), capacity());
-  ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
   new (NotNull, end()) T(std::forward<U>(val));
   ++size_;
 #endif
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position,
                                                          U&& val) {
   DCHECK(Allocator::IsAllocationAllowed());
@@ skipping 148 matching lines @@
           visitor, *const_cast<T*>(buffer_entry));
     CheckUnusedSlots(Buffer() + size(), Buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h