Allow overlapping sync and async startup requests

content/browser/startup_task_runner.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/location.h"
 #include "base/message_loop/message_loop.h"
 
 namespace content {
 
 StartupTaskRunner::StartupTaskRunner(
-    bool browser_may_start_asynchronously,
     base::Callback<void(int)> const startup_complete_callback,
     scoped_refptr<base::SingleThreadTaskRunner> proxy)
-    : asynchronous_startup_(browser_may_start_asynchronously),
-      startup_complete_callback_(startup_complete_callback),
-      proxy_(proxy) {}
+    : startup_complete_callback_(startup_complete_callback), proxy_(proxy) {}
+
+// This is needed to satisfy the coding style checks done by the Mac compiler,

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

Nit: comment is unnecessary. It's standard style for chromium

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

Done.

+// but doesn't need to do anything.
+StartupTaskRunner::~StartupTaskRunner() {}
 
 void StartupTaskRunner::AddTask(StartupTask& callback) {
   task_list_.push_back(callback);
 }
 
-void StartupTaskRunner::StartRunningTasks() {
+void StartupTaskRunner::StartRunningTasksAsync() {
   DCHECK(proxy_);
   int result = 0;
-  if (asynchronous_startup_ && !task_list_.empty()) {
-    const base::Closure next_task =
-        base::Bind(&StartupTaskRunner::WrappedTask, this);
-    proxy_->PostNonNestableTask(FROM_HERE, next_task);
-  } else {
-    for (std::list<StartupTask>::iterator it = task_list_.begin();
-         it != task_list_.end();
-         it++) {
-      result = it->Run();
-      if (result > 0) {
-        break;
-      }
-    }
+  if (task_list_.empty()) {
     if (!startup_complete_callback_.is_null()) {

[nyquist, 2013/08/23 06:28:32]

Nit: curly braces unnecessary.

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

Not done. 

The style guide is explicitly neutral on this point "In general, curly braces
are not required for single-line statements, but they are allowed if you like
them".

In the past I have found that not using curly braces in such situations is a
source of future bugs. What typically happens is that someone later tries to put
another statement (e.g. a trace statement) at the top of the conditional block
without noticing that there are no braces, hence changing the flow of control.

       startup_complete_callback_.Run(result);
     }
+  } else {
+    const base::Closure next_task =
+        base::Bind(&StartupTaskRunner::WrappedTask, base::Unretained(this));
+    proxy_->PostNonNestableTask(FROM_HERE, next_task);
+  }
+}
+
+void StartupTaskRunner::RunAllTasksNow() {
+  int result = 0;
+  for (std::list<StartupTask>::iterator it = task_list_.begin();
+       it != task_list_.end();
+       it++) {
+    result = it->Run();
+    if (result > 0) {

[nyquist, 2013/08/23 06:28:32]

Nit: curly braces unnecessary.

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

Done and break moved to line with if.

+      break;
+    }
+  }
+  if (!startup_complete_callback_.is_null()) {

[nyquist, 2013/08/23 06:28:32]

Nit: curly braces unnecessary.

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

Not done. See comment on line 30.

+    startup_complete_callback_.Run(result);
   }
 }
 
 void StartupTaskRunner::WrappedTask() {
+  if (task_list_.empty()) {
+    // This will happen if the remaining tasks have been run synchronously since
+    // the WrappedTask was created. Any callback will already have been called,
+    // so there is nothing to do
+    return;
+  }
   int result = task_list_.front().Run();
   task_list_.pop_front();
   if (result > 0 || task_list_.empty()) {
     if (!startup_complete_callback_.is_null()) {
       startup_complete_callback_.Run(result);
     }
   } else {
     const base::Closure next_task =
-        base::Bind(&StartupTaskRunner::WrappedTask, this);
+        base::Bind(&StartupTaskRunner::WrappedTask, base::Unretained(this));
     proxy_->PostNonNestableTask(FROM_HERE, next_task);
   }
 }
 
-StartupTaskRunner::~StartupTaskRunner() {}
-
 }  // namespace content