]> git.pld-linux.org Git - packages/thunderbird.git/blob - format.patch
disable clang and gold by default
[packages/thunderbird.git] / format.patch
1
2 # HG changeset patch
3 # User Mike Hommey <mh+mozilla@glandium.org>
4 # Date 1566200940 0
5 # Node ID 42478b7856c0f10c862a1234e4e01040ee99deea
6 # Parent  6eccfe79d02f025ada20d121eda69cf0b7921f16
7 Bug 1531309 - Don't use __PRETTY_FUNCTION__ or __FUNCTION__ as format strings. r=sylvestre
8
9 __PRETTY_FUNCTION__ and __FUNCTION__ are not guaranteed to be a string
10 literal, and only string literals should be used as format strings. GCC
11 9 complains about this with -Werror=format-security.
12
13 Differential Revision: https://phabricator.services.mozilla.com/D42459
14
15 diff --git a/dom/media/systemservices/CamerasChild.cpp b/dom/media/systemservices/CamerasChild.cpp
16 --- a/dom/media/systemservices/CamerasChild.cpp
17 +++ b/dom/media/systemservices/CamerasChild.cpp
18 @@ -153,36 +153,36 @@ int CamerasChild::AddDeviceChangeCallbac
19  
20    // So here we setup camera engine via EnsureInitialized(aCapEngine)
21  
22    EnsureInitialized(CameraEngine);
23    return DeviceChangeCallback::AddDeviceChangeCallback(aCallback);
24  }
25  
26  mozilla::ipc::IPCResult CamerasChild::RecvReplyFailure(void) {
27 -  LOG((__PRETTY_FUNCTION__));
28 +  LOG(("%s", __PRETTY_FUNCTION__));
29    MonitorAutoLock monitor(mReplyMonitor);
30    mReceivedReply = true;
31    mReplySuccess = false;
32    monitor.Notify();
33    return IPC_OK();
34  }
35  
36  mozilla::ipc::IPCResult CamerasChild::RecvReplySuccess(void) {
37 -  LOG((__PRETTY_FUNCTION__));
38 +  LOG(("%s", __PRETTY_FUNCTION__));
39    MonitorAutoLock monitor(mReplyMonitor);
40    mReceivedReply = true;
41    mReplySuccess = true;
42    monitor.Notify();
43    return IPC_OK();
44  }
45  
46  mozilla::ipc::IPCResult CamerasChild::RecvReplyNumberOfCapabilities(
47      const int& numdev) {
48 -  LOG((__PRETTY_FUNCTION__));
49 +  LOG(("%s", __PRETTY_FUNCTION__));
50    MonitorAutoLock monitor(mReplyMonitor);
51    mReceivedReply = true;
52    mReplySuccess = true;
53    mReplyInteger = numdev;
54    monitor.Notify();
55    return IPC_OK();
56  }
57  
58 @@ -257,51 +257,51 @@ bool CamerasChild::DispatchToParent(nsIR
59    if (!mReplySuccess) {
60      return false;
61    }
62    return true;
63  }
64  
65  int CamerasChild::NumberOfCapabilities(CaptureEngine aCapEngine,
66                                         const char* deviceUniqueIdUTF8) {
67 -  LOG((__PRETTY_FUNCTION__));
68 +  LOG(("%s", __PRETTY_FUNCTION__));
69    LOG(("NumberOfCapabilities for %s", deviceUniqueIdUTF8));
70    nsCString unique_id(deviceUniqueIdUTF8);
71    nsCOMPtr<nsIRunnable> runnable =
72        mozilla::NewRunnableMethod<CaptureEngine, nsCString>(
73            "camera::PCamerasChild::SendNumberOfCapabilities", this,
74            &CamerasChild::SendNumberOfCapabilities, aCapEngine, unique_id);
75    LockAndDispatch<> dispatcher(this, __func__, runnable, 0, mReplyInteger);
76    LOG(("Capture capability count: %d", dispatcher.ReturnValue()));
77    return dispatcher.ReturnValue();
78  }
79  
80  int CamerasChild::NumberOfCaptureDevices(CaptureEngine aCapEngine) {
81 -  LOG((__PRETTY_FUNCTION__));
82 +  LOG(("%s", __PRETTY_FUNCTION__));
83    nsCOMPtr<nsIRunnable> runnable = mozilla::NewRunnableMethod<CaptureEngine>(
84        "camera::PCamerasChild::SendNumberOfCaptureDevices", this,
85        &CamerasChild::SendNumberOfCaptureDevices, aCapEngine);
86    LockAndDispatch<> dispatcher(this, __func__, runnable, 0, mReplyInteger);
87    LOG(("Capture Devices: %d", dispatcher.ReturnValue()));
88    return dispatcher.ReturnValue();
89  }
90  
91  mozilla::ipc::IPCResult CamerasChild::RecvReplyNumberOfCaptureDevices(
92      const int& numdev) {
93 -  LOG((__PRETTY_FUNCTION__));
94 +  LOG(("%s", __PRETTY_FUNCTION__));
95    MonitorAutoLock monitor(mReplyMonitor);
96    mReceivedReply = true;
97    mReplySuccess = true;
98    mReplyInteger = numdev;
99    monitor.Notify();
100    return IPC_OK();
101  }
102  
103  int CamerasChild::EnsureInitialized(CaptureEngine aCapEngine) {
104 -  LOG((__PRETTY_FUNCTION__));
105 +  LOG(("%s", __PRETTY_FUNCTION__));
106    nsCOMPtr<nsIRunnable> runnable = mozilla::NewRunnableMethod<CaptureEngine>(
107        "camera::PCamerasChild::SendEnsureInitialized", this,
108        &CamerasChild::SendEnsureInitialized, aCapEngine);
109    LockAndDispatch<> dispatcher(this, __func__, runnable, 0, mReplyInteger);
110    LOG(("Capture Devices: %d", dispatcher.ReturnValue()));
111    return dispatcher.ReturnValue();
112  }
113  
114 @@ -320,17 +320,17 @@ int CamerasChild::GetCaptureCapability(
115    if (dispatcher.Success()) {
116      capability = mReplyCapability;
117    }
118    return dispatcher.ReturnValue();
119  }
120  
121  mozilla::ipc::IPCResult CamerasChild::RecvReplyGetCaptureCapability(
122      const VideoCaptureCapability& ipcCapability) {
123 -  LOG((__PRETTY_FUNCTION__));
124 +  LOG(("%s", __PRETTY_FUNCTION__));
125    MonitorAutoLock monitor(mReplyMonitor);
126    mReceivedReply = true;
127    mReplySuccess = true;
128    mReplyCapability.width = ipcCapability.width();
129    mReplyCapability.height = ipcCapability.height();
130    mReplyCapability.maxFPS = ipcCapability.maxFPS();
131    mReplyCapability.videoType =
132        static_cast<webrtc::VideoType>(ipcCapability.videoType());
133 @@ -338,17 +338,17 @@ mozilla::ipc::IPCResult CamerasChild::Re
134    monitor.Notify();
135    return IPC_OK();
136  }
137  
138  int CamerasChild::GetCaptureDevice(
139      CaptureEngine aCapEngine, unsigned int list_number, char* device_nameUTF8,
140      const unsigned int device_nameUTF8Length, char* unique_idUTF8,
141      const unsigned int unique_idUTF8Length, bool* scary) {
142 -  LOG((__PRETTY_FUNCTION__));
143 +  LOG(("%s", __PRETTY_FUNCTION__));
144    nsCOMPtr<nsIRunnable> runnable =
145        mozilla::NewRunnableMethod<CaptureEngine, unsigned int>(
146            "camera::PCamerasChild::SendGetCaptureDevice", this,
147            &CamerasChild::SendGetCaptureDevice, aCapEngine, list_number);
148    LockAndDispatch<> dispatcher(this, __func__, runnable, -1, mZero);
149    if (dispatcher.Success()) {
150      base::strlcpy(device_nameUTF8, mReplyDeviceName.get(),
151                    device_nameUTF8Length);
152 @@ -359,32 +359,32 @@ int CamerasChild::GetCaptureDevice(
153      LOG(("Got %s name %s id", device_nameUTF8, unique_idUTF8));
154    }
155    return dispatcher.ReturnValue();
156  }
157  
158  mozilla::ipc::IPCResult CamerasChild::RecvReplyGetCaptureDevice(
159      const nsCString& device_name, const nsCString& device_id,
160      const bool& scary) {
161 -  LOG((__PRETTY_FUNCTION__));
162 +  LOG(("%s", __PRETTY_FUNCTION__));
163    MonitorAutoLock monitor(mReplyMonitor);
164    mReceivedReply = true;
165    mReplySuccess = true;
166    mReplyDeviceName = device_name;
167    mReplyDeviceID = device_id;
168    mReplyScary = scary;
169    monitor.Notify();
170    return IPC_OK();
171  }
172  
173  int CamerasChild::AllocateCaptureDevice(
174      CaptureEngine aCapEngine, const char* unique_idUTF8,
175      const unsigned int unique_idUTF8Length, int& aStreamId,
176      const mozilla::ipc::PrincipalInfo& aPrincipalInfo) {
177 -  LOG((__PRETTY_FUNCTION__));
178 +  LOG(("%s", __PRETTY_FUNCTION__));
179    nsCString unique_id(unique_idUTF8);
180    nsCOMPtr<nsIRunnable> runnable =
181        mozilla::NewRunnableMethod<CaptureEngine, nsCString,
182                                   const mozilla::ipc::PrincipalInfo&>(
183            "camera::PCamerasChild::SendAllocateCaptureDevice", this,
184            &CamerasChild::SendAllocateCaptureDevice, aCapEngine, unique_id,
185            aPrincipalInfo);
186    LockAndDispatch<> dispatcher(this, __func__, runnable, -1, mZero);
187 @@ -392,28 +392,28 @@ int CamerasChild::AllocateCaptureDevice(
188      LOG(("Capture Device allocated: %d", mReplyInteger));
189      aStreamId = mReplyInteger;
190    }
191    return dispatcher.ReturnValue();
192  }
193  
194  mozilla::ipc::IPCResult CamerasChild::RecvReplyAllocateCaptureDevice(
195      const int& numdev) {
196 -  LOG((__PRETTY_FUNCTION__));
197 +  LOG(("%s", __PRETTY_FUNCTION__));
198    MonitorAutoLock monitor(mReplyMonitor);
199    mReceivedReply = true;
200    mReplySuccess = true;
201    mReplyInteger = numdev;
202    monitor.Notify();
203    return IPC_OK();
204  }
205  
206  int CamerasChild::ReleaseCaptureDevice(CaptureEngine aCapEngine,
207                                         const int capture_id) {
208 -  LOG((__PRETTY_FUNCTION__));
209 +  LOG(("%s", __PRETTY_FUNCTION__));
210    nsCOMPtr<nsIRunnable> runnable =
211        mozilla::NewRunnableMethod<CaptureEngine, int>(
212            "camera::PCamerasChild::SendReleaseCaptureDevice", this,
213            &CamerasChild::SendReleaseCaptureDevice, aCapEngine, capture_id);
214    LockAndDispatch<> dispatcher(this, __func__, runnable, -1, mZero);
215    return dispatcher.ReturnValue();
216  }
217  
218 @@ -437,42 +437,42 @@ void CamerasChild::RemoveCallback(const 
219        break;
220      }
221    }
222  }
223  
224  int CamerasChild::StartCapture(CaptureEngine aCapEngine, const int capture_id,
225                                 webrtc::VideoCaptureCapability& webrtcCaps,
226                                 FrameRelay* cb) {
227 -  LOG((__PRETTY_FUNCTION__));
228 +  LOG(("%s", __PRETTY_FUNCTION__));
229    AddCallback(aCapEngine, capture_id, cb);
230    VideoCaptureCapability capCap(
231        webrtcCaps.width, webrtcCaps.height, webrtcCaps.maxFPS,
232        static_cast<int>(webrtcCaps.videoType), webrtcCaps.interlaced);
233    nsCOMPtr<nsIRunnable> runnable =
234        mozilla::NewRunnableMethod<CaptureEngine, int, VideoCaptureCapability>(
235            "camera::PCamerasChild::SendStartCapture", this,
236            &CamerasChild::SendStartCapture, aCapEngine, capture_id, capCap);
237    LockAndDispatch<> dispatcher(this, __func__, runnable, -1, mZero);
238    return dispatcher.ReturnValue();
239  }
240  
241  int CamerasChild::FocusOnSelectedSource(CaptureEngine aCapEngine,
242                                          const int aCaptureId) {
243 -  LOG((__PRETTY_FUNCTION__));
244 +  LOG(("%s", __PRETTY_FUNCTION__));
245    nsCOMPtr<nsIRunnable> runnable =
246        mozilla::NewRunnableMethod<CaptureEngine, int>(
247            "camera::PCamerasChild::SendFocusOnSelectedSource", this,
248            &CamerasChild::SendFocusOnSelectedSource, aCapEngine, aCaptureId);
249    LockAndDispatch<> dispatcher(this, __func__, runnable, -1, mZero);
250    return dispatcher.ReturnValue();
251  }
252  
253  int CamerasChild::StopCapture(CaptureEngine aCapEngine, const int capture_id) {
254 -  LOG((__PRETTY_FUNCTION__));
255 +  LOG(("%s", __PRETTY_FUNCTION__));
256    nsCOMPtr<nsIRunnable> runnable =
257        mozilla::NewRunnableMethod<CaptureEngine, int>(
258            "camera::PCamerasChild::SendStopCapture", this,
259            &CamerasChild::SendStopCapture, aCapEngine, capture_id);
260    LockAndDispatch<> dispatcher(this, __func__, runnable, -1, mZero);
261    if (dispatcher.Success()) {
262      RemoveCallback(aCapEngine, capture_id);
263    }
264 diff --git a/dom/media/systemservices/CamerasParent.cpp b/dom/media/systemservices/CamerasParent.cpp
265 --- a/dom/media/systemservices/CamerasParent.cpp
266 +++ b/dom/media/systemservices/CamerasParent.cpp
267 @@ -97,17 +97,17 @@ StaticMutex CamerasParent::sMutex;
268  // - the IPC thread on which PBackground is running and which receives and
269  //   sends messages
270  // - a thread which will execute the actual (possibly slow) camera access
271  //   called "VideoCapture". On Windows this is a thread with an event loop
272  //   suitable for UI access.
273  
274  // InputObserver is owned by CamerasParent, and it has a ref to CamerasParent
275  void InputObserver::OnDeviceChange() {
276 -  LOG((__PRETTY_FUNCTION__));
277 +  LOG(("%s", __PRETTY_FUNCTION__));
278    MOZ_ASSERT(mParent);
279  
280    RefPtr<InputObserver> self(this);
281    RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self]() {
282      if (self->mParent->IsShuttingDown()) {
283        return NS_ERROR_FAILURE;
284      }
285      Unused << self->mParent->SendDeviceChange();
286 @@ -196,17 +196,17 @@ nsresult CamerasParent::DispatchToVideoC
287    if (!sVideoCaptureThread || !sVideoCaptureThread->IsRunning()) {
288      return NS_ERROR_FAILURE;
289    }
290    sVideoCaptureThread->message_loop()->PostTask(event.forget());
291    return NS_OK;
292  }
293  
294  void CamerasParent::StopVideoCapture() {
295 -  LOG((__PRETTY_FUNCTION__));
296 +  LOG(("%s", __PRETTY_FUNCTION__));
297    // We are called from the main thread (xpcom-shutdown) or
298    // from PBackground (when the Actor shuts down).
299    // Shut down the WebRTC stack (on the capture thread)
300    RefPtr<CamerasParent> self(this);
301    DebugOnly<nsresult> rv =
302        DispatchToVideoCaptureThread(NewRunnableFrom([self]() {
303          MonitorAutoLock lock(*(self->sThreadMonitor));
304          self->CloseEngines();
305 @@ -278,17 +278,17 @@ int CamerasParent::DeliverFrameOverIPC(C
306    return 0;
307  }
308  
309  ShmemBuffer CamerasParent::GetBuffer(size_t aSize) {
310    return mShmemPool.GetIfAvailable(aSize);
311  }
312  
313  void CallbackHelper::OnFrame(const webrtc::VideoFrame& aVideoFrame) {
314 -  LOG_VERBOSE((__PRETTY_FUNCTION__));
315 +  LOG_VERBOSE(("%s", __PRETTY_FUNCTION__));
316    RefPtr<DeliverFrameRunnable> runnable = nullptr;
317    // Get frame properties
318    camera::VideoFrameProperties properties;
319    VideoFrameUtils::InitFrameBufferProperties(aVideoFrame, properties);
320    // Get a shared memory buffer to copy the frame data into
321    ShmemBuffer shMemBuffer = mParent->GetBuffer(properties.bufferSize());
322    if (!shMemBuffer.Valid()) {
323      // Either we ran out of buffers or they're not the right size yet
324 @@ -314,17 +314,17 @@ void CallbackHelper::OnFrame(const webrt
325  
326  mozilla::ipc::IPCResult CamerasParent::RecvReleaseFrame(
327      mozilla::ipc::Shmem&& s) {
328    mShmemPool.Put(ShmemBuffer(s));
329    return IPC_OK();
330  }
331  
332  bool CamerasParent::SetupEngine(CaptureEngine aCapEngine) {
333 -  LOG((__PRETTY_FUNCTION__));
334 +  LOG(("%s", __PRETTY_FUNCTION__));
335    StaticRefPtr<VideoEngine>& engine = sEngines[aCapEngine];
336  
337    if (!engine) {
338      UniquePtr<webrtc::CaptureDeviceInfo> captureDeviceInfo;
339      auto config = MakeUnique<webrtc::Config>();
340  
341      switch (aCapEngine) {
342        case ScreenEngine:
343 @@ -366,17 +366,17 @@ bool CamerasParent::SetupEngine(CaptureE
344        device_info->RegisterVideoInputFeedBack(mCameraObserver);
345      }
346    }
347  
348    return true;
349  }
350  
351  void CamerasParent::CloseEngines() {
352 -  LOG((__PRETTY_FUNCTION__));
353 +  LOG(("%s", __PRETTY_FUNCTION__));
354    if (!mWebRTCAlive) {
355      return;
356    }
357    MOZ_ASSERT(sVideoCaptureThread->thread_id() == PlatformThread::CurrentId());
358  
359    // Stop the callers
360    while (mCallbacks.Length()) {
361      auto capEngine = mCallbacks[0]->mCapEngine;
362 @@ -406,17 +406,17 @@ void CamerasParent::CloseEngines() {
363        }
364      }
365    }
366  
367    mWebRTCAlive = false;
368  }
369  
370  VideoEngine* CamerasParent::EnsureInitialized(int aEngine) {
371 -  LOG_VERBOSE((__PRETTY_FUNCTION__));
372 +  LOG_VERBOSE(("%s", __PRETTY_FUNCTION__));
373    // We're shutting down, don't try to do new WebRTC ops.
374    if (!mWebRTCAlive) {
375      return nullptr;
376    }
377    CaptureEngine capEngine = static_cast<CaptureEngine>(aEngine);
378    if (!SetupEngine(capEngine)) {
379      LOG(("CamerasParent failed to initialize engine"));
380      return nullptr;
381 @@ -427,17 +427,17 @@ VideoEngine* CamerasParent::EnsureInitia
382  
383  // Dispatch the runnable to do the camera operation on the
384  // specific Cameras thread, preventing us from blocking, and
385  // chain a runnable to send back the result on the IPC thread.
386  // It would be nice to get rid of the code duplication here,
387  // perhaps via Promises.
388  mozilla::ipc::IPCResult CamerasParent::RecvNumberOfCaptureDevices(
389      const CaptureEngine& aCapEngine) {
390 -  LOG((__PRETTY_FUNCTION__));
391 +  LOG(("%s", __PRETTY_FUNCTION__));
392    LOG(("CaptureEngine=%d", aCapEngine));
393    RefPtr<CamerasParent> self(this);
394    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine]() {
395      int num = -1;
396      if (auto engine = self->EnsureInitialized(aCapEngine)) {
397        if (auto devInfo = engine->GetOrCreateVideoCaptureDeviceInfo()) {
398          num = devInfo->NumberOfDevices();
399        }
400 @@ -461,17 +461,17 @@ mozilla::ipc::IPCResult CamerasParent::R
401      return NS_OK;
402    });
403    DispatchToVideoCaptureThread(webrtc_runnable);
404    return IPC_OK();
405  }
406  
407  mozilla::ipc::IPCResult CamerasParent::RecvEnsureInitialized(
408      const CaptureEngine& aCapEngine) {
409 -  LOG((__PRETTY_FUNCTION__));
410 +  LOG(("%s", __PRETTY_FUNCTION__));
411  
412    RefPtr<CamerasParent> self(this);
413    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine]() {
414      bool result = self->EnsureInitialized(aCapEngine);
415  
416      RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, result]() {
417        if (!self->mChildIsAlive) {
418          return NS_ERROR_FAILURE;
419 @@ -491,17 +491,17 @@ mozilla::ipc::IPCResult CamerasParent::R
420      return NS_OK;
421    });
422    DispatchToVideoCaptureThread(webrtc_runnable);
423    return IPC_OK();
424  }
425  
426  mozilla::ipc::IPCResult CamerasParent::RecvNumberOfCapabilities(
427      const CaptureEngine& aCapEngine, const nsCString& unique_id) {
428 -  LOG((__PRETTY_FUNCTION__));
429 +  LOG(("%s", __PRETTY_FUNCTION__));
430    LOG(("Getting caps for %s", unique_id.get()));
431  
432    RefPtr<CamerasParent> self(this);
433    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, unique_id,
434                                                        aCapEngine]() {
435      int num = -1;
436      if (auto engine = self->EnsureInitialized(aCapEngine)) {
437        if (auto devInfo = engine->GetOrCreateVideoCaptureDeviceInfo()) {
438 @@ -528,17 +528,17 @@ mozilla::ipc::IPCResult CamerasParent::R
439    });
440    DispatchToVideoCaptureThread(webrtc_runnable);
441    return IPC_OK();
442  }
443  
444  mozilla::ipc::IPCResult CamerasParent::RecvGetCaptureCapability(
445      const CaptureEngine& aCapEngine, const nsCString& unique_id,
446      const int& num) {
447 -  LOG((__PRETTY_FUNCTION__));
448 +  LOG(("%s", __PRETTY_FUNCTION__));
449    LOG(("RecvGetCaptureCapability: %s %d", unique_id.get(), num));
450  
451    RefPtr<CamerasParent> self(this);
452    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, unique_id,
453                                                        aCapEngine, num]() {
454      webrtc::VideoCaptureCapability webrtcCaps;
455      int error = -1;
456      if (auto engine = self->EnsureInitialized(aCapEngine)) {
457 @@ -581,17 +581,17 @@ mozilla::ipc::IPCResult CamerasParent::R
458      return NS_OK;
459    });
460    DispatchToVideoCaptureThread(webrtc_runnable);
461    return IPC_OK();
462  }
463  
464  mozilla::ipc::IPCResult CamerasParent::RecvGetCaptureDevice(
465      const CaptureEngine& aCapEngine, const int& aListNumber) {
466 -  LOG((__PRETTY_FUNCTION__));
467 +  LOG(("%s", __PRETTY_FUNCTION__));
468  
469    RefPtr<CamerasParent> self(this);
470    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine,
471                                                        aListNumber]() {
472      char deviceName[MediaEngineSource::kMaxDeviceNameLength];
473      char deviceUniqueId[MediaEngineSource::kMaxUniqueIdLength];
474      nsCString name;
475      nsCString uniqueId;
476 @@ -751,17 +751,17 @@ int CamerasParent::ReleaseCaptureDevice(
477    if (auto engine = EnsureInitialized(aCapEngine)) {
478      error = engine->ReleaseVideoCapture(capnum);
479    }
480    return error;
481  }
482  
483  mozilla::ipc::IPCResult CamerasParent::RecvReleaseCaptureDevice(
484      const CaptureEngine& aCapEngine, const int& numdev) {
485 -  LOG((__PRETTY_FUNCTION__));
486 +  LOG(("%s", __PRETTY_FUNCTION__));
487    LOG(("RecvReleaseCamera device nr %d", numdev));
488  
489    RefPtr<CamerasParent> self(this);
490    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine,
491                                                        numdev]() {
492      int error = self->ReleaseCaptureDevice(aCapEngine, numdev);
493      RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, error, numdev]() {
494        if (!self->mChildIsAlive) {
495 @@ -783,22 +783,22 @@ mozilla::ipc::IPCResult CamerasParent::R
496    });
497    DispatchToVideoCaptureThread(webrtc_runnable);
498    return IPC_OK();
499  }
500  
501  mozilla::ipc::IPCResult CamerasParent::RecvStartCapture(
502      const CaptureEngine& aCapEngine, const int& capnum,
503      const VideoCaptureCapability& ipcCaps) {
504 -  LOG((__PRETTY_FUNCTION__));
505 +  LOG(("%s", __PRETTY_FUNCTION__));
506  
507    RefPtr<CamerasParent> self(this);
508    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine, capnum,
509                                                        ipcCaps]() {
510 -    LOG((__PRETTY_FUNCTION__));
511 +    LOG(("%s", __PRETTY_FUNCTION__));
512      CallbackHelper** cbh;
513      int error = -1;
514      if (self->EnsureInitialized(aCapEngine)) {
515        cbh = self->mCallbacks.AppendElement(new CallbackHelper(
516            static_cast<CaptureEngine>(aCapEngine), capnum, self));
517  
518        self->sEngines[aCapEngine]->WithEntry(
519            capnum, [&capnum, &aCapEngine, &error, &ipcCaps, &cbh,
520 @@ -910,17 +910,17 @@ mozilla::ipc::IPCResult CamerasParent::R
521      return NS_OK;
522    });
523    DispatchToVideoCaptureThread(webrtc_runnable);
524    return IPC_OK();
525  }
526  
527  mozilla::ipc::IPCResult CamerasParent::RecvFocusOnSelectedSource(
528      const CaptureEngine& aCapEngine, const int& aCapNum) {
529 -  LOG((__PRETTY_FUNCTION__));
530 +  LOG(("%s", __PRETTY_FUNCTION__));
531    RefPtr<Runnable> webrtc_runnable = NewRunnableFrom(
532        [self = RefPtr<CamerasParent>(this), aCapEngine, aCapNum]() {
533          if (auto engine = self->EnsureInitialized(aCapEngine)) {
534            engine->WithEntry(aCapNum, [self](VideoEngine::CaptureEntry& cap) {
535              if (cap.VideoCapture()) {
536                bool result = cap.VideoCapture()->FocusOnSelectedSource();
537                RefPtr<nsIRunnable> ipc_runnable =
538                    NewRunnableFrom([self, result]() {
539 @@ -972,17 +972,17 @@ void CamerasParent::StopCapture(const Ca
540          break;
541        }
542      }
543    }
544  }
545  
546  mozilla::ipc::IPCResult CamerasParent::RecvStopCapture(
547      const CaptureEngine& aCapEngine, const int& capnum) {
548 -  LOG((__PRETTY_FUNCTION__));
549 +  LOG(("%s", __PRETTY_FUNCTION__));
550  
551    RefPtr<CamerasParent> self(this);
552    RefPtr<Runnable> webrtc_runnable =
553        NewRunnableFrom([self, aCapEngine, capnum]() {
554          self->StopCapture(aCapEngine, capnum);
555          return NS_OK;
556        });
557    nsresult rv = DispatchToVideoCaptureThread(webrtc_runnable);
558 @@ -1010,29 +1010,29 @@ void CamerasParent::StopIPC() {
559    mShmemPool.Cleanup(this);
560    // We don't want to receive callbacks or anything if we can't
561    // forward them anymore anyway.
562    mChildIsAlive = false;
563    mDestroyed = true;
564  }
565  
566  mozilla::ipc::IPCResult CamerasParent::RecvAllDone() {
567 -  LOG((__PRETTY_FUNCTION__));
568 +  LOG(("%s", __PRETTY_FUNCTION__));
569    // Don't try to send anything to the child now
570    mChildIsAlive = false;
571    IProtocol* mgr = Manager();
572    if (!Send__delete__(this)) {
573      return IPC_FAIL_NO_REASON(mgr);
574    }
575    return IPC_OK();
576  }
577  
578  void CamerasParent::ActorDestroy(ActorDestroyReason aWhy) {
579    // No more IPC from here
580 -  LOG((__PRETTY_FUNCTION__));
581 +  LOG(("%s", __PRETTY_FUNCTION__));
582    StopIPC();
583    // Shut down WebRTC (if we're not in full shutdown, else this
584    // will already have happened)
585    StopVideoCapture();
586  }
587  
588  nsString CamerasParent::GetNewName() {
589    static volatile uint64_t counter = 0;
590 diff --git a/dom/media/systemservices/MediaParent.cpp b/dom/media/systemservices/MediaParent.cpp
591 --- a/dom/media/systemservices/MediaParent.cpp
592 +++ b/dom/media/systemservices/MediaParent.cpp
593 @@ -373,17 +373,17 @@ class OriginKeyStore : public nsISupport
594     private:
595      nsCOMPtr<nsIFile> mProfileDir;
596    };
597  
598   private:
599    virtual ~OriginKeyStore() {
600      StaticMutexAutoLock lock(sOriginKeyStoreMutex);
601      sOriginKeyStore = nullptr;
602 -    LOG((__FUNCTION__));
603 +    LOG(("%s", __FUNCTION__));
604    }
605  
606   public:
607    static OriginKeyStore* Get() {
608      MOZ_ASSERT(NS_IsMainThread());
609      StaticMutexAutoLock lock(sOriginKeyStoreMutex);
610      if (!sOriginKeyStore) {
611        sOriginKeyStore = new OriginKeyStore();
612 @@ -504,17 +504,17 @@ mozilla::ipc::IPCResult Parent<Super>::R
613    }
614    return IPC_OK();
615  }
616  
617  template <class Super>
618  void Parent<Super>::ActorDestroy(ActorDestroyReason aWhy) {
619    // No more IPC from here
620    mDestroyed = true;
621 -  LOG((__FUNCTION__));
622 +  LOG(("%s", __FUNCTION__));
623  }
624  
625  template <class Super>
626  Parent<Super>::Parent()
627      : mOriginKeyStore(OriginKeyStore::Get()), mDestroyed(false) {
628    LOG(("media::Parent: %p", this));
629  }
630  
631 diff --git a/dom/media/systemservices/VideoEngine.cpp b/dom/media/systemservices/VideoEngine.cpp
632 --- a/dom/media/systemservices/VideoEngine.cpp
633 +++ b/dom/media/systemservices/VideoEngine.cpp
634 @@ -23,17 +23,17 @@ namespace camera {
635  #undef LOG_ENABLED
636  mozilla::LazyLogModule gVideoEngineLog("VideoEngine");
637  #define LOG(args) MOZ_LOG(gVideoEngineLog, mozilla::LogLevel::Debug, args)
638  #define LOG_ENABLED() MOZ_LOG_TEST(gVideoEngineLog, mozilla::LogLevel::Debug)
639  
640  int VideoEngine::sId = 0;
641  #if defined(ANDROID)
642  int VideoEngine::SetAndroidObjects() {
643 -  LOG((__PRETTY_FUNCTION__));
644 +  LOG(("%s", __PRETTY_FUNCTION__));
645  
646    JavaVM* const javaVM = mozilla::jni::GetVM();
647    if (!javaVM || webrtc::SetCaptureAndroidVM(javaVM) != 0) {
648      LOG(("Could not set capture Android VM"));
649      return -1;
650    }
651  #  ifdef WEBRTC_INCLUDE_INTERNAL_VIDEO_RENDER
652    if (webrtc::SetRenderAndroidVM(javaVM) != 0) {
653 @@ -42,17 +42,17 @@ int VideoEngine::SetAndroidObjects() {
654    }
655  #  endif
656    return 0;
657  }
658  #endif
659  
660  void VideoEngine::CreateVideoCapture(int32_t& id,
661                                       const char* deviceUniqueIdUTF8) {
662 -  LOG((__PRETTY_FUNCTION__));
663 +  LOG(("%s", __PRETTY_FUNCTION__));
664    MOZ_ASSERT(deviceUniqueIdUTF8);
665  
666    id = GenerateId();
667    LOG(("CaptureDeviceInfo.type=%s id=%d", mCaptureDevInfo.TypeName(), id));
668  
669    for (auto& it : mCaps) {
670      if (it.second.VideoCapture() &&
671          it.second.VideoCapture()->CurrentDeviceName() &&
672 @@ -135,17 +135,17 @@ int VideoEngine::ReleaseVideoCapture(con
673    }
674  
675    mIdMap.erase(id);
676    return found ? 0 : (-1);
677  }
678  
679  std::shared_ptr<webrtc::VideoCaptureModule::DeviceInfo>
680  VideoEngine::GetOrCreateVideoCaptureDeviceInfo() {
681 -  LOG((__PRETTY_FUNCTION__));
682 +  LOG(("%s", __PRETTY_FUNCTION__));
683    int64_t currentTime = 0;
684  
685    const char* capDevTypeName =
686        webrtc::CaptureDeviceInfo(mCaptureDevInfo.type).TypeName();
687  
688    if (mDeviceInfo) {
689      LOG(("Device cache available."));
690      // Camera cache is invalidated by HW change detection elsewhere
691 @@ -210,17 +210,17 @@ VideoEngine::GetOrCreateVideoCaptureDevi
692  }
693  
694  const UniquePtr<const webrtc::Config>& VideoEngine::GetConfiguration() {
695    return mConfig;
696  }
697  
698  already_AddRefed<VideoEngine> VideoEngine::Create(
699      UniquePtr<const webrtc::Config>&& aConfig) {
700 -  LOG((__PRETTY_FUNCTION__));
701 +  LOG(("%s", __PRETTY_FUNCTION__));
702    LOG(("Creating new VideoEngine with CaptureDeviceType %s",
703         aConfig->Get<webrtc::CaptureDeviceInfo>().TypeName()));
704    return do_AddRef(new VideoEngine(std::move(aConfig)));
705  }
706  
707  VideoEngine::CaptureEntry::CaptureEntry(
708      int32_t aCapnum, rtc::scoped_refptr<webrtc::VideoCaptureModule> aCapture)
709      : mCapnum(aCapnum), mVideoCaptureModule(aCapture) {}
710 @@ -258,13 +258,13 @@ int32_t VideoEngine::GenerateId() {
711    return mId = sId++;
712  }
713  
714  VideoEngine::VideoEngine(UniquePtr<const webrtc::Config>&& aConfig)
715      : mId(0),
716        mCaptureDevInfo(aConfig->Get<webrtc::CaptureDeviceInfo>()),
717        mDeviceInfo(nullptr),
718        mConfig(std::move(aConfig)) {
719 -  LOG((__PRETTY_FUNCTION__));
720 +  LOG(("%s", __PRETTY_FUNCTION__));
721  }
722  
723  }  // namespace camera
724  }  // namespace mozilla
725 diff --git a/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp b/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
726 --- a/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
727 +++ b/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
728 @@ -68,7 +68,7 @@
729  }
730  
731  void MediaEngineRemoteVideoSource::Init() {
732 -  LOG(__PRETTY_FUNCTION__);
733 +  LOG("%s", __PRETTY_FUNCTION__);
734    AssertIsOnOwningThread();
735  
736    char deviceName[kMaxDeviceNameLength];
737 @@ -89,7 +89,7 @@
738  }
739  
740  void MediaEngineRemoteVideoSource::Shutdown() {
741 -  LOG(__PRETTY_FUNCTION__);
742 +  LOG("%s", __PRETTY_FUNCTION__);
743    AssertIsOnOwningThread();
744  
745    if (!mInitDone) {
746 @@ -109,7 +109,7 @@
747  }
748  
749  void MediaEngineRemoteVideoSource::SetName(nsString aName) {
750 -  LOG(__PRETTY_FUNCTION__);
751 +  LOG("%s", __PRETTY_FUNCTION__);
752    AssertIsOnOwningThread();
753  
754    mDeviceName = std::move(aName);
755 @@ -193,7 +193,7 @@
756      const nsString& aDeviceId,
757      const mozilla::ipc::PrincipalInfo& aPrincipalInfo,
758      const char** aOutBadConstraint) {
759 -  LOG(__PRETTY_FUNCTION__);
760 +  LOG("%s", __PRETTY_FUNCTION__);
761    AssertIsOnOwningThread();
762  
763    MOZ_ASSERT(mState == kReleased);
764 @@ -231,7 +231,7 @@
765  }
766  
767  nsresult MediaEngineRemoteVideoSource::Deallocate() {
768 -  LOG(__PRETTY_FUNCTION__);
769 +  LOG("%s", __PRETTY_FUNCTION__);
770    AssertIsOnOwningThread();
771  
772    MOZ_ASSERT(mState == kStopped || mState == kAllocated);
773 @@ -267,7 +267,7 @@
774  void MediaEngineRemoteVideoSource::SetTrack(
775      const RefPtr<SourceMediaStream>& aStream, TrackID aTrackID,
776      const PrincipalHandle& aPrincipal) {
777 -  LOG(__PRETTY_FUNCTION__);
778 +  LOG("%s", __PRETTY_FUNCTION__);
779    AssertIsOnOwningThread();
780  
781    MOZ_ASSERT(mState == kAllocated);
782 @@ -292,7 +292,7 @@
783  }
784  
785  nsresult MediaEngineRemoteVideoSource::Start() {
786 -  LOG(__PRETTY_FUNCTION__);
787 +  LOG("%s", __PRETTY_FUNCTION__);
788    AssertIsOnOwningThread();
789  
790    MOZ_ASSERT(mState == kAllocated || mState == kStopped);
791 @@ -345,7 +345,7 @@
792  }
793  
794  nsresult MediaEngineRemoteVideoSource::FocusOnSelectedSource() {
795 -  LOG(__PRETTY_FUNCTION__);
796 +  LOG("%s", __PRETTY_FUNCTION__);
797    AssertIsOnOwningThread();
798  
799    int result;
800 @@ -355,7 +355,7 @@
801  }
802  
803  nsresult MediaEngineRemoteVideoSource::Stop() {
804 -  LOG(__PRETTY_FUNCTION__);
805 +  LOG("%s", __PRETTY_FUNCTION__);
806    AssertIsOnOwningThread();
807  
808    if (mState == kStopped || mState == kAllocated) {
809 @@ -381,7 +381,7 @@
810  nsresult MediaEngineRemoteVideoSource::Reconfigure(
811      const MediaTrackConstraints& aConstraints, const MediaEnginePrefs& aPrefs,
812      const nsString& aDeviceId, const char** aOutBadConstraint) {
813 -  LOG(__PRETTY_FUNCTION__);
814 +  LOG("%s", __PRETTY_FUNCTION__);
815    AssertIsOnOwningThread();
816  
817    MOZ_ASSERT(mInitDone);
818 @@ -762,7 +762,7 @@
819      const NormalizedConstraints& aConstraints, const MediaEnginePrefs& aPrefs,
820      const nsString& aDeviceId, webrtc::CaptureCapability& aCapability,
821      const DistanceCalculation aCalculate) {
822 -  LOG(__PRETTY_FUNCTION__);
823 +  LOG("%s", __PRETTY_FUNCTION__);
824    AssertIsOnOwningThread();
825  
826    if (MOZ_LOG_TEST(gMediaManagerLog, LogLevel::Debug)) {
827 @@ -928,7 +928,7 @@
828  }
829  
830  void MediaEngineRemoteVideoSource::Refresh(int aIndex) {
831 -  LOG(__PRETTY_FUNCTION__);
832 +  LOG("%s", __PRETTY_FUNCTION__);
833    AssertIsOnOwningThread();
834  
835    // NOTE: mCaptureIndex might have changed when allocated!
This page took 0.323259 seconds and 3 git commands to generate.