Implement the WindowsLogoffRace finch experiment.

chrome/browser/browser_process_impl.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/browser_process_impl.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "base/atomic_ref_count.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_path.h"
+#include "base/metrics/field_trial.h"
 #include "base/path_service.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/default_tick_clock.h"
 #include "chrome/browser/apps/chrome_apps_client.h"
 #include "chrome/browser/background/background_mode_manager.h"
@@ skipping 406 matching lines @@
     waitable_event_.Signal();
 }
 
 bool RundownTaskCounter::TimedWait(const base::TimeDelta& max_time) {
   // Decrement the excess count from the constructor.
   Decrement();
 
   return waitable_event_.TimedWait(max_time);
 }
 
+bool ExperimentUseBrokenSynchronization() {
+  // The logoff behavior used to have a race, whereby it would perform profile
+  // IO writes on the blocking thread pool, but would sycnhronize to the FILE
+  // thread. Windows feels free to terminate any process that's hidden or
+  // destroyed all it's windows, and sometimes Chrome would be terminated
+  // with pending profile IO due to this mis-synchronization.
+  // Under the "WindowsLogoffRace" experiment group, the broken behavior is
+  // emulated, in order to allow measuring what fraction of unclean shutdowns
+  // are due to this bug.
+  const std::string group_name =
+      base::FieldTrialList::FindFullName("WindowsLogoffRace");
+  return group_name == "BrokenSynchronization";
+}
+
 }  // namespace
 
 void BrowserProcessImpl::EndSession() {
+  bool use_broken_synchronization = ExperimentUseBrokenSynchronization();
+
   // Mark all the profiles as clean.
   ProfileManager* pm = profile_manager();
   std::vector<Profile*> profiles(pm->GetLoadedProfiles());
   scoped_refptr<RundownTaskCounter> rundown_counter(new RundownTaskCounter());
   for (size_t i = 0; i < profiles.size(); ++i) {
     Profile* profile = profiles[i];
     profile->SetExitType(Profile::EXIT_SESSION_ENDED);
 
-    rundown_counter->Post(profile->GetIOTaskRunner());
+    if (!use_broken_synchronization)
+      rundown_counter->Post(profile->GetIOTaskRunner());
   }
 
   // Tell the metrics service it was cleanly shutdown.
   MetricsService* metrics = g_browser_process->metrics_service();
   if (metrics && local_state()) {
     metrics->RecordStartOfSessionEnd();
 #if !defined(OS_CHROMEOS)
     // MetricsService lazily writes to prefs, force it to write now.
     // On ChromeOS, chrome gets killed when hangs, so no need to
     // commit metrics::prefs::kStabilitySessionEndCompleted change immediately.
     local_state()->CommitPendingWrite();
 
-    rundown_counter->Post(local_state_task_runner_);
+    if (!use_broken_synchronization)
+      rundown_counter->Post(local_state_task_runner_);
 #endif
   }
 
   // http://crbug.com/125207
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
 
   // We must write that the profile and metrics service shutdown cleanly,
   // otherwise on startup we'll think we crashed. So we block until done and
   // then proceed with normal shutdown.
   //
   // If you change the condition here, be sure to also change
   // ProfileBrowserTests to match.
 #if defined(USE_X11) || defined(OS_WIN)
+  if (use_broken_synchronization) {
+    rundown_counter->Post(
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+  }
+
   // Do a best-effort wait on the successful countdown of rundown tasks. Note
   // that if we don't complete "quickly enough", Windows will terminate our
   // process.
   //
   // On Windows, we previously posted a message to FILE and then ran a nested
   // message loop, waiting for that message to be processed until quitting.
   // However, doing so means that other messages will also be processed. In
   // particular, if the GPU process host notices that the GPU has been killed
   // during shutdown, it races exiting the nested loop with the process host
   // blocking the message loop attempting to re-establish a connection to the
@@ skipping 679 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)