Implement a poor man's PostAfterStartupTask() function.

chrome/browser/chrome_content_browser_client.cc

 // Copyright (c) 2012 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 "chrome/browser/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/scoped_file.h"
 #include "base/i18n/icu_util.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
+#include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "base/time/time.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/character_encoding.h"
+#include "chrome/browser/chrome_browser_main.h"
 #include "chrome/browser/chrome_content_browser_client_parts.h"
 #include "chrome/browser/chrome_net_benchmarking_message_filter.h"
 #include "chrome/browser/chrome_quota_permission_context.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/font_family_cache.h"
 #include "chrome/browser/geolocation/chrome_access_token_store.h"
 #include "chrome/browser/geolocation/geolocation_permission_context.h"
@@ skipping 650 matching lines @@
 #endif
 
 #if !defined(OS_ANDROID)
   TtsExtensionEngine* tts_extension_engine = TtsExtensionEngine::GetInstance();
   TtsController::GetInstance()->SetTtsEngineDelegate(tts_extension_engine);
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
   extra_parts_.push_back(new ChromeContentBrowserClientExtensionsPart);
 #endif
+
+  weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 ChromeContentBrowserClient::~ChromeContentBrowserClient() {
   for (int i = static_cast<int>(extra_parts_.size()) - 1; i >= 0; --i)
     delete extra_parts_[i];
   extra_parts_.clear();
 }
 
 // static
 void ChromeContentBrowserClient::RegisterProfilePrefs(
@@ skipping 71 matching lines @@
 
 #if defined(USE_X11)
   main_parts->AddParts(new ChromeBrowserMainExtraPartsX11());
 #endif
 
   chrome::AddMetricsExtraParts(main_parts);
 
   return main_parts;
 }
 
+void ChromeContentBrowserClient::PostAfterStartupTask(
+    const tracked_objects::Location& from_here,
+    const scoped_refptr<base::TaskRunner>& task_runner,
+    const base::Closure& task) {
+  if (IsBrowserStartupComplete()) {
+    task_runner->PostTask(from_here, task);
+    return;
+  }
+
+  scoped_ptr<AfterStartupTask> queued_task(
+      new AfterStartupTask(from_here, task_runner, task));
+  QueueAfterStartupTask(queued_task.Pass());
+}
+
 std::string ChromeContentBrowserClient::GetStoragePartitionIdForSite(
     content::BrowserContext* browser_context,
     const GURL& site) {
   std::string partition_id;
 
   // The partition ID for webview guest processes is the string value of its
   // SiteInstance URL - "chrome-guest://app_id/persist?partition".
   if (site.SchemeIs(content::kGuestScheme)) {
     partition_id = site.spec();
   } else if (site.GetOrigin().spec() == kChromeUIChromeSigninURL) {
@@ skipping 1750 matching lines @@
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(profile);
   if (prerender_manager &&
       prerender_manager->IsWebContentsPrerendering(web_contents, nullptr)) {
     *visibility_state = blink::WebPageVisibilityStatePrerender;
   }
 }
 
+void ChromeContentBrowserClient::QueueAfterStartupTask(
+    scoped_ptr<AfterStartupTask> queued_task) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ChromeContentBrowserClient::QueueAfterStartupTask,
+                   weak_this_, base::Passed(queued_task.Pass())));
+    return;
+  }
+
+  if (IsBrowserStartupComplete()) {
+    ScheduleRunAfterStartupTask(queued_task.Pass());
+    return;
+  }
+
+  if (after_startup_tasks_.empty()) {
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ChromeContentBrowserClient::OnAfterStartupTasksTimer,
+                   weak_this_),
+        base::TimeDelta::FromSeconds(5));
+  }
+
+  after_startup_tasks_.push_back(queued_task.release());
+}
+
+void ChromeContentBrowserClient::OnAfterStartupTasksTimer() {
+  if (!IsBrowserStartupComplete()) {
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ChromeContentBrowserClient::OnAfterStartupTasksTimer,
+                   weak_this_),
+        base::TimeDelta::FromSeconds(5));
+    return;
+  }
+  for (AfterStartupTask* queued_task : after_startup_tasks_)
+    ScheduleRunAfterStartupTask(make_scoped_ptr(queued_task));
+  after_startup_tasks_.clear();
+}
+
+void ChromeContentBrowserClient::ScheduleRunAfterStartupTask(
+    scoped_ptr<AfterStartupTask> queued_task) {
+  // Spread their execution over 30 seconds.
+  const int kMinDelay = 0;
+  const int kMaxDelay = 30;

[jam, 2015/03/26 15:38:58]

What is the purpose of this random delay?

[michaeln, 2015/03/26 19:52:33]

To avoid initiating a bunch of work at the same time. Wouldn't want to tie up
threads with a bunches of back to back tasks that aren't tied directly to a user
action. I think ideally the time span could be a function of how many there are
to run.

[michaeln, 2015/03/26 20:17:52]

I'll compute the delay more directly instead of randomizing it. Probably some
benefit to keeping the ordering.

[jam, 2015/03/26 20:22:08]

hmm, I understand the motivation but it's not clear that this is going to make a
difference. 

[michaeln, 2015/03/26 21:39:36]

And if the list were very large, what would your gut say then? Avoiding a big
hit at time 0 was one of the issues raised on the mailing list about this
approach. All of the tasks I have in mind for this involve disk and/or network
IO.  As a user of this api, i think  I'd prefer having them spread out a little
so I wouldn't have to ensure that elsewhere. The call to RandInt was a way to do
that with minimal amount of code.

I'm not real comfortable with running them at the same time.

[jam, 2015/03/27 15:50:29]

ok that seems fair.

+  scoped_refptr<base::TaskRunner> target_runner = queued_task->task_runner;
+  tracked_objects::Location from_here = queued_task->from_here;
+  target_runner->PostDelayedTask(
+      from_here,
+      base::Bind(&ChromeContentBrowserClient::RunAfterStartupTask,
+                  weak_this_, base::Passed(queued_task.Pass())),
+      base::TimeDelta::FromSeconds(base::RandInt(kMinDelay, kMaxDelay)));
+}
+
+void ChromeContentBrowserClient::RunAfterStartupTask(
+    scoped_ptr<AfterStartupTask> queued_task) {
+  // We're careful to delete the caller's |task| on the target runner's thread.
+  DCHECK(queued_task->task_runner->RunsTasksOnCurrentThread());
+  queued_task->task.Run();
+}
+
 #if defined(ENABLE_WEBRTC)
 void ChromeContentBrowserClient::MaybeCopyDisableWebRtcEncryptionSwitch(
     base::CommandLine* to_command_line,
     const base::CommandLine& from_command_line,
     VersionInfo::Channel channel) {
 #if defined(OS_ANDROID)
   const VersionInfo::Channel kMaxDisableEncryptionChannel =
       VersionInfo::CHANNEL_BETA;
 #else
   const VersionInfo::Channel kMaxDisableEncryptionChannel =
       VersionInfo::CHANNEL_DEV;
 #endif
   if (channel <= kMaxDisableEncryptionChannel) {
     static const char* const kWebRtcDevSwitchNames[] = {
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome