Oilpan: Remove unused methods from HeapDeque

Source/platform/heap/HeapAllocator.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef HeapAllocator_h
 #define HeapAllocator_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/TraceTraits.h"
 #include "wtf/Assertions.h"
@@ skipping 390 matching lines @@
     }
 
     HeapDeque(size_t size, const T& val) : Deque<T, inlineCapacity, HeapAllocator>(size, val)
     {
     }
 
     // FIXME: Doesn't work if there is an inline buffer, due to crbug.com/360572
     HeapDeque<T, 0>& operator=(const HeapDeque& other)
     {
         HeapDeque<T> copy(other);
-        swap(copy);
+        Deque<T, inlineCapacity, HeapAllocator>::swap(copy);
         return *this;
     }
 
-    // FIXME: Doesn't work if there is an inline buffer, due to crbug.com/360572
-    void swap(HeapDeque& other)
-    {
-        Deque<T, inlineCapacity, HeapAllocator>::swap(other);
-    }
-
     template<size_t otherCapacity>
     HeapDeque(const HeapDeque<T, otherCapacity>& other)
         : Deque<T, inlineCapacity, HeapAllocator>(other)
     {
     }
-
-    template<typename U>
-    void append(const U& other)
-    {
-        Deque<T, inlineCapacity, HeapAllocator>::append(other);
-    }
 };
 
 template<typename T, size_t i>
 inline void swap(HeapVector<T, i>& a, HeapVector<T, i>& b) { a.swap(b); }
 template<typename T, size_t i>
 inline void swap(HeapDeque<T, i>& a, HeapDeque<T, i>& b) { a.swap(b); }
 template<typename T, typename U, typename V>
 inline void swap(HeapHashSet<T, U, V>& a, HeapHashSet<T, U, V>& b) { a.swap(b); }
 template<typename T, typename U, typename V, typename W, typename X>
 inline void swap(HeapHashMap<T, U, V, W, X>& a, HeapHashMap<T, U, V, W, X>& b) { a.swap(b); }
 template<typename T, size_t i, typename U>
 inline void swap(HeapListHashSet<T, i, U>& a, HeapListHashSet<T, i, U>& b) { a.swap(b); }
 template<typename T, typename U, typename V>
 inline void swap(HeapLinkedHashSet<T, U, V>& a, HeapLinkedHashSet<T, U, V>& b) { a.swap(b); }
 template<typename T, typename U, typename V>
 inline void swap(HeapHashCountedSet<T, U, V>& a, HeapHashCountedSet<T, U, V>& b) { a.swap(b); }
 
 } // namespace blink
 
 #endif