Remove the WindowsLogoffRace experiment.

chrome/browser/lifetime/application_lifetime.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/lifetime/application_lifetime.h"
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/kill.h"
 #include "base/process/process_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/lifetime/browser_close_manager.h"
@@ skipping 219 matching lines @@
   // can be false in following cases. a) power-off b) signout from
   // screen locker.
   if (!AreAllBrowsersCloseable())
     browser_shutdown::OnShutdownStarting(browser_shutdown::END_SESSION);
   else
     browser_shutdown::OnShutdownStarting(browser_shutdown::BROWSER_EXIT);
   AttemptExitInternal(true);
 }
 #endif
 
-namespace {
-
-bool ExperimentUseBrokenSynchronization() {
-  const std::string group_name =
-      base::FieldTrialList::FindFullName("WindowsLogoffRace");
-  return group_name == "BrokenSynchronization";
-}
-
-}  // namespace
-
 void SessionEnding() {
   // This is a time-limited shutdown where we need to write as much to
   // disk as we can as soon as we can, and where we must kill the
   // process within a hang timeout to avoid user prompts.
 
   // Start watching for hang during shutdown, and crash it if takes too long.
   // We disarm when |shutdown_watcher| object is destroyed, which is when we
   // exit this function.
   ShutdownWatcherHelper shutdown_watcher;
   shutdown_watcher.Arm(base::TimeDelta::FromSeconds(90));
@@ skipping 13 matching lines @@
       content::NotificationService::AllSources(),
       content::NotificationService::NoDetails());
 
   // Write important data first.
   g_browser_process->EndSession();
 
 #if defined(OS_WIN)
   base::win::SetShouldCrashOnProcessDetach(false);
 #endif
 
-  if (ExperimentUseBrokenSynchronization()) {
-    CloseAllBrowsers();
-
-    // Send out notification. This is used during testing so that the test
-    // harness can properly shutdown before we exit.
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_SESSION_END,
-        content::NotificationService::AllSources(),
-        content::NotificationService::NoDetails());
-
-    // This will end by terminating the process.
-    content::ImmediateShutdownAndExitProcess();
-  } else {
-    // On Windows 7 and later, the system will consider the process ripe for
-    // termination as soon as it hides or destroys its windows. Since any
-    // execution past that point will be non-deterministically cut short, we
-    // might as well put ourselves out of that misery deterministically.
-    base::KillProcess(base::GetCurrentProcessHandle(), 0, false);
-  }
+  // On Windows 7 and later, the system will consider the process ripe for
+  // termination as soon as it hides or destroys its windows. Since any
+  // execution past that point will be non-deterministically cut short, we
+  // might as well put ourselves out of that misery deterministically.
+  base::KillProcess(base::GetCurrentProcessHandle(), 0, false);

[gab, 2015/12/03 19:12:29]

I just realized that this made this the behavior on all OSes!

I don't think this was intentional? At least when the experiment was introduced
(https://codereview.chromium.org/385123004) this code was under an
ifdef(OS_WIN). The Windows specific side was then assumed by the experiment. And
here after removing the experiment, this become true for all platforms..!

But hey... maybe that's a good thing after all? Shutdown determinism across
platforms? Means we should probably delete all code after this point as it
hasn't ran in a year?!

 }
 
 void IncrementKeepAliveCount() {
   // Increment the browser process refcount as long as we're keeping the
   // application alive.
   if (!WillKeepAlive())
     g_browser_process->AddRefModule();
   ++g_keep_alive_count;
 }
 
@@ skipping 94 matching lines @@
   //    environment is still active.
   if (browser->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_NATIVE)
     return !ash::Shell::HasInstance();
   else if (browser->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH)
     return BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_NATIVE)->empty();
 #endif
   return true;
 }
 
 }  // namespace chrome