Migrate WTF::Deque::remove() to ::erase()

third_party/WebKit/Source/wtf/Deque.h

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 109 matching lines @@
     size_t right = m_buffer.capacity() - m_start;
     return i < right ? m_buffer.buffer()[m_start + i]
                      : m_buffer.buffer()[i - right];
   }
 
   T& operator[](size_t i) { return at(i); }
   const T& operator[](size_t i) const { return at(i); }
 
   template <typename U>
   void prepend(U&&);
-  void remove(iterator&);
-  void remove(const_iterator&);
+  void erase(iterator&);
+  void erase(const_iterator&);
 
   // STL compatibility.
   template <typename U>
   void push_back(U&&);
   template <typename U>
   void push_front(U&& u) {
     prepend(std::forward<U>(u));
   }
   void pop_back();
   void pop_front();
@@ skipping 34 matching lines @@
    public:
     BackingBuffer() : Base() {}
     explicit BackingBuffer(size_t capacity) : Base(capacity) {}
 
     void setSize(size_t size) { m_size = size; }
   };
 
   typedef VectorTypeOperations<T> TypeOperations;
   typedef DequeIteratorBase<T, inlineCapacity, Allocator> IteratorBase;
 
-  void remove(size_t position);
+  void erase(size_t position);
   void destroyAll();
   void expandCapacityIfNeeded();
   void expandCapacity();
 
   BackingBuffer m_buffer;
   unsigned m_start;
   unsigned m_end;
 };
 
 template <typename T, size_t inlineCapacity, typename Allocator>
@@ skipping 361 matching lines @@
     m_end = m_buffer.capacity() - 1;
   else
     --m_end;
   TypeOperations::destruct(&m_buffer.buffer()[m_end],
                            &m_buffer.buffer()[m_end + 1]);
   m_buffer.clearUnusedSlots(&m_buffer.buffer()[m_end],
                             &m_buffer.buffer()[m_end + 1]);
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
-inline void Deque<T, inlineCapacity, Allocator>::remove(iterator& it) {
-  remove(it.m_index);
+inline void Deque<T, inlineCapacity, Allocator>::erase(iterator& it) {
+  erase(it.m_index);
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
-inline void Deque<T, inlineCapacity, Allocator>::remove(const_iterator& it) {
-  remove(it.m_index);
+inline void Deque<T, inlineCapacity, Allocator>::erase(const_iterator& it) {
+  erase(it.m_index);
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
-inline void Deque<T, inlineCapacity, Allocator>::remove(size_t position) {
+inline void Deque<T, inlineCapacity, Allocator>::erase(size_t position) {
   if (position == m_end)
     return;
 
   T* buffer = m_buffer.buffer();
   TypeOperations::destruct(&buffer[position], &buffer[position + 1]);
 
   // Find which segment of the circular buffer contained the remove element,
   // and only move elements in that part.
   if (position >= m_start) {
     TypeOperations::moveOverlapping(buffer + m_start, buffer + position,
@@ skipping 112 matching lines @@
 inline void swap(Deque<T, inlineCapacity, Allocator>& a,
                  Deque<T, inlineCapacity, Allocator>& b) {
   a.swap(b);
 }
 
 }  // namespace WTF
 
 using WTF::Deque;
 
 #endif  // WTF_Deque_h