blob: f3d9234f84231668f4980b3d30164c7694617c2d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// Copyright (c) 2011 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.
#ifndef CONTENT_BROWSER_BROWSER_MAIN_H_
#define CONTENT_BROWSER_BROWSER_MAIN_H_
#pragma once
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
class BrowserThread;
class CommandLine;
class HighResolutionTimerManager;
class MessageLoop;
struct MainFunctionParams;
namespace base {
class SystemMonitor;
}
namespace net {
class NetworkChangeNotifier;
}
namespace content {
// BrowserMainParts:
// This class contains different "stages" to be executed in |BrowserMain()|,
// mostly initialization. This is made into a class rather than just functions
// so each stage can create and maintain state. Each part is represented by a
// single method (e.g., "EarlyInitialization()"), which does the following:
// - calls a method (e.g., "PreEarlyInitialization()") which individual
// platforms can override to provide platform-specific code which is to be
// executed before the common code;
// - calls various methods for things common to all platforms (for that given
// stage); and
// - calls a method (e.g., "PostEarlyInitialization()") for platform-specific
// code to be called after the common code.
// As indicated above, platforms should override the default "Pre...()" and
// "Post...()" methods when necessary; they need not call the superclass's
// implementation (which is empty).
//
// Parts:
// - EarlyInitialization: things which should be done as soon as possible on
// program start (such as setting up signal handlers) and things to be done
// at some generic time before the start of the main message loop.
// - MainMessageLoopStart: things beginning with the start of the main message
// loop and ending with initialization of the main thread; platform-specific
// things which should be done immediately before the start of the main
// message loop should go in |PreMainMessageLoopStart()|.
// - (more to come)
//
// How to add stuff (to existing parts):
// - Figure out when your new code should be executed. What must happen
// before/after your code is executed? Are there performance reasons for
// running your code at a particular time? Document these things!
// - Split out any platform-specific bits. Please avoid #ifdefs it at all
// possible. You have two choices for platform-specific code: (1) Execute it
// from one of the platform-specific |Pre/Post...()| methods; do this if the
// code is unique to a platform type. Or (2) execute it from one of the
// "parts" (e.g., |EarlyInitialization()|) and provide platform-specific
// implementations of your code (in a virtual method); do this if you need to
// provide different implementations across most/all platforms.
// - Unless your new code is just one or two lines, put it into a separate
// method with a well-defined purpose. (Likewise, if you're adding to an
// existing chunk which makes it longer than one or two lines, please move
// the code out into a separate method.)
class BrowserMainParts {
public:
explicit BrowserMainParts(const MainFunctionParams& parameters);
virtual ~BrowserMainParts();
// Parts to be called by |BrowserMain()|.
void EarlyInitialization();
void InitializeToolkit();
void MainMessageLoopStart();
void RunMainMessageLoopParts();
int result_code() const { return result_code_; }
protected:
// Methods to be overridden to provide platform-specific code; these
// correspond to the "parts" above.
virtual void PreEarlyInitialization();
virtual void PostEarlyInitialization();
virtual void PreMainMessageLoopStart();
virtual void PostMainMessageLoopStart();
virtual void PreMainMessageLoopRun();
virtual void MainMessageLoopRun();
virtual void PostMainMessageLoopRun();
// Allows an embedder to do any extra toolkit initialization.
virtual void ToolkitInitialized();
// Accessors for data members (below) ----------------------------------------
const MainFunctionParams& parameters() const {
return parameters_;
}
const CommandLine& parsed_command_line() const {
return parsed_command_line_;
}
MessageLoop& main_message_loop() const {
return *main_message_loop_;
}
void set_result_code(int result_code) { result_code_ = result_code; }
private:
void InitializeMainThread();
// Members initialized on construction ---------------------------------------
const MainFunctionParams& parameters_;
const CommandLine& parsed_command_line_;
int result_code_;
// Members initialized in |MainMessageLoopStart()| ---------------------------
scoped_ptr<MessageLoop> main_message_loop_;
scoped_ptr<base::SystemMonitor> system_monitor_;
scoped_ptr<HighResolutionTimerManager> hi_res_timer_manager_;
scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
scoped_ptr<BrowserThread> main_thread_;
DISALLOW_COPY_AND_ASSIGN(BrowserMainParts);
};
} // namespace content
#endif // CONTENT_BROWSER_BROWSER_MAIN_H_
|
