OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 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/browser/extensions/api/webrtc_logging_private/webrtc_logging_pr
ivate_api.h" | 5 #include "chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_pr
ivate_api.h" |
6 | 6 |
7 #include "base/command_line.h" | 7 #include "base/command_line.h" |
8 #include "base/hash.h" | 8 #include "base/hash.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 144 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
145 api::webrtc_logging_private::AudioDebugRecordingsInfo result; | 145 api::webrtc_logging_private::AudioDebugRecordingsInfo result; |
146 result.prefix_path = prefix_path; | 146 result.prefix_path = prefix_path; |
147 result.did_stop = did_stop; | 147 result.did_stop = did_stop; |
148 result.did_manual_stop = did_manual_stop; | 148 result.did_manual_stop = did_manual_stop; |
149 SetResult(result.ToValue().release()); | 149 SetResult(result.ToValue().release()); |
150 SendResponse(true); | 150 SendResponse(true); |
151 } | 151 } |
152 | 152 |
153 bool WebrtcLoggingPrivateSetMetaDataFunction::RunAsync() { | 153 bool WebrtcLoggingPrivateSetMetaDataFunction::RunAsync() { |
154 scoped_ptr<SetMetaData::Params> params(SetMetaData::Params::Create(*args_)); | 154 std::unique_ptr<SetMetaData::Params> params( |
| 155 SetMetaData::Params::Create(*args_)); |
155 EXTENSION_FUNCTION_VALIDATE(params.get()); | 156 EXTENSION_FUNCTION_VALIDATE(params.get()); |
156 | 157 |
157 WebRtcLoggingHandlerHost::GenericDoneCallback callback; | 158 WebRtcLoggingHandlerHost::GenericDoneCallback callback; |
158 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = | 159 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = |
159 PrepareTask(params->request, params->security_origin, &callback); | 160 PrepareTask(params->request, params->security_origin, &callback); |
160 if (!webrtc_logging_handler_host.get()) | 161 if (!webrtc_logging_handler_host.get()) |
161 return false; | 162 return false; |
162 | 163 |
163 scoped_ptr<MetaDataMap> meta_data(new MetaDataMap()); | 164 std::unique_ptr<MetaDataMap> meta_data(new MetaDataMap()); |
164 for (const MetaDataEntry& entry : params->meta_data) | 165 for (const MetaDataEntry& entry : params->meta_data) |
165 (*meta_data.get())[entry.key] = entry.value; | 166 (*meta_data.get())[entry.key] = entry.value; |
166 | 167 |
167 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 168 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
168 &WebRtcLoggingHandlerHost::SetMetaData, webrtc_logging_handler_host, | 169 &WebRtcLoggingHandlerHost::SetMetaData, webrtc_logging_handler_host, |
169 base::Passed(&meta_data), callback)); | 170 base::Passed(&meta_data), callback)); |
170 | 171 |
171 return true; | 172 return true; |
172 } | 173 } |
173 | 174 |
174 bool WebrtcLoggingPrivateStartFunction::RunAsync() { | 175 bool WebrtcLoggingPrivateStartFunction::RunAsync() { |
175 scoped_ptr<Start::Params> params(Start::Params::Create(*args_)); | 176 std::unique_ptr<Start::Params> params(Start::Params::Create(*args_)); |
176 EXTENSION_FUNCTION_VALIDATE(params.get()); | 177 EXTENSION_FUNCTION_VALIDATE(params.get()); |
177 | 178 |
178 WebRtcLoggingHandlerHost::GenericDoneCallback callback; | 179 WebRtcLoggingHandlerHost::GenericDoneCallback callback; |
179 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = | 180 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = |
180 PrepareTask(params->request, params->security_origin, &callback); | 181 PrepareTask(params->request, params->security_origin, &callback); |
181 if (!webrtc_logging_handler_host.get()) | 182 if (!webrtc_logging_handler_host.get()) |
182 return false; | 183 return false; |
183 | 184 |
184 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 185 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
185 &WebRtcLoggingHandlerHost::StartLogging, webrtc_logging_handler_host, | 186 &WebRtcLoggingHandlerHost::StartLogging, webrtc_logging_handler_host, |
186 callback)); | 187 callback)); |
187 | 188 |
188 return true; | 189 return true; |
189 } | 190 } |
190 | 191 |
191 bool WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::RunAsync() { | 192 bool WebrtcLoggingPrivateSetUploadOnRenderCloseFunction::RunAsync() { |
192 scoped_ptr<SetUploadOnRenderClose::Params> params( | 193 std::unique_ptr<SetUploadOnRenderClose::Params> params( |
193 SetUploadOnRenderClose::Params::Create(*args_)); | 194 SetUploadOnRenderClose::Params::Create(*args_)); |
194 EXTENSION_FUNCTION_VALIDATE(params.get()); | 195 EXTENSION_FUNCTION_VALIDATE(params.get()); |
195 | 196 |
196 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host( | 197 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host( |
197 LoggingHandlerFromRequest(params->request, params->security_origin)); | 198 LoggingHandlerFromRequest(params->request, params->security_origin)); |
198 if (!webrtc_logging_handler_host.get()) | 199 if (!webrtc_logging_handler_host.get()) |
199 return false; | 200 return false; |
200 | 201 |
201 webrtc_logging_handler_host->set_upload_log_on_render_close( | 202 webrtc_logging_handler_host->set_upload_log_on_render_close( |
202 params->should_upload); | 203 params->should_upload); |
203 | 204 |
204 return true; | 205 return true; |
205 } | 206 } |
206 | 207 |
207 bool WebrtcLoggingPrivateStopFunction::RunAsync() { | 208 bool WebrtcLoggingPrivateStopFunction::RunAsync() { |
208 scoped_ptr<Stop::Params> params(Stop::Params::Create(*args_)); | 209 std::unique_ptr<Stop::Params> params(Stop::Params::Create(*args_)); |
209 EXTENSION_FUNCTION_VALIDATE(params.get()); | 210 EXTENSION_FUNCTION_VALIDATE(params.get()); |
210 | 211 |
211 WebRtcLoggingHandlerHost::GenericDoneCallback callback; | 212 WebRtcLoggingHandlerHost::GenericDoneCallback callback; |
212 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = | 213 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = |
213 PrepareTask(params->request, params->security_origin, &callback); | 214 PrepareTask(params->request, params->security_origin, &callback); |
214 if (!webrtc_logging_handler_host.get()) | 215 if (!webrtc_logging_handler_host.get()) |
215 return false; | 216 return false; |
216 | 217 |
217 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 218 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
218 &WebRtcLoggingHandlerHost::StopLogging, webrtc_logging_handler_host, | 219 &WebRtcLoggingHandlerHost::StopLogging, webrtc_logging_handler_host, |
219 callback)); | 220 callback)); |
220 | 221 |
221 return true; | 222 return true; |
222 } | 223 } |
223 | 224 |
224 bool WebrtcLoggingPrivateStoreFunction::RunAsync() { | 225 bool WebrtcLoggingPrivateStoreFunction::RunAsync() { |
225 scoped_ptr<Store::Params> params(Store::Params::Create(*args_)); | 226 std::unique_ptr<Store::Params> params(Store::Params::Create(*args_)); |
226 EXTENSION_FUNCTION_VALIDATE(params.get()); | 227 EXTENSION_FUNCTION_VALIDATE(params.get()); |
227 | 228 |
228 WebRtcLoggingHandlerHost::GenericDoneCallback callback; | 229 WebRtcLoggingHandlerHost::GenericDoneCallback callback; |
229 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = | 230 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = |
230 PrepareTask(params->request, params->security_origin, &callback); | 231 PrepareTask(params->request, params->security_origin, &callback); |
231 if (!webrtc_logging_handler_host.get()) | 232 if (!webrtc_logging_handler_host.get()) |
232 return false; | 233 return false; |
233 | 234 |
234 const std::string local_log_id(HashIdWithOrigin(params->security_origin, | 235 const std::string local_log_id(HashIdWithOrigin(params->security_origin, |
235 params->log_id)); | 236 params->log_id)); |
236 | 237 |
237 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 238 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
238 &WebRtcLoggingHandlerHost::StoreLog, | 239 &WebRtcLoggingHandlerHost::StoreLog, |
239 webrtc_logging_handler_host, local_log_id, callback)); | 240 webrtc_logging_handler_host, local_log_id, callback)); |
240 | 241 |
241 return true; | 242 return true; |
242 } | 243 } |
243 | 244 |
244 bool WebrtcLoggingPrivateUploadStoredFunction::RunAsync() { | 245 bool WebrtcLoggingPrivateUploadStoredFunction::RunAsync() { |
245 scoped_ptr<UploadStored::Params> params(UploadStored::Params::Create(*args_)); | 246 std::unique_ptr<UploadStored::Params> params( |
| 247 UploadStored::Params::Create(*args_)); |
246 EXTENSION_FUNCTION_VALIDATE(params.get()); | 248 EXTENSION_FUNCTION_VALIDATE(params.get()); |
247 | 249 |
248 scoped_refptr<WebRtcLoggingHandlerHost> logging_handler( | 250 scoped_refptr<WebRtcLoggingHandlerHost> logging_handler( |
249 LoggingHandlerFromRequest(params->request, params->security_origin)); | 251 LoggingHandlerFromRequest(params->request, params->security_origin)); |
250 if (!logging_handler.get()) | 252 if (!logging_handler.get()) |
251 return false; | 253 return false; |
252 | 254 |
253 WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind( | 255 WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind( |
254 &WebrtcLoggingPrivateUploadStoredFunction::FireCallback, this); | 256 &WebrtcLoggingPrivateUploadStoredFunction::FireCallback, this); |
255 | 257 |
256 const std::string local_log_id(HashIdWithOrigin(params->security_origin, | 258 const std::string local_log_id(HashIdWithOrigin(params->security_origin, |
257 params->log_id)); | 259 params->log_id)); |
258 | 260 |
259 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 261 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
260 &WebRtcLoggingHandlerHost::UploadStoredLog, logging_handler, local_log_id, | 262 &WebRtcLoggingHandlerHost::UploadStoredLog, logging_handler, local_log_id, |
261 callback)); | 263 callback)); |
262 | 264 |
263 return true; | 265 return true; |
264 } | 266 } |
265 | 267 |
266 bool WebrtcLoggingPrivateUploadFunction::RunAsync() { | 268 bool WebrtcLoggingPrivateUploadFunction::RunAsync() { |
267 scoped_ptr<Upload::Params> params(Upload::Params::Create(*args_)); | 269 std::unique_ptr<Upload::Params> params(Upload::Params::Create(*args_)); |
268 EXTENSION_FUNCTION_VALIDATE(params.get()); | 270 EXTENSION_FUNCTION_VALIDATE(params.get()); |
269 | 271 |
270 scoped_refptr<WebRtcLoggingHandlerHost> logging_handler( | 272 scoped_refptr<WebRtcLoggingHandlerHost> logging_handler( |
271 LoggingHandlerFromRequest(params->request, params->security_origin)); | 273 LoggingHandlerFromRequest(params->request, params->security_origin)); |
272 if (!logging_handler.get()) | 274 if (!logging_handler.get()) |
273 return false; | 275 return false; |
274 | 276 |
275 WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind( | 277 WebRtcLoggingHandlerHost::UploadDoneCallback callback = base::Bind( |
276 &WebrtcLoggingPrivateUploadFunction::FireCallback, this); | 278 &WebrtcLoggingPrivateUploadFunction::FireCallback, this); |
277 | 279 |
278 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 280 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
279 &WebRtcLoggingHandlerHost::UploadLog, logging_handler, callback)); | 281 &WebRtcLoggingHandlerHost::UploadLog, logging_handler, callback)); |
280 | 282 |
281 return true; | 283 return true; |
282 } | 284 } |
283 | 285 |
284 bool WebrtcLoggingPrivateDiscardFunction::RunAsync() { | 286 bool WebrtcLoggingPrivateDiscardFunction::RunAsync() { |
285 scoped_ptr<Discard::Params> params(Discard::Params::Create(*args_)); | 287 std::unique_ptr<Discard::Params> params(Discard::Params::Create(*args_)); |
286 EXTENSION_FUNCTION_VALIDATE(params.get()); | 288 EXTENSION_FUNCTION_VALIDATE(params.get()); |
287 | 289 |
288 WebRtcLoggingHandlerHost::GenericDoneCallback callback; | 290 WebRtcLoggingHandlerHost::GenericDoneCallback callback; |
289 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = | 291 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host = |
290 PrepareTask(params->request, params->security_origin, &callback); | 292 PrepareTask(params->request, params->security_origin, &callback); |
291 if (!webrtc_logging_handler_host.get()) | 293 if (!webrtc_logging_handler_host.get()) |
292 return false; | 294 return false; |
293 | 295 |
294 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( | 296 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind( |
295 &WebRtcLoggingHandlerHost::DiscardLog, webrtc_logging_handler_host, | 297 &WebRtcLoggingHandlerHost::DiscardLog, webrtc_logging_handler_host, |
296 callback)); | 298 callback)); |
297 | 299 |
298 return true; | 300 return true; |
299 } | 301 } |
300 | 302 |
301 bool WebrtcLoggingPrivateStartRtpDumpFunction::RunAsync() { | 303 bool WebrtcLoggingPrivateStartRtpDumpFunction::RunAsync() { |
302 scoped_ptr<StartRtpDump::Params> params(StartRtpDump::Params::Create(*args_)); | 304 std::unique_ptr<StartRtpDump::Params> params( |
| 305 StartRtpDump::Params::Create(*args_)); |
303 EXTENSION_FUNCTION_VALIDATE(params.get()); | 306 EXTENSION_FUNCTION_VALIDATE(params.get()); |
304 | 307 |
305 if (!params->incoming && !params->outgoing) { | 308 if (!params->incoming && !params->outgoing) { |
306 FireCallback(false, "Either incoming or outgoing must be true."); | 309 FireCallback(false, "Either incoming or outgoing must be true."); |
307 return true; | 310 return true; |
308 } | 311 } |
309 | 312 |
310 RtpDumpType type = | 313 RtpDumpType type = |
311 (params->incoming && params->outgoing) | 314 (params->incoming && params->outgoing) |
312 ? RTP_DUMP_BOTH | 315 ? RTP_DUMP_BOTH |
(...skipping 21 matching lines...) Expand all Loading... |
334 FROM_HERE, | 337 FROM_HERE, |
335 base::Bind(&WebRtcLoggingHandlerHost::StartRtpDump, | 338 base::Bind(&WebRtcLoggingHandlerHost::StartRtpDump, |
336 webrtc_logging_handler_host, | 339 webrtc_logging_handler_host, |
337 type, | 340 type, |
338 callback, | 341 callback, |
339 stop_callback)); | 342 stop_callback)); |
340 return true; | 343 return true; |
341 } | 344 } |
342 | 345 |
343 bool WebrtcLoggingPrivateStopRtpDumpFunction::RunAsync() { | 346 bool WebrtcLoggingPrivateStopRtpDumpFunction::RunAsync() { |
344 scoped_ptr<StopRtpDump::Params> params(StopRtpDump::Params::Create(*args_)); | 347 std::unique_ptr<StopRtpDump::Params> params( |
| 348 StopRtpDump::Params::Create(*args_)); |
345 EXTENSION_FUNCTION_VALIDATE(params.get()); | 349 EXTENSION_FUNCTION_VALIDATE(params.get()); |
346 | 350 |
347 if (!params->incoming && !params->outgoing) { | 351 if (!params->incoming && !params->outgoing) { |
348 FireCallback(false, "Either incoming or outgoing must be true."); | 352 FireCallback(false, "Either incoming or outgoing must be true."); |
349 return true; | 353 return true; |
350 } | 354 } |
351 | 355 |
352 RtpDumpType type = | 356 RtpDumpType type = |
353 (params->incoming && params->outgoing) | 357 (params->incoming && params->outgoing) |
354 ? RTP_DUMP_BOTH | 358 ? RTP_DUMP_BOTH |
(...skipping 18 matching lines...) Expand all Loading... |
373 callback)); | 377 callback)); |
374 return true; | 378 return true; |
375 } | 379 } |
376 | 380 |
377 bool WebrtcLoggingPrivateStartAudioDebugRecordingsFunction::RunAsync() { | 381 bool WebrtcLoggingPrivateStartAudioDebugRecordingsFunction::RunAsync() { |
378 if (!base::CommandLine::ForCurrentProcess()->HasSwitch( | 382 if (!base::CommandLine::ForCurrentProcess()->HasSwitch( |
379 switches::kEnableAudioDebugRecordingsFromExtension)) { | 383 switches::kEnableAudioDebugRecordingsFromExtension)) { |
380 return false; | 384 return false; |
381 } | 385 } |
382 | 386 |
383 scoped_ptr<StartAudioDebugRecordings::Params> params( | 387 std::unique_ptr<StartAudioDebugRecordings::Params> params( |
384 StartAudioDebugRecordings::Params::Create(*args_)); | 388 StartAudioDebugRecordings::Params::Create(*args_)); |
385 EXTENSION_FUNCTION_VALIDATE(params.get()); | 389 EXTENSION_FUNCTION_VALIDATE(params.get()); |
386 | 390 |
387 if (params->seconds < 0) { | 391 if (params->seconds < 0) { |
388 FireErrorCallback("seconds must be greater than or equal to 0"); | 392 FireErrorCallback("seconds must be greater than or equal to 0"); |
389 return true; | 393 return true; |
390 } | 394 } |
391 | 395 |
392 content::RenderProcessHost* host = | 396 content::RenderProcessHost* host = |
393 RphFromRequest(params->request, params->security_origin); | 397 RphFromRequest(params->request, params->security_origin); |
(...skipping 13 matching lines...) Expand all Loading... |
407 this)); | 411 this)); |
408 return true; | 412 return true; |
409 } | 413 } |
410 | 414 |
411 bool WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::RunAsync() { | 415 bool WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::RunAsync() { |
412 if (!base::CommandLine::ForCurrentProcess()->HasSwitch( | 416 if (!base::CommandLine::ForCurrentProcess()->HasSwitch( |
413 switches::kEnableAudioDebugRecordingsFromExtension)) { | 417 switches::kEnableAudioDebugRecordingsFromExtension)) { |
414 return false; | 418 return false; |
415 } | 419 } |
416 | 420 |
417 scoped_ptr<StopAudioDebugRecordings::Params> params( | 421 std::unique_ptr<StopAudioDebugRecordings::Params> params( |
418 StopAudioDebugRecordings::Params::Create(*args_)); | 422 StopAudioDebugRecordings::Params::Create(*args_)); |
419 EXTENSION_FUNCTION_VALIDATE(params.get()); | 423 EXTENSION_FUNCTION_VALIDATE(params.get()); |
420 | 424 |
421 content::RenderProcessHost* host = | 425 content::RenderProcessHost* host = |
422 RphFromRequest(params->request, params->security_origin); | 426 RphFromRequest(params->request, params->security_origin); |
423 if (!host) | 427 if (!host) |
424 return false; | 428 return false; |
425 | 429 |
426 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host( | 430 scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host( |
427 base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host)); | 431 base::UserDataAdapter<WebRtcLoggingHandlerHost>::Get(host, host)); |
428 | 432 |
429 webrtc_logging_handler_host->StopAudioDebugRecordings( | 433 webrtc_logging_handler_host->StopAudioDebugRecordings( |
430 host, | 434 host, |
431 base::Bind( | 435 base::Bind( |
432 &WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::FireCallback, | 436 &WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::FireCallback, |
433 this), | 437 this), |
434 base::Bind(&WebrtcLoggingPrivateStopAudioDebugRecordingsFunction:: | 438 base::Bind(&WebrtcLoggingPrivateStopAudioDebugRecordingsFunction:: |
435 FireErrorCallback, | 439 FireErrorCallback, |
436 this)); | 440 this)); |
437 return true; | 441 return true; |
438 } | 442 } |
439 | 443 |
440 } // namespace extensions | 444 } // namespace extensions |
OLD | NEW |