Revert 214254 "Add initial prototype for the GN meta-buildsystem."

trunk/src/tools/gn/input_file_manager.cc

Index: trunk/src/tools/gn/input_file_manager.cc
===================================================================
--- trunk/src/tools/gn/input_file_manager.cc	(revision 214322)
+++ trunk/src/tools/gn/input_file_manager.cc	(working copy)
@@ -1,254 +0,0 @@
-// 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"
-#include "tools/gn/scheduler.h"
-#include "tools/gn/scope_per_file_provider.h"
-#include "tools/gn/tokenizer.h"
-
-namespace {
-
-void InvokeFileLoadCallback(const InputFileManager::FileLoadCallback& cb,
-                            const ParseNode* node) {
-  cb.Run(node);
-}
-
-}  // namespace
-
-InputFileManager::InputFileData::InputFileData(const SourceFile& file_name)
-    : file(file_name),
-      loaded(false),
-      sync_invocation(false) {
-}
-
-InputFileManager::InputFileData::~InputFileData() {
-}
-
-InputFileManager::InputFileManager() {
-}
-
-InputFileManager::~InputFileManager() {
-  // Should be single-threaded by now.
-  STLDeleteContainerPairSecondPointers(input_files_.begin(),
-                                       input_files_.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.
-  base::Closure schedule_this;
-  {
-    base::AutoLock lock(lock_);
-
-    InputFileMap::const_iterator found = input_files_.find(file_name);
-    if (found == input_files_.end()) {
-      // New file, schedule load.
-      InputFileData* data = new InputFileData(file_name);
-      data->scheduled_callbacks.push_back(callback);
-      input_files_[file_name] = data;
-
-      schedule_this = base::Bind(&InputFileManager::BackgroundLoadFile,
-                                 this,
-                                 origin,
-                                 build_settings,
-                                 file_name,
-                                 &data->file);
-    } else {
-      InputFileData* data = found->second;
-
-      // Prevent mixing async and sync loads. See SyncLoadFile for discussion.
-      if (data->sync_invocation) {
-        g_scheduler->FailWithError(Err(
-            origin, "Load type mismatch.",
-            "The file \"" + file_name.value() + "\" was previously loaded\n"
-            "synchronously (via an import) and now you're trying to load it "
-            "asynchronously\n(via a deps rule). This is a class 2 misdemeanor: "
-            "a single input file must\nbe loaded the same way each time to "
-            "avoid blowing my tiny, tiny mind."));
-        return false;
-      }
-
-      if (data->loaded) {
-        // Can just directly issue the callback on the background thread.
-        schedule_this = base::Bind(&InvokeFileLoadCallback, callback,
-                                   data->parsed_root.get());
-      } else {
-        // Load is pending on this file, schedule the invoke.
-        data->scheduled_callbacks.push_back(callback);
-        return true;
-      }
-    }
-  }
-  g_scheduler->pool()->PostWorkerTaskWithShutdownBehavior(
-      FROM_HERE, schedule_this,
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
-  return true;
-}
-
-const ParseNode* InputFileManager::SyncLoadFile(
-    const LocationRange& origin,
-    const BuildSettings* build_settings,
-    const SourceFile& file_name,
-    Err* err) {
-  base::AutoLock lock(lock_);
-
-  InputFileData* data = NULL;
-  InputFileMap::iterator found = input_files_.find(file_name);
-  if (found == input_files_.end()) {
-    base::AutoUnlock unlock(lock_);
-
-    // Haven't seen this file yet, start loading right now.
-    data = new InputFileData(file_name);
-    data->sync_invocation = true;
-    input_files_[file_name] = data;
-
-    if (!LoadFile(origin, build_settings, file_name, &data->file, err))
-      return NULL;
-  } else {
-    // This file has either been loaded or is pending loading.
-    data = found->second;
-
-    if (!data->sync_invocation) {
-      // Don't allow mixing of sync and async loads. If an async load is
-      // scheduled and then a bunch of threads need to load it synchronously
-      // and block on it loading, it could deadlock or at least cause a lot
-      // of wasted CPU while those threads wait for the load to complete (which
-      // may be far back in the input queue).
-      //
-      // We could work around this by promoting the load to a sync load. This
-      // requires a bunch of extra code to either check flags and likely do
-      // extra locking (bad) or to just do both types of load on the file and
-      // deal with the race condition.
-      //
-      // I have no practical way to test this, and generally we should have
-      // all include files processed synchronously and all build files
-      // processed asynchronously, so it doesn't happen in practice.
-      *err = Err(
-          origin, "Load type mismatch.",
-          "The file \"" + file_name.value() + "\" was previously loaded\n"
-          "asynchronously (via a deps rule) and now you're trying to load it "
-          "synchronously.\nThis is a class 2 misdemeanor: a single input file "
-          "must be loaded the same way\neach time to avoid blowing my tiny, "
-          "tiny mind.");
-      return NULL;
-    }
-
-    if (!data->loaded) {
-      // Wait for the already-pending sync load to complete.
-      if (!data->completion_event)
-        data->completion_event.reset(new base::WaitableEvent(false, false));
-      {
-        base::AutoUnlock unlock(lock_);
-        data->completion_event->Wait();
-      }
-    }
-  }
-
-  // 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();
-}
-
-int InputFileManager::GetInputFileCount() const {
-  base::AutoLock lock(lock_);
-  return input_files_.size();
-}
-
-void InputFileManager::GetAllInputFileNames(
-    std::vector<SourceFile>* result) const {
-  base::AutoLock lock(lock_);
-  result->reserve(input_files_.size());
-  for (InputFileMap::const_iterator i = input_files_.begin();
-       i != input_files_.end(); ++i) {
-    result->push_back(i->second->file.name());
-  }
-}
-
-void InputFileManager::BackgroundLoadFile(const LocationRange& origin,
-                                          const BuildSettings* build_settings,
-                                          const SourceFile& name,
-                                          InputFile* file) {
-  Err err;
-  if (!LoadFile(origin, build_settings, name, file, &err))
-    g_scheduler->FailWithError(err);
-}
-
-bool InputFileManager::LoadFile(const LocationRange& origin,
-                                const BuildSettings* build_settings,
-                                const SourceFile& name,
-                                InputFile* file,
-                                Err* err) {
-  // Do all of this stuff outside the lock. We should not give out file
-  // pointers until the read is complete.
-  if (g_scheduler->verbose_logging())
-    g_scheduler->Log("Loading", name.value());
-
-  // Read.
-  base::FilePath primary_path = build_settings->GetFullPath(name);
-  if (!file->Load(primary_path)) {
-    if (!build_settings->secondary_source_path().empty()) {
-      // Fall back to secondary source tree.
-      base::FilePath secondary_path =
-          build_settings->GetFullPathSecondary(name);
-      if (!file->Load(secondary_path)) {
-        *err = Err(origin, "Can't load input file.",
-                   "Unable to load either \n" +
-                   FilePathToUTF8(primary_path) + " or \n" +
-                   FilePathToUTF8(secondary_path));
-        return false;
-      }
-    } else {
-      *err = Err(origin,
-                 "Unable to load \"" + FilePathToUTF8(primary_path) + "\".");
-      return false;
-    }
-  }
-
-  if (g_scheduler->verbose_logging())
-    g_scheduler->Log("Parsing", name.value());
-
-  // Tokenize.
-  std::vector<Token> tokens = Tokenizer::Tokenize(file, err);
-  if (err->has_error())
-    return false;
-
-  // Parse.
-  scoped_ptr<ParseNode> root = Parser::Parse(tokens, err);
-  if (err->has_error())
-    return false;
-  ParseNode* unowned_root = root.get();
-
-  std::vector<FileLoadCallback> callbacks;
-  {
-    base::AutoLock lock(lock_);
-    DCHECK(input_files_.find(name) != input_files_.end());
-
-    InputFileData* data = input_files_[name];
-    data->loaded = true;
-    data->tokens.swap(tokens);
-    data->parsed_root = root.Pass();
-
-    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;
-}