← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/process/launch.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/process/launch.h
1
 
// Copyright 2013 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
 
// This file contains functions for launching subprocesses.
6
 
 
7
 
#ifndef BASE_PROCESS_LAUNCH_H_
8
 
#define BASE_PROCESS_LAUNCH_H_
9
 
 
10
 
#include <string>
11
 
#include <utility>
12
 
#include <vector>
13
 
 
14
 
#include "base/base_export.h"
15
 
#include "base/basictypes.h"
16
 
#include "base/environment.h"
17
 
#include "base/process/process_handle.h"
18
 
#include "base/strings/string_piece.h"
19
 
 
20
 
#if defined(OS_POSIX)
21
 
#include "base/posix/file_descriptor_shuffle.h"
22
 
#elif defined(OS_WIN)
23
 
#include <windows.h>
24
 
#include "base/win/scoped_handle.h"
25
 
#endif
26
 
 
27
 
class CommandLine;
28
 
 
29
 
namespace base {
30
 
 
31
 
#if defined(OS_WIN)
32
 
typedef std::vector<HANDLE> HandlesToInheritVector;
33
 
#endif
34
 
// TODO(viettrungluu): Only define this on POSIX?
35
 
typedef std::vector<std::pair<int, int> > FileHandleMappingVector;
36
 
 
37
 
// Options for launching a subprocess that are passed to LaunchProcess().
38
 
// The default constructor constructs the object with default options.
39
 
struct BASE_EXPORT LaunchOptions {
40
 
  LaunchOptions();
41
 
  ~LaunchOptions();
42
 
 
43
 
  // If true, wait for the process to complete.
44
 
  bool wait;
45
 
 
46
 
#if defined(OS_WIN)
47
 
  bool start_hidden;
48
 
 
49
 
  // If non-null, inherit exactly the list of handles in this vector (these
50
 
  // handles must be inheritable). This is only supported on Vista and higher.
51
 
  HandlesToInheritVector* handles_to_inherit;
52
 
 
53
 
  // If true, the new process inherits handles from the parent. In production
54
 
  // code this flag should be used only when running short-lived, trusted
55
 
  // binaries, because open handles from other libraries and subsystems will
56
 
  // leak to the child process, causing errors such as open socket hangs.
57
 
  // Note: If |handles_to_inherit| is non-null, this flag is ignored and only
58
 
  // those handles will be inherited (on Vista and higher).
59
 
  bool inherit_handles;
60
 
 
61
 
  // If non-null, runs as if the user represented by the token had launched it.
62
 
  // Whether the application is visible on the interactive desktop depends on
63
 
  // the token belonging to an interactive logon session.
64
 
  //
65
 
  // To avoid hard to diagnose problems, when specified this loads the
66
 
  // environment variables associated with the user and if this operation fails
67
 
  // the entire call fails as well.
68
 
  UserTokenHandle as_user;
69
 
 
70
 
  // If true, use an empty string for the desktop name.
71
 
  bool empty_desktop_name;
72
 
 
73
 
  // If non-null, launches the application in that job object. The process will
74
 
  // be terminated immediately and LaunchProcess() will fail if assignment to
75
 
  // the job object fails.
76
 
  HANDLE job_handle;
77
 
 
78
 
  // Handles for the redirection of stdin, stdout and stderr. The handles must
79
 
  // be inheritable. Caller should either set all three of them or none (i.e.
80
 
  // there is no way to redirect stderr without redirecting stdin). The
81
 
  // |inherit_handles| flag must be set to true when redirecting stdio stream.
82
 
  HANDLE stdin_handle;
83
 
  HANDLE stdout_handle;
84
 
  HANDLE stderr_handle;
85
 
 
86
 
  // If set to true, ensures that the child process is launched with the
87
 
  // CREATE_BREAKAWAY_FROM_JOB flag which allows it to breakout of the parent
88
 
  // job if any.
89
 
  bool force_breakaway_from_job_;
90
 
#else
91
 
  // Set/unset environment variables. Empty (the default) means to inherit
92
 
  // the same environment. See AlterEnvironment().
93
 
  EnvironmentMap environ;
94
 
 
95
 
  // If non-null, remap file descriptors according to the mapping of
96
 
  // src fd->dest fd to propagate FDs into the child process.
97
 
  // This pointer is owned by the caller and must live through the
98
 
  // call to LaunchProcess().
99
 
  const FileHandleMappingVector* fds_to_remap;
100
 
 
101
 
  // Each element is an RLIMIT_* constant that should be raised to its
102
 
  // rlim_max.  This pointer is owned by the caller and must live through
103
 
  // the call to LaunchProcess().
104
 
  const std::vector<int>* maximize_rlimits;
105
 
 
106
 
  // If true, start the process in a new process group, instead of
107
 
  // inheriting the parent's process group.  The pgid of the child process
108
 
  // will be the same as its pid.
109
 
  bool new_process_group;
110
 
 
111
 
#if defined(OS_LINUX)
112
 
  // If non-zero, start the process using clone(), using flags as provided.
113
 
  int clone_flags;
114
 
#endif  // defined(OS_LINUX)
115
 
 
116
 
#if defined(OS_CHROMEOS)
117
 
  // If non-negative, the specified file descriptor will be set as the launched
118
 
  // process' controlling terminal.
119
 
  int ctrl_terminal_fd;
120
 
#endif  // defined(OS_CHROMEOS)
121
 
 
122
 
#endif  // !defined(OS_WIN)
123
 
};
124
 
 
125
 
// Launch a process via the command line |cmdline|.
126
 
// See the documentation of LaunchOptions for details on |options|.
127
 
//
128
 
// Returns true upon success.
129
 
//
130
 
// Upon success, if |process_handle| is non-null, it will be filled in with the
131
 
// handle of the launched process.  NOTE: In this case, the caller is
132
 
// responsible for closing the handle so that it doesn't leak!
133
 
// Otherwise, the process handle will be implicitly closed.
134
 
//
135
 
// Unix-specific notes:
136
 
// - All file descriptors open in the parent process will be closed in the
137
 
//   child process except for any preserved by options::fds_to_remap, and
138
 
//   stdin, stdout, and stderr. If not remapped by options::fds_to_remap,
139
 
//   stdin is reopened as /dev/null, and the child is allowed to inherit its
140
 
//   parent's stdout and stderr.
141
 
// - If the first argument on the command line does not contain a slash,
142
 
//   PATH will be searched.  (See man execvp.)
143
 
BASE_EXPORT bool LaunchProcess(const CommandLine& cmdline,
144
 
                               const LaunchOptions& options,
145
 
                               ProcessHandle* process_handle);
146
 
 
147
 
#if defined(OS_WIN)
148
 
// Windows-specific LaunchProcess that takes the command line as a
149
 
// string.  Useful for situations where you need to control the
150
 
// command line arguments directly, but prefer the CommandLine version
151
 
// if launching Chrome itself.
152
 
//
153
 
// The first command line argument should be the path to the process,
154
 
// and don't forget to quote it.
155
 
//
156
 
// Example (including literal quotes)
157
 
//  cmdline = "c:\windows\explorer.exe" -foo "c:\bar\"
158
 
BASE_EXPORT bool LaunchProcess(const string16& cmdline,
159
 
                               const LaunchOptions& options,
160
 
                               win::ScopedHandle* process_handle);
161
 
 
162
 
// Launches a process with elevated privileges.  This does not behave exactly
163
 
// like LaunchProcess as it uses ShellExecuteEx instead of CreateProcess to
164
 
// create the process.  This means the process will have elevated privileges
165
 
// and thus some common operations like OpenProcess will fail. The process will
166
 
// be available through the |process_handle| argument.  Currently the only
167
 
// supported LaunchOptions are |start_hidden| and |wait|.
168
 
BASE_EXPORT bool LaunchElevatedProcess(const CommandLine& cmdline,
169
 
                                       const LaunchOptions& options,
170
 
                                       ProcessHandle* process_handle);
171
 
 
172
 
#elif defined(OS_POSIX)
173
 
// A POSIX-specific version of LaunchProcess that takes an argv array
174
 
// instead of a CommandLine.  Useful for situations where you need to
175
 
// control the command line arguments directly, but prefer the
176
 
// CommandLine version if launching Chrome itself.
177
 
BASE_EXPORT bool LaunchProcess(const std::vector<std::string>& argv,
178
 
                               const LaunchOptions& options,
179
 
                               ProcessHandle* process_handle);
180
 
 
181
 
// Close all file descriptors, except those which are a destination in the
182
 
// given multimap. Only call this function in a child process where you know
183
 
// that there aren't any other threads.
184
 
BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
185
 
#endif  // defined(OS_POSIX)
186
 
 
187
 
#if defined(OS_WIN)
188
 
// Set |job_object|'s JOBOBJECT_EXTENDED_LIMIT_INFORMATION
189
 
// BasicLimitInformation.LimitFlags to |limit_flags|.
190
 
BASE_EXPORT bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags);
191
 
 
192
 
// Output multi-process printf, cout, cerr, etc to the cmd.exe console that ran
193
 
// chrome. This is not thread-safe: only call from main thread.
194
 
BASE_EXPORT void RouteStdioToConsole();
195
 
#endif  // defined(OS_WIN)
196
 
 
197
 
// Executes the application specified by |cl| and wait for it to exit. Stores
198
 
// the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
199
 
// on success (application launched and exited cleanly, with exit code
200
 
// indicating success).
201
 
BASE_EXPORT bool GetAppOutput(const CommandLine& cl, std::string* output);
202
 
 
203
 
#if defined(OS_WIN)
204
 
// A Windows-specific version of GetAppOutput that takes a command line string
205
 
// instead of a CommandLine object. Useful for situations where you need to
206
 
// control the command line arguments directly.
207
 
BASE_EXPORT bool GetAppOutput(const StringPiece16& cl, std::string* output);
208
 
#endif
209
 
 
210
 
#if defined(OS_POSIX)
211
 
// A POSIX-specific version of GetAppOutput that takes an argv array
212
 
// instead of a CommandLine.  Useful for situations where you need to
213
 
// control the command line arguments directly.
214
 
BASE_EXPORT bool GetAppOutput(const std::vector<std::string>& argv,
215
 
                              std::string* output);
216
 
 
217
 
// A restricted version of |GetAppOutput()| which (a) clears the environment,
218
 
// and (b) stores at most |max_output| bytes; also, it doesn't search the path
219
 
// for the command.
220
 
BASE_EXPORT bool GetAppOutputRestricted(const CommandLine& cl,
221
 
                                        std::string* output, size_t max_output);
222
 
 
223
 
// A version of |GetAppOutput()| which also returns the exit code of the
224
 
// executed command. Returns true if the application runs and exits cleanly. If
225
 
// this is the case the exit code of the application is available in
226
 
// |*exit_code|.
227
 
BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl,
228
 
                                          std::string* output, int* exit_code);
229
 
#endif  // defined(OS_POSIX)
230
 
 
231
 
// If supported on the platform, and the user has sufficent rights, increase
232
 
// the current process's scheduling priority to a high priority.
233
 
BASE_EXPORT void RaiseProcessToHighPriority();
234
 
 
235
 
#if defined(OS_MACOSX)
236
 
// Restore the default exception handler, setting it to Apple Crash Reporter
237
 
// (ReportCrash).  When forking and execing a new process, the child will
238
 
// inherit the parent's exception ports, which may be set to the Breakpad
239
 
// instance running inside the parent.  The parent's Breakpad instance should
240
 
// not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
241
 
// in the child after forking will restore the standard exception handler.
242
 
// See http://crbug.com/20371/ for more details.
243
 
void RestoreDefaultExceptionHandler();
244
 
#endif  // defined(OS_MACOSX)
245
 
 
246
 
}  // namespace base
247
 
 
248
 
#endif  // BASE_PROCESS_LAUNCH_H_