Remove deprecated PrintableUnique.

src/compiler/common-operator.h

 // Copyright 2013 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_COMPILER_COMMON_OPERATOR_H_
 #define V8_COMPILER_COMMON_OPERATOR_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 120 matching lines @@
   Operator* ExternalConstant(ExternalReference value) {
     return new (zone_) Operator1<ExternalReference>(IrOpcode::kExternalConstant,
                                                     Operator::kPure, 0, 1,
                                                     "ExternalConstant", value);
   }
   Operator* NumberConstant(double value) {
     return new (zone_)
         Operator1<double>(IrOpcode::kNumberConstant, Operator::kPure, 0, 1,
                           "NumberConstant", value);
   }
-  Operator* HeapConstant(PrintableUnique<Object> value) {
-    return new (zone_) Operator1<PrintableUnique<Object> >(
+  Operator* HeapConstant(Unique<Object> value) {
+    return new (zone_) Operator1<Unique<Object> >(
         IrOpcode::kHeapConstant, Operator::kPure, 0, 1, "HeapConstant", value);
   }
   Operator* Phi(int arguments) {
     DCHECK(arguments > 0);  // Disallow empty phis.
     return new (zone_) Operator1<int>(IrOpcode::kPhi, Operator::kPure,
                                       arguments, 1, "Phi", arguments);
   }
   Operator* EffectPhi(int arguments) {
     DCHECK(arguments > 0);  // Disallow empty phis.
     return new (zone_) Operator1<int>(IrOpcode::kEffectPhi, Operator::kPure, 0,
@@ skipping 129 matching lines @@
   static inline bool HasValue(const Operator* op) {
     return op->opcode() == IrOpcode::kExternalConstant;
   }
   static inline ExternalReference ValueOf(const Operator* op) {
     CHECK_EQ(IrOpcode::kExternalConstant, op->opcode());
     return OpParameter<ExternalReference>(op);
   }
 };
 
 template <typename T>
-struct CommonOperatorTraits<PrintableUnique<T> > {
+struct CommonOperatorTraits<Unique<T> > {
   static inline bool HasValue(const Operator* op) {
     return op->opcode() == IrOpcode::kHeapConstant;
   }
-  static inline PrintableUnique<T> ValueOf(const Operator* op) {
+  static inline Unique<T> ValueOf(const Operator* op) {
     CHECK_EQ(IrOpcode::kHeapConstant, op->opcode());
-    return OpParameter<PrintableUnique<T> >(op);
+    return OpParameter<Unique<T> >(op);
   }
 };
 
 template <typename T>
 struct CommonOperatorTraits<Handle<T> > {
   static inline bool HasValue(const Operator* op) {
-    return CommonOperatorTraits<PrintableUnique<T> >::HasValue(op);
+    return CommonOperatorTraits<Unique<T> >::HasValue(op);
   }
   static inline Handle<T> ValueOf(const Operator* op) {
-    return CommonOperatorTraits<PrintableUnique<T> >::ValueOf(op).handle();
+    return CommonOperatorTraits<Unique<T> >::ValueOf(op).handle();
   }
 };
 
 
 template <typename T>
 inline T ValueOf(const Operator* op) {
   return CommonOperatorTraits<T>::ValueOf(op);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_COMMON_OPERATOR_H_