browser_process_impl.h revision 5f1c94371a64b3196d4be9466099bb892df9b88e 
1// Copyright (c) 2012 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// When each service is created, we set a flag indicating this. At this point,
6// the service initialization could fail or succeed. This allows us to remember
7// if we tried to create a service, and not try creating it over and over if
8// the creation failed.
9
10#ifndef CHROME_BROWSER_BROWSER_PROCESS_IMPL_H_
11#define CHROME_BROWSER_BROWSER_PROCESS_IMPL_H_
12
13#include <string>
14
15#include "base/basictypes.h"
16#include "base/debug/stack_trace.h"
17#include "base/memory/ref_counted.h"
18#include "base/memory/scoped_ptr.h"
19#include "base/prefs/pref_change_registrar.h"
20#include "base/threading/non_thread_safe.h"
21#include "base/timer/timer.h"
22#include "chrome/browser/browser_process.h"
23
24class ChromeNetLog;
25class ChromeResourceDispatcherHostDelegate;
26class MetricsServicesManager;
27class RemoteDebuggingServer;
28class PrefRegistrySimple;
29class PromoResourceService;
30
31#if defined(ENABLE_PLUGIN_INSTALLATION)
32class PluginsResourceService;
33#endif
34
35namespace base {
36class CommandLine;
37class SequencedTaskRunner;
38}
39
40namespace extensions {
41class ExtensionsBrowserClient;
42}
43
44namespace gcm {
45class GCMDriver;
46}
47
48namespace policy {
49class BrowserPolicyConnector;
50class PolicyService;
51};
52
53// Real implementation of BrowserProcess that creates and returns the services.
54class BrowserProcessImpl : public BrowserProcess,
55                           public base::NonThreadSafe {
56 public:
57  // |local_state_task_runner| must be a shutdown-blocking task runner.
58  BrowserProcessImpl(base::SequencedTaskRunner* local_state_task_runner,
59                     const base::CommandLine& command_line);
60  virtual ~BrowserProcessImpl();
61
62  // Called before the browser threads are created.
63  void PreCreateThreads();
64
65  // Called after the threads have been created but before the message loops
66  // starts running. Allows the browser process to do any initialization that
67  // requires all threads running.
68  void PreMainMessageLoopRun();
69
70  // Most cleanup is done by these functions, driven from
71  // ChromeBrowserMain based on notifications from the content
72  // framework, rather than in the destructor, so that we can
73  // interleave cleanup with threads being stopped.
74  void StartTearDown();
75  void PostDestroyThreads();
76
77  // BrowserProcess implementation.
78  virtual void ResourceDispatcherHostCreated() OVERRIDE;
79  virtual void EndSession() OVERRIDE;
80  virtual MetricsServicesManager* GetMetricsServicesManager() OVERRIDE;
81  virtual MetricsService* metrics_service() OVERRIDE;
82  virtual rappor::RapporService* rappor_service() OVERRIDE;
83  virtual IOThread* io_thread() OVERRIDE;
84  virtual WatchDogThread* watchdog_thread() OVERRIDE;
85  virtual ProfileManager* profile_manager() OVERRIDE;
86  virtual PrefService* local_state() OVERRIDE;
87  virtual net::URLRequestContextGetter* system_request_context() OVERRIDE;
88  virtual chrome_variations::VariationsService* variations_service() OVERRIDE;
89  virtual BrowserProcessPlatformPart* platform_part() OVERRIDE;
90  virtual extensions::EventRouterForwarder*
91        extension_event_router_forwarder() OVERRIDE;
92  virtual NotificationUIManager* notification_ui_manager() OVERRIDE;
93  virtual message_center::MessageCenter* message_center() OVERRIDE;
94  virtual policy::BrowserPolicyConnector* browser_policy_connector() OVERRIDE;
95  virtual policy::PolicyService* policy_service() OVERRIDE;
96  virtual IconManager* icon_manager() OVERRIDE;
97  virtual GLStringManager* gl_string_manager() OVERRIDE;
98  virtual GpuModeManager* gpu_mode_manager() OVERRIDE;
99  virtual void CreateDevToolsHttpProtocolHandler(
100      chrome::HostDesktopType host_desktop_type,
101      const std::string& ip,
102      int port) OVERRIDE;
103  virtual unsigned int AddRefModule() OVERRIDE;
104  virtual unsigned int ReleaseModule() OVERRIDE;
105  virtual bool IsShuttingDown() OVERRIDE;
106  virtual printing::PrintJobManager* print_job_manager() OVERRIDE;
107  virtual printing::PrintPreviewDialogController*
108      print_preview_dialog_controller() OVERRIDE;
109  virtual printing::BackgroundPrintingManager*
110      background_printing_manager() OVERRIDE;
111  virtual IntranetRedirectDetector* intranet_redirect_detector() OVERRIDE;
112  virtual const std::string& GetApplicationLocale() OVERRIDE;
113  virtual void SetApplicationLocale(const std::string& locale) OVERRIDE;
114  virtual DownloadStatusUpdater* download_status_updater() OVERRIDE;
115  virtual DownloadRequestLimiter* download_request_limiter() OVERRIDE;
116  virtual BackgroundModeManager* background_mode_manager() OVERRIDE;
117  virtual void set_background_mode_manager_for_test(
118      scoped_ptr<BackgroundModeManager> manager) OVERRIDE;
119  virtual StatusTray* status_tray() OVERRIDE;
120  virtual SafeBrowsingService* safe_browsing_service() OVERRIDE;
121  virtual safe_browsing::ClientSideDetectionService*
122      safe_browsing_detection_service() OVERRIDE;
123
124#if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
125  virtual void StartAutoupdateTimer() OVERRIDE;
126#endif
127
128  virtual ChromeNetLog* net_log() OVERRIDE;
129  virtual prerender::PrerenderTracker* prerender_tracker() OVERRIDE;
130  virtual component_updater::ComponentUpdateService*
131      component_updater() OVERRIDE;
132  virtual CRLSetFetcher* crl_set_fetcher() OVERRIDE;
133  virtual component_updater::PnaclComponentInstaller*
134      pnacl_component_installer() OVERRIDE;
135  virtual MediaFileSystemRegistry* media_file_system_registry() OVERRIDE;
136  virtual bool created_local_state() const OVERRIDE;
137#if defined(ENABLE_WEBRTC)
138  virtual WebRtcLogUploader* webrtc_log_uploader() OVERRIDE;
139#endif
140  virtual network_time::NetworkTimeTracker* network_time_tracker() OVERRIDE;
141  virtual gcm::GCMDriver* gcm_driver() OVERRIDE;
142
143  static void RegisterPrefs(PrefRegistrySimple* registry);
144
145 private:
146  void CreateWatchdogThread();
147  void CreateProfileManager();
148  void CreateLocalState();
149  void CreateViewedPageTracker();
150  void CreateIconManager();
151  void CreateIntranetRedirectDetector();
152  void CreateNotificationUIManager();
153  void CreateStatusTrayManager();
154  void CreatePrintPreviewDialogController();
155  void CreateBackgroundPrintingManager();
156  void CreateSafeBrowsingService();
157  void CreateSafeBrowsingDetectionService();
158  void CreateStatusTray();
159  void CreateBackgroundModeManager();
160  void CreateGCMDriver();
161
162  void ApplyAllowCrossOriginAuthPromptPolicy();
163  void ApplyDefaultBrowserPolicy();
164  void ApplyMetricsReportingPolicy();
165
166  scoped_ptr<MetricsServicesManager> metrics_services_manager_;
167
168  scoped_ptr<IOThread> io_thread_;
169
170  bool created_watchdog_thread_;
171  scoped_ptr<WatchDogThread> watchdog_thread_;
172
173  bool created_browser_policy_connector_;
174#if defined(ENABLE_CONFIGURATION_POLICY)
175  // Must be destroyed after |local_state_|.
176  scoped_ptr<policy::BrowserPolicyConnector> browser_policy_connector_;
177#else
178  // Must be destroyed after |local_state_|.
179  // This is a stub when policy is not enabled. Otherwise, the PolicyService
180  // is owned by the |browser_policy_connector_| and this is not used.
181  scoped_ptr<policy::PolicyService> policy_service_;
182#endif
183
184  bool created_profile_manager_;
185  scoped_ptr<ProfileManager> profile_manager_;
186
187  bool created_local_state_;
188  scoped_ptr<PrefService> local_state_;
189
190  bool created_icon_manager_;
191  scoped_ptr<IconManager> icon_manager_;
192
193  scoped_ptr<GLStringManager> gl_string_manager_;
194
195  scoped_ptr<GpuModeManager> gpu_mode_manager_;
196
197  scoped_ptr<extensions::ExtensionsBrowserClient> extensions_browser_client_;
198
199#if defined(ENABLE_EXTENSIONS)
200  scoped_refptr<extensions::EventRouterForwarder>
201      extension_event_router_forwarder_;
202
203  scoped_ptr<MediaFileSystemRegistry> media_file_system_registry_;
204#endif
205
206#if !defined(OS_ANDROID)
207  scoped_ptr<RemoteDebuggingServer> remote_debugging_server_;
208#endif
209
210#if defined(ENABLE_FULL_PRINTING)
211  scoped_refptr<printing::PrintPreviewDialogController>
212      print_preview_dialog_controller_;
213
214  scoped_ptr<printing::BackgroundPrintingManager> background_printing_manager_;
215#endif
216
217  // Manager for desktop notification UI.
218  bool created_notification_ui_manager_;
219  scoped_ptr<NotificationUIManager> notification_ui_manager_;
220
221  scoped_ptr<IntranetRedirectDetector> intranet_redirect_detector_;
222
223  scoped_ptr<StatusTray> status_tray_;
224
225  scoped_ptr<BackgroundModeManager> background_mode_manager_;
226
227  bool created_safe_browsing_service_;
228  scoped_refptr<SafeBrowsingService> safe_browsing_service_;
229
230  unsigned int module_ref_count_;
231  bool did_start_;
232
233  // Ensures that all the print jobs are finished before closing the browser.
234  scoped_ptr<printing::PrintJobManager> print_job_manager_;
235
236  std::string locale_;
237
238  // Download status updates (like a changing application icon on dock/taskbar)
239  // are global per-application. DownloadStatusUpdater does no work in the ctor
240  // so we don't have to worry about lazy initialization.
241  scoped_ptr<DownloadStatusUpdater> download_status_updater_;
242
243  scoped_refptr<DownloadRequestLimiter> download_request_limiter_;
244
245  // Sequenced task runner for local state related I/O tasks.
246  const scoped_refptr<base::SequencedTaskRunner> local_state_task_runner_;
247
248  // Ensures that the observers of plugin/print disable/enable state
249  // notifications are properly added and removed.
250  PrefChangeRegistrar pref_change_registrar_;
251
252  // Lives here so can safely log events on shutdown.
253  scoped_ptr<ChromeNetLog> net_log_;
254
255  // Ordered before resource_dispatcher_host_delegate_ due to destruction
256  // ordering.
257  scoped_ptr<prerender::PrerenderTracker> prerender_tracker_;
258
259  scoped_ptr<ChromeResourceDispatcherHostDelegate>
260      resource_dispatcher_host_delegate_;
261
262  scoped_refptr<PromoResourceService> promo_resource_service_;
263
264#if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
265  base::RepeatingTimer<BrowserProcessImpl> autoupdate_timer_;
266
267  // Gets called by autoupdate timer to see if browser needs restart and can be
268  // restarted, and if that's the case, restarts the browser.
269  void OnAutoupdateTimer();
270  bool CanAutorestartForUpdate() const;
271  void RestartBackgroundInstance();
272#endif  // defined(OS_WIN) || defined(OS_LINUX) && !defined(OS_CHROMEOS)
273
274  // component updater is normally not used under ChromeOS due
275  // to concerns over integrity of data shared between profiles,
276  // but some users of component updater only install per-user.
277  scoped_ptr<component_updater::ComponentUpdateService> component_updater_;
278  scoped_refptr<CRLSetFetcher> crl_set_fetcher_;
279  scoped_ptr<component_updater::PnaclComponentInstaller>
280      pnacl_component_installer_;
281
282#if defined(ENABLE_PLUGIN_INSTALLATION)
283  scoped_refptr<PluginsResourceService> plugins_resource_service_;
284#endif
285
286  scoped_ptr<BrowserProcessPlatformPart> platform_part_;
287
288  // TODO(eroman): Remove this when done debugging 113031. This tracks
289  // the callstack which released the final module reference count.
290  base::debug::StackTrace release_last_reference_callstack_;
291
292#if defined(ENABLE_WEBRTC)
293  // Lazily initialized.
294  scoped_ptr<WebRtcLogUploader> webrtc_log_uploader_;
295#endif
296
297  scoped_ptr<network_time::NetworkTimeTracker> network_time_tracker_;
298
299  scoped_ptr<gcm::GCMDriver> gcm_driver_;
300
301  DISALLOW_COPY_AND_ASSIGN(BrowserProcessImpl);
302};
303
304#endif  // CHROME_BROWSER_BROWSER_PROCESS_IMPL_H_
305