1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/browser_shutdown.h"
6
7 #include <map>
8 #include <string>
9
10 #include "base/command_line.h"
11 #include "base/file_path.h"
12 #include "base/file_util.h"
13 #include "base/metrics/histogram.h"
14 #include "base/path_service.h"
15 #include "base/process_util.h"
16 #include "base/string_number_conversions.h"
17 #include "base/string_util.h"
18 #include "base/synchronization/waitable_event.h"
19 #include "base/threading/thread.h"
20 #include "base/threading/thread_restrictions.h"
21 #include "base/time.h"
22 #include "build/build_config.h"
23 #include "chrome/browser/about_flags.h"
24 #include "chrome/browser/browser_process.h"
25 #include "chrome/browser/first_run/upgrade_util.h"
26 #include "chrome/browser/jankometer.h"
27 #include "chrome/browser/metrics/metrics_service.h"
28 #include "chrome/browser/prefs/pref_service.h"
29 #include "chrome/browser/profiles/profile_manager.h"
30 #include "chrome/browser/service/service_process_control_manager.h"
31 #include "chrome/browser/ui/browser_list.h"
32 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
33 #include "chrome/common/chrome_paths.h"
34 #include "chrome/common/chrome_switches.h"
35 #include "chrome/common/pref_names.h"
36 #include "chrome/common/switch_utils.h"
37 #include "content/browser/browser_thread.h"
38 #include "content/browser/plugin_process_host.h"
39 #include "content/browser/renderer_host/render_process_host.h"
40 #include "content/browser/renderer_host/render_view_host.h"
41 #include "content/browser/renderer_host/render_widget_host.h"
42 #include "net/predictor_api.h"
43 #include "ui/base/resource/resource_bundle.h"
44
45 #if defined(OS_WIN)
46 #include "chrome/browser/browser_util_win.h"
47 #include "chrome/browser/first_run/upgrade_util_win.h"
48 #include "chrome/browser/rlz/rlz.h"
49 #endif
50
51 #if defined(OS_CHROMEOS)
52 #include "chrome/browser/chromeos/boot_times_loader.h"
53 #include "chrome/browser/chromeos/cros/cros_library.h"
54 #include "chrome/browser/chromeos/cros/login_library.h"
55 #include "chrome/browser/chromeos/system_key_event_listener.h"
56 #endif
57
58 using base::Time;
59 using base::TimeDelta;
60
61 namespace browser_shutdown {
62
63 // Whether the browser is trying to quit (e.g., Quit chosen from menu).
64 bool g_trying_to_quit = false;
65
66 Time shutdown_started_;
67 ShutdownType shutdown_type_ = NOT_VALID;
68 int shutdown_num_processes_;
69 int shutdown_num_processes_slow_;
70
71 bool delete_resources_on_shutdown = true;
72
73 const char kShutdownMsFile[] = "chrome_shutdown_ms.txt";
74
RegisterPrefs(PrefService * local_state)75 void RegisterPrefs(PrefService* local_state) {
76 local_state->RegisterIntegerPref(prefs::kShutdownType, NOT_VALID);
77 local_state->RegisterIntegerPref(prefs::kShutdownNumProcesses, 0);
78 local_state->RegisterIntegerPref(prefs::kShutdownNumProcessesSlow, 0);
79 }
80
GetShutdownType()81 ShutdownType GetShutdownType() {
82 return shutdown_type_;
83 }
84
OnShutdownStarting(ShutdownType type)85 void OnShutdownStarting(ShutdownType type) {
86 if (shutdown_type_ != NOT_VALID)
87 return;
88
89 shutdown_type_ = type;
90 // For now, we're only counting the number of renderer processes
91 // since we can't safely count the number of plugin processes from this
92 // thread, and we'd really like to avoid anything which might add further
93 // delays to shutdown time.
94 shutdown_started_ = Time::Now();
95
96 // Call FastShutdown on all of the RenderProcessHosts. This will be
97 // a no-op in some cases, so we still need to go through the normal
98 // shutdown path for the ones that didn't exit here.
99 shutdown_num_processes_ = 0;
100 shutdown_num_processes_slow_ = 0;
101 for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
102 !i.IsAtEnd(); i.Advance()) {
103 ++shutdown_num_processes_;
104 if (!i.GetCurrentValue()->FastShutdownIfPossible())
105 ++shutdown_num_processes_slow_;
106 }
107 }
108
GetShutdownMsPath()109 FilePath GetShutdownMsPath() {
110 FilePath shutdown_ms_file;
111 PathService::Get(chrome::DIR_USER_DATA, &shutdown_ms_file);
112 return shutdown_ms_file.AppendASCII(kShutdownMsFile);
113 }
114
Shutdown()115 void Shutdown() {
116 #if defined(OS_CHROMEOS)
117 chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker(
118 "BrowserShutdownStarted", false);
119 #endif
120 // During shutdown we will end up some blocking operations. But the
121 // work needs to get done and we're going to wait for them no matter
122 // what thread they're on, so don't worry about it slowing down
123 // shutdown.
124 base::ThreadRestrictions::SetIOAllowed(true);
125
126 // Shutdown all IPC channels to service processes.
127 ServiceProcessControlManager::GetInstance()->Shutdown();
128
129 #if defined(OS_CHROMEOS)
130 // The system key event listener needs to be shut down earlier than when
131 // Singletons are finally destroyed in AtExitManager.
132 chromeos::SystemKeyEventListener::GetInstance()->Stop();
133 #endif
134
135 // WARNING: During logoff/shutdown (WM_ENDSESSION) we may not have enough
136 // time to get here. If you have something that *must* happen on end session,
137 // consider putting it in BrowserProcessImpl::EndSession.
138 DCHECK(g_browser_process);
139
140 // Notifies we are going away.
141 g_browser_process->shutdown_event()->Signal();
142
143 PrefService* prefs = g_browser_process->local_state();
144 ProfileManager* profile_manager = g_browser_process->profile_manager();
145 PrefService* user_prefs = profile_manager->GetDefaultProfile()->GetPrefs();
146
147 chrome_browser_net::SavePredictorStateForNextStartupAndTrim(user_prefs);
148
149 MetricsService* metrics = g_browser_process->metrics_service();
150 if (metrics)
151 metrics->RecordCompletedSessionEnd();
152
153 if (shutdown_type_ > NOT_VALID && shutdown_num_processes_ > 0) {
154 // Record the shutdown info so that we can put it into a histogram at next
155 // startup.
156 prefs->SetInteger(prefs::kShutdownType, shutdown_type_);
157 prefs->SetInteger(prefs::kShutdownNumProcesses, shutdown_num_processes_);
158 prefs->SetInteger(prefs::kShutdownNumProcessesSlow,
159 shutdown_num_processes_slow_);
160 }
161
162 // Check local state for the restart flag so we can restart the session below.
163 bool restart_last_session = false;
164 if (prefs->HasPrefPath(prefs::kRestartLastSessionOnShutdown)) {
165 restart_last_session =
166 prefs->GetBoolean(prefs::kRestartLastSessionOnShutdown);
167 prefs->ClearPref(prefs::kRestartLastSessionOnShutdown);
168 }
169
170 prefs->SavePersistentPrefs();
171
172 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
173 // Cleanup any statics created by RLZ. Must be done before NotificationService
174 // is destroyed.
175 RLZTracker::CleanupRlz();
176 #endif
177
178 // The jank'o'meter requires that the browser process has been destroyed
179 // before calling UninstallJankometer().
180 delete g_browser_process;
181 g_browser_process = NULL;
182 #if defined(OS_CHROMEOS)
183 chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("BrowserDeleted",
184 true);
185 #endif
186
187 // Uninstall Jank-O-Meter here after the IO thread is no longer running.
188 UninstallJankometer();
189
190 if (delete_resources_on_shutdown)
191 ResourceBundle::CleanupSharedInstance();
192
193 #if defined(OS_WIN)
194 if (!browser_util::IsBrowserAlreadyRunning() &&
195 shutdown_type_ != browser_shutdown::END_SESSION) {
196 upgrade_util::SwapNewChromeExeIfPresent();
197 }
198 #endif
199
200 if (restart_last_session) {
201 #if !defined(OS_CHROMEOS)
202 // Make sure to relaunch the browser with the original command line plus
203 // the Restore Last Session flag. Note that Chrome can be launched (ie.
204 // through ShellExecute on Windows) with a switch argument terminator at
205 // the end (double dash, as described in b/1366444) plus a URL,
206 // which prevents us from appending to the command line directly (issue
207 // 46182). We therefore use GetSwitches to copy the command line (it stops
208 // at the switch argument terminator).
209 CommandLine old_cl(*CommandLine::ForCurrentProcess());
210 scoped_ptr<CommandLine> new_cl(new CommandLine(old_cl.GetProgram()));
211 std::map<std::string, CommandLine::StringType> switches =
212 old_cl.GetSwitches();
213 // Remove the switches that shouldn't persist across restart.
214 about_flags::RemoveFlagsSwitches(&switches);
215 switches::RemoveSwitchesForAutostart(&switches);
216 // Append the old switches to the new command line.
217 for (std::map<std::string, CommandLine::StringType>::const_iterator i =
218 switches.begin(); i != switches.end(); ++i) {
219 CommandLine::StringType switch_value = i->second;
220 if (!switch_value.empty())
221 new_cl->AppendSwitchNative(i->first, i->second);
222 else
223 new_cl->AppendSwitch(i->first);
224 }
225 // Ensure restore last session is set.
226 if (!new_cl->HasSwitch(switches::kRestoreLastSession))
227 new_cl->AppendSwitch(switches::kRestoreLastSession);
228
229 #if defined(OS_WIN) || defined(OS_LINUX)
230 upgrade_util::RelaunchChromeBrowser(*new_cl.get());
231 #endif // defined(OS_WIN) || defined(OS_LINUX)
232
233 #if defined(OS_MACOSX)
234 new_cl->AppendSwitch(switches::kActivateOnLaunch);
235 base::LaunchApp(*new_cl.get(), false, false, NULL);
236 #endif // defined(OS_MACOSX)
237
238 #else
239 NOTIMPLEMENTED();
240 #endif // !defined(OS_CHROMEOS)
241 }
242
243 if (shutdown_type_ > NOT_VALID && shutdown_num_processes_ > 0) {
244 // Measure total shutdown time as late in the process as possible
245 // and then write it to a file to be read at startup.
246 // We can't use prefs since all services are shutdown at this point.
247 TimeDelta shutdown_delta = Time::Now() - shutdown_started_;
248 std::string shutdown_ms =
249 base::Int64ToString(shutdown_delta.InMilliseconds());
250 int len = static_cast<int>(shutdown_ms.length()) + 1;
251 FilePath shutdown_ms_file = GetShutdownMsPath();
252 file_util::WriteFile(shutdown_ms_file, shutdown_ms.c_str(), len);
253 }
254
255 #if defined(OS_CHROMEOS)
256 BrowserList::NotifyAndTerminate(false);
257 #endif
258
259 ChromeURLDataManager::DeleteDataSources();
260 }
261
ReadLastShutdownFile(ShutdownType type,int num_procs,int num_procs_slow)262 void ReadLastShutdownFile(
263 ShutdownType type,
264 int num_procs,
265 int num_procs_slow) {
266 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
267
268 FilePath shutdown_ms_file = GetShutdownMsPath();
269 std::string shutdown_ms_str;
270 int64 shutdown_ms = 0;
271 if (file_util::ReadFileToString(shutdown_ms_file, &shutdown_ms_str))
272 base::StringToInt64(shutdown_ms_str, &shutdown_ms);
273 file_util::Delete(shutdown_ms_file, false);
274
275 if (type == NOT_VALID || shutdown_ms == 0 || num_procs == 0)
276 return;
277
278 const char *time_fmt = "Shutdown.%s.time";
279 const char *time_per_fmt = "Shutdown.%s.time_per_process";
280 std::string time;
281 std::string time_per;
282 if (type == WINDOW_CLOSE) {
283 time = StringPrintf(time_fmt, "window_close");
284 time_per = StringPrintf(time_per_fmt, "window_close");
285 } else if (type == BROWSER_EXIT) {
286 time = StringPrintf(time_fmt, "browser_exit");
287 time_per = StringPrintf(time_per_fmt, "browser_exit");
288 } else if (type == END_SESSION) {
289 time = StringPrintf(time_fmt, "end_session");
290 time_per = StringPrintf(time_per_fmt, "end_session");
291 } else {
292 NOTREACHED();
293 }
294
295 if (time.empty())
296 return;
297
298 // TODO(erikkay): change these to UMA histograms after a bit more testing.
299 UMA_HISTOGRAM_TIMES(time.c_str(),
300 TimeDelta::FromMilliseconds(shutdown_ms));
301 UMA_HISTOGRAM_TIMES(time_per.c_str(),
302 TimeDelta::FromMilliseconds(shutdown_ms / num_procs));
303 UMA_HISTOGRAM_COUNTS_100("Shutdown.renderers.total", num_procs);
304 UMA_HISTOGRAM_COUNTS_100("Shutdown.renderers.slow", num_procs_slow);
305 }
306
ReadLastShutdownInfo()307 void ReadLastShutdownInfo() {
308 PrefService* prefs = g_browser_process->local_state();
309 ShutdownType type =
310 static_cast<ShutdownType>(prefs->GetInteger(prefs::kShutdownType));
311 int num_procs = prefs->GetInteger(prefs::kShutdownNumProcesses);
312 int num_procs_slow = prefs->GetInteger(prefs::kShutdownNumProcessesSlow);
313 // clear the prefs immediately so we don't pick them up on a future run
314 prefs->SetInteger(prefs::kShutdownType, NOT_VALID);
315 prefs->SetInteger(prefs::kShutdownNumProcesses, 0);
316 prefs->SetInteger(prefs::kShutdownNumProcessesSlow, 0);
317
318 // Read and delete the file on the file thread.
319 BrowserThread::PostTask(
320 BrowserThread::FILE, FROM_HERE,
321 NewRunnableFunction(
322 &ReadLastShutdownFile, type, num_procs, num_procs_slow));
323 }
324
SetTryingToQuit(bool quitting)325 void SetTryingToQuit(bool quitting) {
326 g_trying_to_quit = quitting;
327 }
328
IsTryingToQuit()329 bool IsTryingToQuit() {
330 return g_trying_to_quit;
331 }
332
ShuttingDownWithoutClosingBrowsers()333 bool ShuttingDownWithoutClosingBrowsers() {
334 #if defined(USE_X11)
335 if (GetShutdownType() == browser_shutdown::END_SESSION)
336 return true;
337 #endif
338 return false;
339 }
340
341 } // namespace browser_shutdown
342