Add GN split_list function

tools/gn/parse_node_value_adapter.h

Index: tools/gn/parse_node_value_adapter.h
diff --git a/tools/gn/parse_node_value_adapter.h b/tools/gn/parse_node_value_adapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f483a9a10cbc7c53de86b4276c006eb23f23fc5
--- /dev/null
+++ b/tools/gn/parse_node_value_adapter.h
@@ -0,0 +1,55 @@
+// Copyright 2016 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_PARSE_NODE_VALUE_ADAPTER_H_
+#define TOOLS_GN_PARSE_NODE_VALUE_ADAPTER_H_
+
+#include "base/macros.h"
+#include "tools/gn/value.h"
+
+class ParseNode;
+
+// Provides a means to convert a parse node to a value without causing a copy
+// in the common case of an "Identifier" node. Normally to get a value from a
+// parse node you have to call Execute(), and when an identifier is executed
+// it just returns the current value of itself as a copy. But some variables
+// are very large (lsits of many strings for example).

[scottmg, 2016/06/27 22:06:01]

lists

+//
+// The reason you might not want to do this is that in the case of an
+// identifier where the copy is optimized away, the origin will still be the
+// original value. The result can be confusing because it will reference the
+// original value rather than the place where the value was dereferenced, e.g.
+// for a function call. The InitForType() function will verify type information
+// and will fix up the origin so it's not confusing.
+class ParseNodeValueAdapter {
+ public:
+  ParseNodeValueAdapter();
+  ~ParseNodeValueAdapter();
+
+  const Value& get() {
+    if (ref_)
+      return *ref_;
+    return temporary_;
+  }
+
+  // Initializes the adapter for the result of the given expression. Returns
+  // truen on success.
+  bool Init(Scope* scope, const ParseNode* node, Err* err);
+
+  // Like Init() but additionally verifies that the type of the result matches.
+  bool InitForType(Scope* scope,
+                   const ParseNode* node,
+                   Value::Type type,
+                   Err* err);
+
+ private:
+  // Holds either a reference to an existing item, or a temporary as a copy.
+  // If ref is non-null, it's valid, otherwise the temporary is used.
+  const Value* ref_;
+  Value temporary_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParseNodeValueAdapter);
+};
+
+#endif  // TOOLS_GN_PARSE_NODE_VALUE_ADAPTER_H_