Run the later parts of startup as UI thread tasks

content/public/common/startup_task_runner.h

Index: content/public/common/startup_task_runner.h
diff --git a/content/public/common/startup_task_runner.h b/content/public/common/startup_task_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e4df089de7b267a2a92eb42c8a6365f46cf8916
--- /dev/null
+++ b/content/public/common/startup_task_runner.h
@@ -0,0 +1,72 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_STARTUP_TASK_RUNNER_H_
+#define CONTENT_BROWSER_STARTUP_TASK_RUNNER_H_
+
+#include <list>
+
+#include "base/callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+
+#include "build/build_config.h"
+
+namespace content {
+
+// This class runs startup tasks. The tasks are either run immediately inline,
+// or are queued one at a time on the UI thread's message loop. If the events
+// are queued, UI events that are received during startup will be acted upon
+// between startup tasks. The motivation for this is that, on targets where the
+// UI is already started, it allows us to keep the UI responsive during startup.
+//
+// Note that this differs from a SingleThreadedTaskRunner in that there may be
+// no opportunity to handle UI events between the tasks of a
+// SingleThreadedTaskRunner.
+
+class StartupTaskRunner : public base::RefCounted<StartupTaskRunner> {
+ public:
+  class Observer {
+   public:
+    virtual ~Observer() {}
+    // Called when all tasks have been run
+    virtual void AllStartupTasksRan() = 0;

[jam, 2013/07/24 06:45:24]

see content api link about not having single-method interfaces and using
callbacks instead

[aberent, 2013/07/24 22:18:31]

Done.

+  };
+
+  enum StartupMode {
+    IMMEDIATE,
+    INCREMENTAL
+  };
+
+  // Constructor: Note that the observer is optional. The code will check for
+  // a NULL observer before attempting to call observer functions.
+  StartupTaskRunner(StartupMode mode, Observer* observer);
+
+  // Add a task to the queue of startup tasks to be run.
+  virtual void AddTask(base::Closure& callback);
+
+  // Set the task runner to use to run the tasks
+  virtual void SetProxy(
+      const scoped_refptr<base::SingleThreadTaskRunner>& proxy);
+
+  // Start running the tasks.
+  virtual void StartRunningTasks();
+
+ private:
+
+  friend class base::RefCounted<StartupTaskRunner>;
+  virtual ~StartupTaskRunner() {};
+
+  std::list<base::Closure> task_list_;
+  void WrappedTask();
+
+  StartupMode startup_mode_;
+  Observer* observer_;
+  scoped_refptr<base::SingleThreadTaskRunner> proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(StartupTaskRunner);

[jam, 2013/07/24 06:45:24]

see content api docs about interfaces vs concrete classes in the public api

[aberent, 2013/07/24 22:18:31]

After looking at this I realized that I don't actually need StartupTaskRunner to
be an api class. The only thing that was being called from above the api was the
constructor. I am now, instead, passing down the constructor's arguments so that
StartupTaskRunner is only ever referenced within content.

+};
+
+}  // namespace content
+#endif  // CONTENT_BROWSER_STARTUP_TASK_RUNNER_H_