OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/common/mac/mock_launchd.h" | 5 #include "chrome/common/mac/mock_launchd.h" |
6 | 6 |
7 #include <CoreFoundation/CoreFoundation.h> | 7 #include <CoreFoundation/CoreFoundation.h> |
8 #include <sys/socket.h> | 8 #include <sys/socket.h> |
9 #include <sys/un.h> | 9 #include <sys/un.h> |
10 | 10 |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
76 base::StringPrintf(info_plist_format, | 76 base::StringPrintf(info_plist_format, |
77 name.c_str(), | 77 name.c_str(), |
78 name.c_str(), | 78 name.c_str(), |
79 version_info.Version().c_str()); | 79 version_info.Version().c_str()); |
80 len = info_plist_data.length(); | 80 len = info_plist_data.length(); |
81 if (file_util::WriteFile(info_plist, info_plist_data.c_str(), len) != len) { | 81 if (file_util::WriteFile(info_plist, info_plist_data.c_str(), len) != len) { |
82 return false; | 82 return false; |
83 } | 83 } |
84 const UInt8* bundle_root_path = | 84 const UInt8* bundle_root_path = |
85 reinterpret_cast<const UInt8*>(bundle_root->value().c_str()); | 85 reinterpret_cast<const UInt8*>(bundle_root->value().c_str()); |
86 base::mac::ScopedCFTypeRef<CFURLRef> url( | 86 base::ScopedCFTypeRef<CFURLRef> url( |
87 CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, | 87 CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, |
88 bundle_root_path, | 88 bundle_root_path, |
89 bundle_root->value().length(), | 89 bundle_root->value().length(), |
90 true)); | 90 true)); |
91 base::mac::ScopedCFTypeRef<CFBundleRef> bundle( | 91 base::ScopedCFTypeRef<CFBundleRef> bundle( |
92 CFBundleCreate(kCFAllocatorDefault, url)); | 92 CFBundleCreate(kCFAllocatorDefault, url)); |
93 return bundle.get(); | 93 return bundle.get(); |
94 } | 94 } |
95 | 95 |
96 MockLaunchd::MockLaunchd(const base::FilePath& file, | 96 MockLaunchd::MockLaunchd(const base::FilePath& file, |
97 base::MessageLoop* loop, | 97 base::MessageLoop* loop, |
98 bool create_socket, | 98 bool create_socket, |
99 bool as_service) | 99 bool as_service) |
100 : file_(file), | 100 : file_(file), |
101 message_loop_(loop), | 101 message_loop_(loop), |
(...skipping 17 matching lines...) Expand all Loading... |
119 } | 119 } |
120 | 120 |
121 CFDictionaryRef MockLaunchd::CopyExports() { | 121 CFDictionaryRef MockLaunchd::CopyExports() { |
122 if (!create_socket_) { | 122 if (!create_socket_) { |
123 ADD_FAILURE(); | 123 ADD_FAILURE(); |
124 return NULL; | 124 return NULL; |
125 } | 125 } |
126 | 126 |
127 CFStringRef env_var = | 127 CFStringRef env_var = |
128 base::mac::NSToCFCast(GetServiceProcessLaunchDSocketEnvVar()); | 128 base::mac::NSToCFCast(GetServiceProcessLaunchDSocketEnvVar()); |
129 base::mac::ScopedCFTypeRef<CFStringRef> socket_path( | 129 base::ScopedCFTypeRef<CFStringRef> socket_path(CFStringCreateWithCString( |
130 CFStringCreateWithCString(kCFAllocatorDefault, pipe_name_.c_str(), | 130 kCFAllocatorDefault, pipe_name_.c_str(), kCFStringEncodingUTF8)); |
131 kCFStringEncodingUTF8)); | |
132 const void *keys[] = { env_var }; | 131 const void *keys[] = { env_var }; |
133 const void *values[] = { socket_path }; | 132 const void *values[] = { socket_path }; |
134 COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match); | 133 COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match); |
135 return CFDictionaryCreate(kCFAllocatorDefault, | 134 return CFDictionaryCreate(kCFAllocatorDefault, |
136 keys, | 135 keys, |
137 values, | 136 values, |
138 arraysize(keys), | 137 arraysize(keys), |
139 &kCFTypeDictionaryKeyCallBacks, | 138 &kCFTypeDictionaryKeyCallBacks, |
140 &kCFTypeDictionaryValueCallBacks); | 139 &kCFTypeDictionaryValueCallBacks); |
141 } | 140 } |
142 | 141 |
143 CFDictionaryRef MockLaunchd::CopyJobDictionary(CFStringRef label) { | 142 CFDictionaryRef MockLaunchd::CopyJobDictionary(CFStringRef label) { |
144 if (!as_service_) { | 143 if (!as_service_) { |
145 scoped_ptr<MultiProcessLock> running_lock( | 144 scoped_ptr<MultiProcessLock> running_lock( |
146 TakeNamedLock(pipe_name_, false)); | 145 TakeNamedLock(pipe_name_, false)); |
147 if (running_lock.get()) | 146 if (running_lock.get()) |
148 return NULL; | 147 return NULL; |
149 } | 148 } |
150 | 149 |
151 CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM); | 150 CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM); |
152 CFStringRef program_pid = CFSTR(LAUNCH_JOBKEY_PID); | 151 CFStringRef program_pid = CFSTR(LAUNCH_JOBKEY_PID); |
153 const void *keys[] = { program, program_pid }; | 152 const void *keys[] = { program, program_pid }; |
154 base::mac::ScopedCFTypeRef<CFStringRef> path( | 153 base::ScopedCFTypeRef<CFStringRef> path( |
155 base::SysUTF8ToCFStringRef(file_.value())); | 154 base::SysUTF8ToCFStringRef(file_.value())); |
156 int process_id = base::GetCurrentProcId(); | 155 int process_id = base::GetCurrentProcId(); |
157 base::mac::ScopedCFTypeRef<CFNumberRef> pid( | 156 base::ScopedCFTypeRef<CFNumberRef> pid( |
158 CFNumberCreate(NULL, kCFNumberIntType, &process_id)); | 157 CFNumberCreate(NULL, kCFNumberIntType, &process_id)); |
159 const void *values[] = { path, pid }; | 158 const void *values[] = { path, pid }; |
160 COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match); | 159 COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match); |
161 return CFDictionaryCreate(kCFAllocatorDefault, | 160 return CFDictionaryCreate(kCFAllocatorDefault, |
162 keys, | 161 keys, |
163 values, | 162 values, |
164 arraysize(keys), | 163 arraysize(keys), |
165 &kCFTypeDictionaryKeyCallBacks, | 164 &kCFTypeDictionaryKeyCallBacks, |
166 &kCFTypeDictionaryValueCallBacks); | 165 &kCFTypeDictionaryValueCallBacks); |
167 } | 166 } |
168 | 167 |
169 CFDictionaryRef MockLaunchd::CopyDictionaryByCheckingIn(CFErrorRef* error) { | 168 CFDictionaryRef MockLaunchd::CopyDictionaryByCheckingIn(CFErrorRef* error) { |
170 checkin_called_ = true; | 169 checkin_called_ = true; |
171 CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM); | 170 CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM); |
172 CFStringRef program_args = CFSTR(LAUNCH_JOBKEY_PROGRAMARGUMENTS); | 171 CFStringRef program_args = CFSTR(LAUNCH_JOBKEY_PROGRAMARGUMENTS); |
173 base::mac::ScopedCFTypeRef<CFStringRef> path( | 172 base::ScopedCFTypeRef<CFStringRef> path( |
174 base::SysUTF8ToCFStringRef(file_.value())); | 173 base::SysUTF8ToCFStringRef(file_.value())); |
175 const void *array_values[] = { path.get() }; | 174 const void *array_values[] = { path.get() }; |
176 base::mac::ScopedCFTypeRef<CFArrayRef> args( | 175 base::ScopedCFTypeRef<CFArrayRef> args(CFArrayCreate( |
177 CFArrayCreate(kCFAllocatorDefault, | 176 kCFAllocatorDefault, array_values, 1, &kCFTypeArrayCallBacks)); |
178 array_values, | |
179 1, | |
180 &kCFTypeArrayCallBacks)); | |
181 | 177 |
182 if (!create_socket_) { | 178 if (!create_socket_) { |
183 const void *keys[] = { program, program_args }; | 179 const void *keys[] = { program, program_args }; |
184 const void *values[] = { path, args }; | 180 const void *values[] = { path, args }; |
185 COMPILE_ASSERT(arraysize(keys) == arraysize(values), | 181 COMPILE_ASSERT(arraysize(keys) == arraysize(values), |
186 array_sizes_must_match); | 182 array_sizes_must_match); |
187 return CFDictionaryCreate(kCFAllocatorDefault, | 183 return CFDictionaryCreate(kCFAllocatorDefault, |
188 keys, | 184 keys, |
189 values, | 185 values, |
190 arraysize(keys), | 186 arraysize(keys), |
(...skipping 12 matching lines...) Expand all Loading... |
203 base::strlcpy(unix_addr.sun_path, pipe_name_.c_str(), kMaxPipeNameLength); | 199 base::strlcpy(unix_addr.sun_path, pipe_name_.c_str(), kMaxPipeNameLength); |
204 DCHECK_EQ(pipe_name_.length(), path_len); | 200 DCHECK_EQ(pipe_name_.length(), path_len); |
205 unix_addr.sun_len = SUN_LEN(&unix_addr); | 201 unix_addr.sun_len = SUN_LEN(&unix_addr); |
206 | 202 |
207 CFSocketSignature signature; | 203 CFSocketSignature signature; |
208 signature.protocolFamily = PF_UNIX; | 204 signature.protocolFamily = PF_UNIX; |
209 signature.socketType = SOCK_STREAM; | 205 signature.socketType = SOCK_STREAM; |
210 signature.protocol = 0; | 206 signature.protocol = 0; |
211 size_t unix_addr_len = offsetof(struct sockaddr_un, | 207 size_t unix_addr_len = offsetof(struct sockaddr_un, |
212 sun_path) + path_len + 1; | 208 sun_path) + path_len + 1; |
213 base::mac::ScopedCFTypeRef<CFDataRef> address( | 209 base::ScopedCFTypeRef<CFDataRef> address( |
214 CFDataCreate(NULL, reinterpret_cast<UInt8*>(&unix_addr), unix_addr_len)); | 210 CFDataCreate(NULL, reinterpret_cast<UInt8*>(&unix_addr), unix_addr_len)); |
215 signature.address = address; | 211 signature.address = address; |
216 | 212 |
217 CFSocketRef socket = | 213 CFSocketRef socket = |
218 CFSocketCreateWithSocketSignature(NULL, &signature, 0, NULL, NULL); | 214 CFSocketCreateWithSocketSignature(NULL, &signature, 0, NULL, NULL); |
219 | 215 |
220 local_pipe = CFSocketGetNative(socket); | 216 local_pipe = CFSocketGetNative(socket); |
221 EXPECT_NE(-1, local_pipe); | 217 EXPECT_NE(-1, local_pipe); |
222 if (local_pipe == -1) { | 218 if (local_pipe == -1) { |
223 if (error) { | 219 if (error) { |
224 *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, | 220 *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, |
225 errno, NULL); | 221 errno, NULL); |
226 } | 222 } |
227 return NULL; | 223 return NULL; |
228 } | 224 } |
229 | 225 |
230 base::mac::ScopedCFTypeRef<CFNumberRef> socket_fd( | 226 base::ScopedCFTypeRef<CFNumberRef> socket_fd( |
231 CFNumberCreate(NULL, kCFNumberIntType, &local_pipe)); | 227 CFNumberCreate(NULL, kCFNumberIntType, &local_pipe)); |
232 const void *socket_array_values[] = { socket_fd }; | 228 const void *socket_array_values[] = { socket_fd }; |
233 base::mac::ScopedCFTypeRef<CFArrayRef> sockets( | 229 base::ScopedCFTypeRef<CFArrayRef> sockets(CFArrayCreate( |
234 CFArrayCreate(kCFAllocatorDefault, | 230 kCFAllocatorDefault, socket_array_values, 1, &kCFTypeArrayCallBacks)); |
235 socket_array_values, | |
236 1, | |
237 &kCFTypeArrayCallBacks)); | |
238 CFStringRef socket_dict_key = CFSTR("ServiceProcessSocket"); | 231 CFStringRef socket_dict_key = CFSTR("ServiceProcessSocket"); |
239 const void *socket_keys[] = { socket_dict_key }; | 232 const void *socket_keys[] = { socket_dict_key }; |
240 const void *socket_values[] = { sockets }; | 233 const void *socket_values[] = { sockets }; |
241 COMPILE_ASSERT(arraysize(socket_keys) == arraysize(socket_values), | 234 COMPILE_ASSERT(arraysize(socket_keys) == arraysize(socket_values), |
242 socket_array_sizes_must_match); | 235 socket_array_sizes_must_match); |
243 base::mac::ScopedCFTypeRef<CFDictionaryRef> socket_dict( | 236 base::ScopedCFTypeRef<CFDictionaryRef> socket_dict( |
244 CFDictionaryCreate(kCFAllocatorDefault, | 237 CFDictionaryCreate(kCFAllocatorDefault, |
245 socket_keys, | 238 socket_keys, |
246 socket_values, | 239 socket_values, |
247 arraysize(socket_keys), | 240 arraysize(socket_keys), |
248 &kCFTypeDictionaryKeyCallBacks, | 241 &kCFTypeDictionaryKeyCallBacks, |
249 &kCFTypeDictionaryValueCallBacks)); | 242 &kCFTypeDictionaryValueCallBacks)); |
250 const void *keys[] = { program, program_args, socket_key }; | 243 const void *keys[] = { program, program_args, socket_key }; |
251 const void *values[] = { path, args, socket_dict }; | 244 const void *values[] = { path, args, socket_dict }; |
252 COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match); | 245 COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match); |
253 return CFDictionaryCreate(kCFAllocatorDefault, | 246 return CFDictionaryCreate(kCFAllocatorDefault, |
(...skipping 16 matching lines...) Expand all Loading... |
270 CFStringRef session_type) { | 263 CFStringRef session_type) { |
271 restart_called_ = true; | 264 restart_called_ = true; |
272 message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure()); | 265 message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure()); |
273 return true; | 266 return true; |
274 } | 267 } |
275 | 268 |
276 CFMutableDictionaryRef MockLaunchd::CreatePlistFromFile( | 269 CFMutableDictionaryRef MockLaunchd::CreatePlistFromFile( |
277 Domain domain, | 270 Domain domain, |
278 Type type, | 271 Type type, |
279 CFStringRef name) { | 272 CFStringRef name) { |
280 base::mac::ScopedCFTypeRef<CFDictionaryRef> dict( | 273 base::ScopedCFTypeRef<CFDictionaryRef> dict(CopyDictionaryByCheckingIn(NULL)); |
281 CopyDictionaryByCheckingIn(NULL)); | |
282 return CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, dict); | 274 return CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, dict); |
283 } | 275 } |
284 | 276 |
285 bool MockLaunchd::WritePlistToFile(Domain domain, | 277 bool MockLaunchd::WritePlistToFile(Domain domain, |
286 Type type, | 278 Type type, |
287 CFStringRef name, | 279 CFStringRef name, |
288 CFDictionaryRef dict) { | 280 CFDictionaryRef dict) { |
289 write_called_ = true; | 281 write_called_ = true; |
290 return true; | 282 return true; |
291 } | 283 } |
292 | 284 |
293 bool MockLaunchd::DeletePlist(Domain domain, | 285 bool MockLaunchd::DeletePlist(Domain domain, |
294 Type type, | 286 Type type, |
295 CFStringRef name) { | 287 CFStringRef name) { |
296 delete_called_ = true; | 288 delete_called_ = true; |
297 return true; | 289 return true; |
298 } | 290 } |
299 | 291 |
300 void MockLaunchd::SignalReady() { | 292 void MockLaunchd::SignalReady() { |
301 ASSERT_TRUE(as_service_); | 293 ASSERT_TRUE(as_service_); |
302 running_lock_.reset(TakeNamedLock(pipe_name_, true)); | 294 running_lock_.reset(TakeNamedLock(pipe_name_, true)); |
303 } | 295 } |
OLD | NEW |