Add support for reading .gypi files.

tools/gn/input_file_manager.cc

 // 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.
 
 #include "tools/gn/input_file_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parser.h"
@@ skipping 20 matching lines @@
 InputFileManager::InputFileData::~InputFileData() {
 }
 
 InputFileManager::InputFileManager() {
 }
 
 InputFileManager::~InputFileManager() {
   // Should be single-threaded by now.
   STLDeleteContainerPairSecondPointers(input_files_.begin(),
                                        input_files_.end());
+  STLDeleteContainerPointers(dynamic_inputs_.begin(), dynamic_inputs_.end());
 }
 
 bool InputFileManager::AsyncLoadFile(const LocationRange& origin,
                                      const BuildSettings* build_settings,
                                      const SourceFile& file_name,
                                      const FileLoadCallback& callback,
                                      Err* err) {
   // Try not to schedule callbacks while holding the lock. All cases that don't
   // want to schedule should return early. Otherwise, this will be scheduled
   // after we leave the lock.
@@ skipping 108 matching lines @@
   }
 
   // The other load could have failed. In this case that error will be printed
   // to the console, but we need to return something here, so make up a
   // dummy error.
   if (!data->parsed_root)
     *err = Err(origin, "File parse failed");
   return data->parsed_root.get();
 }
 
+void InputFileManager::AddDynamicInput(InputFile** file,
+                                       std::vector<Token>** tokens,
+                                       scoped_ptr<ParseNode>** parse_root) {
+  InputFileData* data = new InputFileData(SourceFile());
+  {
+    base::AutoLock lock(lock_);
+    dynamic_inputs_.push_back(data);
+  }
+  *file = &data->file;
+  *tokens = &data->tokens;
+  *parse_root = &data->parsed_root;
+}
+
 int InputFileManager::GetInputFileCount() const {
   base::AutoLock lock(lock_);
   return static_cast<int>(input_files_.size());
 }
 
 void InputFileManager::GetAllPhysicalInputFileNames(
     std::vector<base::FilePath>* result) const {
   base::AutoLock lock(lock_);
   result->reserve(input_files_.size());
   for (InputFileMap::const_iterator i = input_files_.begin();
@@ skipping 91 matching lines @@
     callbacks.swap(data->scheduled_callbacks);
   }
 
   // Run pending invocations. Theoretically we could schedule each of these
   // separately to get some parallelism. But normally there will only be one
   // item in the list, so that's extra overhead and complexity for no gain.
   for (size_t i = 0; i < callbacks.size(); i++)
     callbacks[i].Run(unowned_root);
   return true;
 }