Migrate WTF::Deque::removeLast() to ::pop_back()

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 112 matching lines @@
   }
 
   T& operator[](size_t i) { return at(i); }
   const T& operator[](size_t i) const { return at(i); }
 
   template <typename U>
   void append(U&&);
   template <typename U>
   void prepend(U&&);
   void removeFirst();
-  void removeLast();
   void remove(iterator&);
   void remove(const_iterator&);
 
   // STL compatibility.
   template <typename U>
   void push_back(U&& u) {
     append(std::forward<U>(u));
   }
   template <typename U>
   void push_front(U&& u) {
     prepend(std::forward<U>(u));
   }
-  void pop_back() { removeLast(); }
+  void pop_back();
   void pop_front() { removeFirst(); }
   bool empty() const { return isEmpty(); }
   T& front() { return first(); }
   const T& front() const { return first(); }
   T& back() { return last(); }
   const T& back() const { return last(); }
   template <typename... Args>
   void emplace_back(Args&&...);
   template <typename... Args>
   void emplace_front(Args&&...);
@@ skipping 334 matching lines @@
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline T Deque<T, inlineCapacity, Allocator>::takeFirst() {
   T oldFirst = std::move(first());
   removeFirst();
   return oldFirst;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline T Deque<T, inlineCapacity, Allocator>::takeLast() {
   T oldLast = std::move(last());
-  removeLast();
+  pop_back();
   return oldLast;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 inline void Deque<T, inlineCapacity, Allocator>::append(U&& value) {
   expandCapacityIfNeeded();
   T* newElement = &m_buffer.buffer()[m_end];
   if (m_end == m_buffer.capacity() - 1)
     m_end = 0;
@@ skipping 43 matching lines @@
                            &m_buffer.buffer()[m_start + 1]);
   m_buffer.clearUnusedSlots(&m_buffer.buffer()[m_start],
                             &m_buffer.buffer()[m_start + 1]);
   if (m_start == m_buffer.capacity() - 1)
     m_start = 0;
   else
     ++m_start;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
-inline void Deque<T, inlineCapacity, Allocator>::removeLast() {
+inline void Deque<T, inlineCapacity, Allocator>::pop_back() {
   DCHECK(!isEmpty());
   if (!m_end)
     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]);
 }
@@ skipping 135 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