Allow overlapping sync and async startup requests

content/browser/startup_task_runner_unittest.cc

 // Copyright 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 "content/browser/startup_task_runner.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 98 matching lines @@
   virtual ~TaskRunnerProxy() {}
 };
 
 TEST_F(StartupTaskRunnerTest, SynchronousExecution) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
   EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
   EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0);
 
-  scoped_refptr<StartupTaskRunner> runner =
-      new StartupTaskRunner(false, base::Bind(&Observer), proxy);
+  scoped_ptr<StartupTaskRunner> runner(

[Yaron, 2013/08/22 06:00:26]

Nit: why not allocate on stack?

[aberent, 2013/08/23 11:40:21]

Done.

+      new StartupTaskRunner(base::Bind(&Observer), proxy));
 
   StartupTask task1 =
       base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this));
   runner->AddTask(task1);
   EXPECT_EQ(GetLastTask(), 0);
   StartupTask task2 =
       base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this));
   runner->AddTask(task2);
 
   // Nothing should run until we tell them to.
   EXPECT_EQ(GetLastTask(), 0);
-  runner->StartRunningTasks();
+  runner->RunAllTasksNow();
 
   // On an immediate StartupTaskRunner the tasks should now all have run.
   EXPECT_EQ(GetLastTask(), 2);
 
   EXPECT_TRUE(observer_called);
   EXPECT_EQ(observer_result, 0);
 }
 
 TEST_F(StartupTaskRunnerTest, NullObserver) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
   EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
   EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0);
 
-  scoped_refptr<StartupTaskRunner> runner =
-      new StartupTaskRunner(false, base::Callback<void(int)>(), proxy);
+  scoped_ptr<StartupTaskRunner> runner(
+      new StartupTaskRunner(base::Callback<void(int)>(), proxy));
 
   StartupTask task1 =
       base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this));
   runner->AddTask(task1);
   EXPECT_EQ(GetLastTask(), 0);
   StartupTask task2 =
       base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this));
   runner->AddTask(task2);
 
   // Nothing should run until we tell them to.
   EXPECT_EQ(GetLastTask(), 0);
-  runner->StartRunningTasks();
+  runner->RunAllTasksNow();
 
   // On an immediate StartupTaskRunner the tasks should now all have run.
   EXPECT_EQ(GetLastTask(), 2);
 
   EXPECT_FALSE(observer_called);
 }
 
 TEST_F(StartupTaskRunnerTest, SynchronousExecutionFailedTask) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
   EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
   EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0);
 
-  scoped_refptr<StartupTaskRunner> runner =
-      new StartupTaskRunner(false, base::Bind(&Observer), proxy);
+  scoped_ptr<StartupTaskRunner> runner(
+      new StartupTaskRunner(base::Bind(&Observer), proxy));
 
   StartupTask task3 =
       base::Bind(&StartupTaskRunnerTest::FailingTask, base::Unretained(this));
   runner->AddTask(task3);
   EXPECT_EQ(GetLastTask(), 0);
   StartupTask task2 =
       base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this));
   runner->AddTask(task2);
 
   // Nothing should run until we tell them to.
   EXPECT_EQ(GetLastTask(), 0);
-  runner->StartRunningTasks();
+  runner->RunAllTasksNow();
 
   // Only the first task should have run, since it failed
   EXPECT_EQ(GetLastTask(), 3);
 
   EXPECT_TRUE(observer_called);
   EXPECT_EQ(observer_result, 1);
 }
 
 TEST_F(StartupTaskRunnerTest, AsynchronousExecution) {
 
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
   EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
   EXPECT_CALL(
       mock_runner,
       PostNonNestableDelayedTask(_, _, base::TimeDelta::FromMilliseconds(0)))
       .Times(testing::Between(2, 3))
       .WillRepeatedly(WithArg<1>(Invoke(SaveTaskArg)));
 
-  scoped_refptr<StartupTaskRunner> runner =
-      new StartupTaskRunner(true, base::Bind(&Observer), proxy);
+  scoped_ptr<StartupTaskRunner> runner(
+      new StartupTaskRunner(base::Bind(&Observer), proxy));
 
   StartupTask task1 =
       base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this));
   runner->AddTask(task1);
   StartupTask task2 =
       base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this));
   runner->AddTask(task2);
 
   // Nothing should run until we tell them to.
   EXPECT_EQ(GetLastTask(), 0);
-  runner->StartRunningTasks();
+  runner->StartRunningTasksAsync();
 
   // No tasks should have run yet, since we the message loop hasn't run.
   EXPECT_EQ(GetLastTask(), 0);
 
   // Fake the actual message loop. Each time a task is run a new task should
   // be added to the queue, hence updating "task". The loop should actually run
   // at most 3 times (once for each task plus possibly once for the observer),
   // the "4" is a backstop.
   for (int i = 0; i < 4 && !observer_called; i++) {
     task.Run();
     EXPECT_EQ(i + 1, GetLastTask());
   }
   EXPECT_TRUE(observer_called);
   EXPECT_EQ(observer_result, 0);
 }
 
 TEST_F(StartupTaskRunnerTest, AsynchronousExecutionFailedTask) {
 
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
   EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
   EXPECT_CALL(
       mock_runner,
       PostNonNestableDelayedTask(_, _, base::TimeDelta::FromMilliseconds(0)))
       .Times(testing::Between(1, 2))
       .WillRepeatedly(WithArg<1>(Invoke(SaveTaskArg)));
 
-  scoped_refptr<StartupTaskRunner> runner =
-      new StartupTaskRunner(true, base::Bind(&Observer), proxy);
+  scoped_ptr<StartupTaskRunner> runner(
+      new StartupTaskRunner(base::Bind(&Observer), proxy));
 
   StartupTask task3 =
       base::Bind(&StartupTaskRunnerTest::FailingTask, base::Unretained(this));
   runner->AddTask(task3);
   StartupTask task2 =
       base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this));
   runner->AddTask(task2);
 
   // Nothing should run until we tell them to.
   EXPECT_EQ(GetLastTask(), 0);
-  runner->StartRunningTasks();
+  runner->StartRunningTasksAsync();
 
   // No tasks should have run yet, since we the message loop hasn't run.
   EXPECT_EQ(GetLastTask(), 0);
 
   // Fake the actual message loop. Each time a task is run a new task should
   // be added to the queue, hence updating "task". The loop should actually run
   // at most twice (once for the failed task plus possibly once for the
   // observer), the "4" is a backstop.
   for (int i = 0; i < 4 && !observer_called; i++) {
     task.Run();
   }
   EXPECT_EQ(GetLastTask(), 3);
 
   EXPECT_TRUE(observer_called);
   EXPECT_EQ(observer_result, 1);
 }
 }  // namespace
 }  // namespace content