De-generify the GenericGraph.

src/compiler/generic-node.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_GENERIC_NODE_H_
 #define V8_COMPILER_GENERIC_NODE_H_
 
 #include "src/v8.h"
 
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-class GenericGraphBase;
+class Graph;
 
 typedef int NodeId;
 
 // A GenericNode<> is the basic primitive of graphs. GenericNode's are
 // chained together by input/use chains but by default otherwise contain only an
 // identifying number which specific applications of graphs and nodes can use
 // to index auxiliary out-of-line data, especially transient data.
 // Specializations of the templatized GenericNode<> class must provide a base
 // class B that contains all of the members to be made available in each
 // specialized Node instance. GenericNode uses a mixin template pattern to
@@ skipping 58 matching lines @@
    private:
     GenericNode* node_;
   };
 
   Uses uses() { return Uses(this); }
 
   class Edge;
 
   bool OwnedBy(GenericNode* owner) const;
 
-  static S* New(GenericGraphBase* graph, int input_count, S** inputs,
+  static S* New(Graph* graph, int input_count, S** inputs,
                 bool has_extensible_inputs);
 
  protected:
-  friend class GenericGraphBase;
+  friend class Graph;
 
   class Use : public ZoneObject {
    public:
     GenericNode* from;
     Use* next;
     Use* prev;
     int input_index;
   };
 
   class Input {
@@ skipping 12 matching lines @@
     } else {
       return inputs_.static_ + index;
     }
   }
 
   inline void AppendUse(Use* use);
   inline void RemoveUse(Use* use);
 
   void* operator new(size_t, void* location) { return location; }
 
-  GenericNode(GenericGraphBase* graph, int input_count,
-              int reserved_input_count);
+  GenericNode(Graph* graph, int input_count, int reserved_input_count);
 
  private:
-  void AssignUniqueID(GenericGraphBase* graph);
+  void AssignUniqueID(Graph* graph);
 
   typedef ZoneDeque<Input> InputDeque;
 
   static const int kReservedInputCountBits = 2;
   static const int kMaxReservedInputs = (1 << kReservedInputCountBits) - 1;
   static const int kDefaultReservedInputs = kMaxReservedInputs;
 
   NodeId id_;
   int input_count_ : 29;
   unsigned int reserve_input_count_ : kReservedInputCountBits;
@@ skipping 123 matching lines @@
   }
 
   typename GenericNode<B, S>::Use* current_;
   int index_;
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_GENERIC_NODE_H_