diff options
Diffstat (limited to 'tools/gn/input_file_manager.cc')
| -rw-r--r-- | tools/gn/input_file_manager.cc | 254 |
1 files changed, 0 insertions, 254 deletions
diff --git a/tools/gn/input_file_manager.cc b/tools/gn/input_file_manager.cc deleted file mode 100644 index e840ba0..0000000 --- a/tools/gn/input_file_manager.cc +++ /dev/null @@ -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; -} |