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;
+  }
+
+  if (!BrowserThread:: CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ChromeContentBrowserClient::PostAfterStartupTask,
+                   weak_this_, from_here, task_runner, task));
+    return;
+  }
+
+  if (after_startup_tasks_.empty()) {
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ChromeContentBrowserClient::OnAfterStartupTasksTimer,
+                   weak_this_),
+        base::TimeDelta::FromSeconds(5));
+  }
+
+  // When the time comes, spread their execution over 30 seconds.
+  const int kMinDelay = 0;
+  const int kMaxDelay = 30;
+  after_startup_tasks_.push_back(base::Bind(
+      &base::TaskRunner::PostDelayedTask, task_runner, from_here, task,
+      base::TimeDelta::FromSeconds(base::RandInt(kMinDelay, kMaxDelay))));
+}
+
 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::OnAfterStartupTasksTimer() {
+  if (!IsBrowserStartupComplete()) {
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ChromeContentBrowserClient::OnAfterStartupTasksTimer,
+                   weak_this_),
+        base::TimeDelta::FromSeconds(5));
+    return;
+  }
+
+  for (const auto& task : after_startup_tasks_)
+    task.Run();
+  after_startup_tasks_.clear();

[michaeln, 2015/03/25 01:09:32]

Oh, I think there's a problem with this? I think it requires that any refcounted
objects bound up in the 'task' given to PostAfterStartupTask to have a
threadsafe refcount because the final ref could be released on this thread
rather than the target thread. It's unlikely given the kMinDelay to kMaxDelay
involved.

I'll massage it to avoid that problem.

[michaeln, 2015/03/25 02:25:18]

Done

+}
+
 #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