Implement a poor man's PostAfterStartupTask() function.

chrome/browser/chrome_browser_main.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_browser_main.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "base/prefs/pref_value_store.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/process/process_info.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/cancellation_flag.h"
 #include "base/sys_info.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_impl.h"
@@ skipping 171 matching lines @@
 #if defined(ENABLE_WEBRTC)
 #include "chrome/browser/media/webrtc_log_util.h"
 #endif  // defined(ENABLE_WEBRTC)
 
 #if defined(USE_AURA)
 #include "ui/aura/env.h"
 #endif  // defined(USE_AURA)
 
 using content::BrowserThread;
 
+
+
+namespace {
+using StartupCompleteFlag = base::CancellationFlag;

[gab, 2015/03/10 15:00:32]

Feels weird to use "CancellationFlag" here although it does exactly what we
need...

I guess the next closest thing would be a WaitableEvent(true, false); which
would be slightly more heavy weight.

Perhaps CancellationFlag should be repurposed to be non-"Cancellation" specific
(not in this CL, but just a thought for the Chrome owners to weigh).

[michaeln, 2015/03/10 19:46:26]

^^^ this

[gab, 2015/03/10 19:55:27]

One simple way to do this would be to rename the class, but add a

using CancellationFlag = NewFlagClassName;

at the top of the header to avoid having to rename every user just yet if ever.

+base::LazyInstance<StartupCompleteFlag>::Leaky g_startup_complete_flag;
+}
+
+namespace chrome {
+
+bool IsBrowserStartupComplete() {
+  return g_startup_complete_flag.Get().IsSet();
+}
+
+void SetBrowserStartupIsComplete() {
+  g_startup_complete_flag.Get().Set();
+}
+
+}
+
 namespace {
 
 // This function provides some ways to test crash and assertion handling
 // behavior of the program.
 void HandleTestParameters(const base::CommandLine& command_line) {
   // This parameter causes a null pointer crash (crash reporter trigger).
   if (command_line.HasSwitch(switches::kBrowserCrashTest)) {
     int* bad_pointer = NULL;
     *bad_pointer = 0;
   }
@@ skipping 346 matching lines @@
       local_state_(NULL),
       restart_last_session_(false) {
   // If we're running tests (ui_task is non-null).
   if (parameters.ui_task)
     browser_defaults::enable_help_app = false;
 
   // Chrome disallows cookies by default. All code paths that want to use
   // cookies need to go through one of Chrome's URLRequestContexts which have
   // a ChromeNetworkDelegate attached that selectively allows cookies again.
   net::URLRequest::SetDefaultCookiePolicyToBlock();
+
+  g_startup_complete_flag.Get();
 }
 
 ChromeBrowserMainParts::~ChromeBrowserMainParts() {
   for (int i = static_cast<int>(chrome_extra_parts_.size())-1; i >= 0; --i)
     delete chrome_extra_parts_[i];
   chrome_extra_parts_.clear();
 }
 
 // This will be called after the command-line has been mutated by about:flags
 void ChromeBrowserMainParts::SetupMetricsAndFieldTrials() {
@@ skipping 498 matching lines @@
 #if !defined(OS_ANDROID)
   // Allow ProcessSingleton to process messages.
   process_singleton_->Unlock();
 #endif  // !defined(OS_ANDROID)
 #if defined(ENABLE_WEBRTC)
   // Set up a task to delete old WebRTC log files for all profiles. Use a delay
   // to reduce the impact on startup time.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebRtcLogUtil::DeleteOldWebRtcLogFilesForAllProfiles),

[michaeln, 2015/03/10 19:46:26]

This might be a good candidate for PostAfterStartupTask().

       base::TimeDelta::FromMinutes(1));
 #endif  // defined(ENABLE_WEBRTC)
+
+  // Failsafe for signaling startup completion.

[jam, 2015/03/10 23:04:34]

why do we need a failsafe?

under what circumstance would a page load never happen and we want these delayed
tasks to run?

[michaeln, 2015/03/10 23:54:54]

The first page is closed prior to getting to the loaded state.

Chrome is being started headless just to run ServiceWorkers for sync'ing
purposes so no page is loaded.

I may be thinking ahead toward hooking this into session restore too much, but
the notion of when the browser is started up is not well defined, the sum of
some set of signals == started up. I want to make it easy/safe to experiment
with exactly what constitutes 'started up' and I'm wary of corner cases that
might prevent a signal.

+  BrowserThread::PostDelayedTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&chrome::SetBrowserStartupIsComplete),
+      base::TimeDelta::FromMinutes(3));

[gab, 2015/03/10 15:00:32]

Is PostBrowserStart() called in background mode launches (i.e. before an
explicit Chrome launch)? I would guess not.

I assume PostMainMessageLoopStart() would be called though even if in background
mode, this would thus be a better place for this code IMO.

[michaeln, 2015/03/10 19:46:26]

I'm really not sure about which of these methods gets called when and on which
platforms? The NOTREACHED in PostMainMessageLoopStart tells me its not used on
android. Any guidance i can get about where to best place the failsafe and where
to signal 'complete' would be great.

Maybe the failsafe timer should start earlier in the startup process, as soon as
BrowserThread::PostDelayedTask(UI...) can be called?

[gab, 2015/03/10 19:55:27]

Makes sense to post it in a safe and early spot IMO since it's a long timer
anyways.

 }
 
 int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   TRACE_EVENT0("startup", "ChromeBrowserMainParts::PreMainMessageLoopRunImpl");
   SCOPED_UMA_HISTOGRAM_LONG_TIMER("Startup.PreMainMessageLoopRunImplLongTime");
   const base::TimeTicks start_time_step1 = base::TimeTicks::Now();
   // Android updates the metrics service dynamically depending on whether the
   // application is in the foreground or not. Do not start here.
 #if !defined(OS_ANDROID)
   // Now that the file thread has been started, start recording.
@@ skipping 606 matching lines @@
   chromeos::CrosSettings::Shutdown();
 #endif  // defined(OS_CHROMEOS)
 #endif  // defined(OS_ANDROID)
 }
 
 // Public members:
 
 void ChromeBrowserMainParts::AddParts(ChromeBrowserMainExtraParts* parts) {
   chrome_extra_parts_.push_back(parts);
 }