[turbofan] Remove usage of Unique<T> from graph.

src/handles.h

 // Copyright 2011 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_HANDLES_H_
 #define V8_HANDLES_H_
 
 #include "include/v8.h"
+#include "src/base/functional.h"
 #include "src/base/macros.h"
 #include "src/checks.h"
 #include "src/globals.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class DeferredHandles;
 class HandleScopeImplementer;
@@ skipping 92 matching lines @@
   template <typename S>
   static const Handle<T> cast(Handle<S> that) {
     T::cast(*reinterpret_cast<T**>(that.location_));
     return Handle<T>(reinterpret_cast<T**>(that.location_));
   }
 
   // TODO(yangguo): Values that contain empty handles should be declared as
   // MaybeHandle to force validation before being used as handles.
   static const Handle<T> null() { return Handle<T>(); }
 
+  // Provide function object for location equality comparison.
+  struct equal_to : public std::binary_function<Handle<T>, Handle<T>, bool> {
+    V8_INLINE bool operator()(Handle<T> lhs, Handle<T> rhs) const {
+      return lhs.location() == rhs.location();
+    }
+  };
+
+  // Provide function object for location hashing.
+  struct hash : public std::unary_function<Handle<T>, size_t> {
+    V8_INLINE size_t operator()(Handle<T> const& handle) const {
+      return base::hash<void*>()(handle.location());
+    }
+  };
+
  private:
   // Handles of different classes are allowed to access each other's location_.
   template <typename>
   friend class Handle;
   // MaybeHandle is allowed to access location_.
   template <typename>
   friend class MaybeHandle;
 };
 
 template <typename T>
@@ skipping 217 matching lines @@
   void Initialize() {
     next = limit = NULL;
     level = 0;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HANDLES_H_