Reland "[heap] Optimize ArrayBuffer tracking"

src/heap/array-buffer-tracker.h

 // Copyright 2015 the V8 project 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 V8_HEAP_ARRAY_BUFFER_TRACKER_H_
 #define V8_HEAP_ARRAY_BUFFER_TRACKER_H_
 
-#include <unordered_map>
+#include <unordered_set>
 
 #include "src/allocation.h"
 #include "src/base/platform/mutex.h"
 #include "src/globals.h"
 
 namespace v8 {
 namespace internal {
 
 class Heap;
 class JSArrayBuffer;
@@ skipping 33 matching lines @@
 
   // Returns whether a buffer is currently tracked.
   static bool IsTracked(JSArrayBuffer* buffer);
 };
 
 // LocalArrayBufferTracker tracks internalized array buffers.
 //
 // Never use directly but instead always call through |ArrayBufferTracker|.
 class LocalArrayBufferTracker {
  public:
-  typedef std::pair<void*, size_t> Value;
   typedef JSArrayBuffer* Key;
 
   enum CallbackResult { kKeepEntry, kUpdateEntry, kRemoveEntry };
   enum FreeMode { kFreeDead, kFreeAll };
 
   explicit LocalArrayBufferTracker(Heap* heap) : heap_(heap) {}
   ~LocalArrayBufferTracker();
 
-  inline void Add(Key key, const Value& value);
-  inline Value Remove(Key key);
+  inline void Add(Key key);
+  inline void Remove(Key key);
 
   // Frees up array buffers determined by |free_mode|.
   template <FreeMode free_mode>
   void Free();
 
   // Processes buffers one by one. The CallbackResult of the callback decides
   // what action to take on the buffer.
   //
   // Callback should be of type:
   //   CallbackResult fn(JSArrayBuffer* buffer, JSArrayBuffer** new_buffer);
   template <typename Callback>
-  inline void Process(Callback callback);
+  void Process(Callback callback);
 
   bool IsEmpty() { return array_buffers_.empty(); }
 
   bool IsTracked(Key key) {
     return array_buffers_.find(key) != array_buffers_.end();
   }
 
  private:
-  typedef std::unordered_map<Key, Value> TrackingMap;
+  typedef std::unordered_set<Key> TrackingData;
 
   Heap* heap_;
-  TrackingMap array_buffers_;
+  TrackingData array_buffers_;
 };
 
 }  // namespace internal
 }  // namespace v8
 #endif  // V8_HEAP_ARRAY_BUFFER_TRACKER_H_