De-generify the GenericGraph.

src/compiler/generic-node-inl.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_INL_H_
 #define V8_COMPILER_GENERIC_NODE_INL_H_
 
 #include "src/v8.h"
 
-#include "src/compiler/generic-graph.h"
 #include "src/compiler/generic-node.h"
+#include "src/compiler/graph.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 template <class B, class S>
-GenericNode<B, S>::GenericNode(GenericGraphBase* graph, int input_count,
+GenericNode<B, S>::GenericNode(Graph* graph, int input_count,
                                int reserve_input_count)
     : BaseClass(graph->zone()),
       input_count_(input_count),
       reserve_input_count_(reserve_input_count),
       has_appendable_inputs_(false),
       use_count_(0),
       first_use_(NULL),
       last_use_(NULL) {
   DCHECK(reserve_input_count <= kMaxReservedInputs);
   inputs_.static_ = reinterpret_cast<Input*>(this + 1);
   AssignUniqueID(graph);
 }
 
 template <class B, class S>
-inline void GenericNode<B, S>::AssignUniqueID(GenericGraphBase* graph) {
+inline void GenericNode<B, S>::AssignUniqueID(Graph* graph) {
   id_ = graph->NextNodeID();
 }
 
 template <class B, class S>
 inline typename GenericNode<B, S>::Inputs::iterator
 GenericNode<B, S>::Inputs::begin() {
   return typename GenericNode<B, S>::Inputs::iterator(this->node_, 0);
 }
 
 template <class B, class S>
@@ skipping 181 matching lines @@
   --use_count_;
 }
 
 template <class B, class S>
 inline bool GenericNode<B, S>::OwnedBy(GenericNode* owner) const {
   return first_use_ != NULL && first_use_->from == owner &&
          first_use_->next == NULL;
 }
 
 template <class B, class S>
-S* GenericNode<B, S>::New(GenericGraphBase* graph, int input_count, S** inputs,
+S* GenericNode<B, S>::New(Graph* graph, int input_count, S** inputs,
                           bool has_extensible_inputs) {
   size_t node_size = sizeof(GenericNode);
   int reserve_input_count = has_extensible_inputs ? kDefaultReservedInputs : 0;
   size_t inputs_size = (input_count + reserve_input_count) * sizeof(Input);
   size_t uses_size = input_count * sizeof(Use);
   int size = static_cast<int>(node_size + inputs_size + uses_size);
   Zone* zone = graph->zone();
   void* buffer = zone->New(size);
   S* result = new (buffer) S(graph, input_count, reserve_input_count);
   Input* input =
@@ skipping 11 matching lines @@
     ++use;
     ++input;
   }
   return result;
 }
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_GENERIC_NODE_INL_H_