Add initial prototype for the GN meta-buildsystem.

tools/gn/scheduler.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/scheduler.h"
+
+#include "base/bind.h"
+#include "tools/gn/ninja_target_writer.h"
+#include "tools/gn/standard_out.h"
+
+Scheduler* g_scheduler = NULL;
+
+Scheduler::Scheduler()
+    : pool_(new base::SequencedWorkerPool(32, "worker_")),
+      input_file_manager_(new InputFileManager),
+      verbose_logging_(false),
+      work_count_(0),
+      is_failed_(false) {
+  g_scheduler = this;
+}
+
+Scheduler::~Scheduler() {
+  g_scheduler = NULL;
+}
+
+bool Scheduler::Run() {
+  runner_.Run();
+  pool_->Shutdown();
+  return !is_failed();
+}
+
+void Scheduler::Log(const std::string& verb, const std::string& msg) {
+  if (base::MessageLoop::current() == &main_loop_) {
+    LogOnMainThread(verb, msg);
+  } else {
+    // The run loop always joins on the sub threads, so the lifetime of this
+    // object outlives the invocations of this function, hence "unretained".
+    main_loop_.PostTask(FROM_HERE,
+                        base::Bind(&Scheduler::LogOnMainThread,
+                                   base::Unretained(this), verb, msg));
+  }
+}
+
+void Scheduler::FailWithError(const Err& err) {
+  DCHECK(err.has_error());
+  {
+    base::AutoLock lock(lock_);
+
+    if (is_failed_)
+      return;  // Ignore errors once we see one.
+    is_failed_ = true;
+  }
+
+  if (base::MessageLoop::current() == &main_loop_) {
+    FailWithErrorOnMainThread(err);
+  } else {
+    // The run loop always joins on the sub threads, so the lifetime of this
+    // object outlives the invocations of this function, hence "unretained".
+    main_loop_.PostTask(FROM_HERE,
+                        base::Bind(&Scheduler::FailWithErrorOnMainThread,
+                                   base::Unretained(this), err));
+  }
+}
+
+void Scheduler::ScheduleWork(const base::Closure& work) {
+  IncrementWorkCount();
+  pool_->PostWorkerTaskWithShutdownBehavior(
+      FROM_HERE, base::Bind(&Scheduler::DoWork,
+                            base::Unretained(this), work),
+      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+}
+
+void Scheduler::ScheduleTargetFileWrite(const Target* target) {
+  pool_->PostWorkerTaskWithShutdownBehavior(
+      FROM_HERE, base::Bind(&Scheduler::DoTargetFileWrite,
+                            base::Unretained(this), target),
+      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+}
+
+void Scheduler::AddGenDependency(const SourceFile& source_file) {
+  base::AutoLock lock(lock_);
+  gen_dependencies_.push_back(source_file);
+}
+
+std::vector<SourceFile> Scheduler::GetGenDependencies() const {
+  base::AutoLock lock(lock_);
+  return gen_dependencies_;
+}
+
+void Scheduler::IncrementWorkCount() {
+  base::AtomicRefCountInc(&work_count_);
+}
+
+void Scheduler::DecrementWorkCount() {
+  if (!base::AtomicRefCountDec(&work_count_)) {
+    if (base::MessageLoop::current() == &main_loop_) {
+      OnComplete();
+    } else {
+      main_loop_.PostTask(FROM_HERE,
+                          base::Bind(&Scheduler::OnComplete,
+                                     base::Unretained(this)));
+    }
+  }
+}
+
+void Scheduler::LogOnMainThread(const std::string& verb,
+                                const std::string& msg) {
+  OutputString(verb, DECORATION_YELLOW);
+  OutputString(" " + msg + "\n");
+}
+
+void Scheduler::FailWithErrorOnMainThread(const Err& err) {
+  err.PrintToStdout();
+  runner_.Quit();
+}
+
+void Scheduler::DoTargetFileWrite(const Target* target) {
+  NinjaTargetWriter::RunAndWriteFile(target);
+}
+
+void Scheduler::DoWork(const base::Closure& closure) {
+  closure.Run();
+  DecrementWorkCount();
+}
+
+void Scheduler::OnComplete() {
+  // Should be called on the main thread.
+  DCHECK(base::MessageLoop::current() == main_loop());
+  runner_.Quit();
+}