Add initial prototype for the GN meta-buildsystem.

tools/gn/item_node.h

Index: tools/gn/item_node.h
diff --git a/tools/gn/item_node.h b/tools/gn/item_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..297010f2f7399a04dc8fbde64cbc20484ccee3d9
--- /dev/null
+++ b/tools/gn/item_node.h
@@ -0,0 +1,119 @@
+// Copyright (c) 2013 The Chromium 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 TOOLS_GN_ITEM_NODE_H_
+#define TOOLS_GN_ITEM_NODE_H_
+
+#include <set>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/location.h"
+
+class Item;
+
+// Represents a node in the depdency tree. It references an Item which is
+// the actual thing.
+//
+// The items and nodes are split apart so that the ItemTree can manipulate
+// the dependencies one one thread while the Item itself is been modified on
+// another.
+class ItemNode {
+ public:
+  enum State {
+    // Another item has referenced this one by name, but we have not yet
+    // encountered this item to know what it is.
+    REFERENCED,
+
+    // This item has been defined but some of the dependencies it references
+    // have not been.
+    GENERATED,
+
+    // All of this item's transitive dependencies have been found and
+    // resolved.
+    RESOLVED,
+  };
+
+  typedef std::set<ItemNode*> ItemNodeSet;
+
+  // Takes ownership of the pointer.
+  // Initial state will be REFERENCED.
+  ItemNode(Item* i);
+  ~ItemNode();
+
+  State state() const { return state_; }
+
+  // This closure will be executed when the item is resolved.
+  void set_resolved_closure(const base::Closure& closure) {
+    resolved_closure_ = closure;
+  }
+
+  const Item* item() const { return item_.get(); }
+  Item* item() { return item_.get(); }
+
+  // Where this was created from, which might be when it was generated or
+  // when it was first referenced from another target.
+  const LocationRange& originally_referenced_from_here() const {
+    return originally_referenced_from_here_;
+  }
+  void set_originally_referenced_from_here(const LocationRange& r) {
+    originally_referenced_from_here_ = r;
+  }
+
+  // Where this was generated from. This will be empty for items that have
+  // been referenced but not generated. Note that this has to be one the
+  // ItemNode because it can be changing from multiple threads and we need
+  // to be sure that access is serialized.
+  const LocationRange& generated_from_here() const {
+    return generated_from_here_;
+  }
+  void set_generated_from_here(const LocationRange& r) {
+    generated_from_here_ = r;
+  }
+
+  const ItemNodeSet& direct_dependencies() const {
+    return direct_dependencies_;
+  }
+  const ItemNodeSet& unresolved_dependencies() const {
+    return unresolved_dependencies_;
+  }
+
+  void AddDependency(ItemNode* node);
+
+  // Removes the given dependency from the unresolved list. Does not do
+  // anything else to update waiters.
+  void MarkDirectDependencyResolved(ItemNode* node);
+
+  // Destructively retrieve the set of waiting nodes.
+  void SwapOutWaitingDependencySet(ItemNodeSet* out_set);
+
+  void SetGenerated();
+  void SetResolved();
+
+ private:
+  State state_;
+  scoped_ptr<Item> item_;
+
+  LocationRange originally_referenced_from_here_;
+  LocationRange generated_from_here_;
+
+  // What to run when this item is resolved.
+  base::Closure resolved_closure_;
+
+  // Everything this item directly depends on.
+  ItemNodeSet direct_dependencies_;
+
+  // Unresolved things this item directly depends on.
+  ItemNodeSet unresolved_dependencies_;
+
+  // These items are waiting on us to be resolved before they can be
+  // resolved. This is the backpointer for unresolved_dependencies_.
+  ItemNodeSet waiting_on_resolution_;
+
+  DISALLOW_COPY_AND_ASSIGN(ItemNode);
+};
+
+#endif  // TOOLS_GN_ITEM_NODE_H_