Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-01 03:30:33 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #15107 - DexterHaslem:15100-convert-debug-to-traces, r=cbrewster

Browse source 
convert less interesting debug! logs to traces

<!-- Please describe your changes on the following line: -->
converted some debug! invocations to trace!

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: -->
- [X] `./mach build -d` does not report any errors
- [X] `./mach test-tidy` does not report any errors
- [X] These changes fix #15100 (github issue number if applicable).

<!-- Either: -->
- [ ] There are tests for these changes OR
- [X] These changes do not require tests because only logging changed

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/15107)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2017-01-18 21:29:59 -08:00 • committed by GitHub
commit b8df502491
5 changed files with 31 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/rand/lib.rs
View file

@ -77,14 +77,14 @@ impl<'a> SeedableRng<&'a [usize]> for ServoRng {
/// Note that this RNG does not reseed itself, so care is needed to reseed the RNG /// Note that this RNG does not reseed itself, so care is needed to reseed the RNG
/// is required to be cryptographically sound. /// is required to be cryptographically sound.
fn from_seed(seed: &[usize]) -> ServoRng { fn from_seed(seed: &[usize]) -> ServoRng {
debug!("Creating new manually-reseeded ServoRng."); trace!("Creating new manually-reseeded ServoRng.");
let isaac_rng = IsaacWordRng::from_seed(as_isaac_seed(seed)); let isaac_rng = IsaacWordRng::from_seed(as_isaac_seed(seed));
let reseeding_rng = ReseedingRng::new(isaac_rng, u64::MAX, ServoReseeder); let reseeding_rng = ReseedingRng::new(isaac_rng, u64::MAX, ServoReseeder);
ServoRng { rng: reseeding_rng } ServoRng { rng: reseeding_rng }
} }
/// Reseed the RNG. /// Reseed the RNG.
fn reseed(&mut self, seed: &'a [usize]) { fn reseed(&mut self, seed: &'a [usize]) {
debug!("Manually reseeding ServoRng."); trace!("Manually reseeding ServoRng.");
self.rng.reseed((ServoReseeder, as_isaac_seed(seed))) self.rng.reseed((ServoReseeder, as_isaac_seed(seed)))
} }
} }
@ -95,7 +95,7 @@ impl ServoRng {
/// This uses the shared `OsRng`, so avoids consuming /// This uses the shared `OsRng`, so avoids consuming
/// a file descriptor. /// a file descriptor.
pub fn new() -> ServoRng { pub fn new() -> ServoRng {
debug!("Creating new ServoRng."); trace!("Creating new ServoRng.");
let mut os_rng = OS_RNG.lock().expect("Poisoned lock."); let mut os_rng = OS_RNG.lock().expect("Poisoned lock.");
let isaac_rng = IsaacWordRng::rand(&mut *os_rng); let isaac_rng = IsaacWordRng::rand(&mut *os_rng);
let reseeding_rng = ReseedingRng::new(isaac_rng, RESEED_THRESHOLD, ServoReseeder); let reseeding_rng = ReseedingRng::new(isaac_rng, RESEED_THRESHOLD, ServoReseeder);
@ -108,7 +108,7 @@ struct ServoReseeder;
impl Reseeder<IsaacWordRng> for ServoReseeder { impl Reseeder<IsaacWordRng> for ServoReseeder {
fn reseed(&mut self, rng: &mut IsaacWordRng) { fn reseed(&mut self, rng: &mut IsaacWordRng) {
debug!("Reseeding ServoRng."); trace!("Reseeding ServoRng.");
let mut os_rng = OS_RNG.lock().expect("Poisoned lock."); let mut os_rng = OS_RNG.lock().expect("Poisoned lock.");
*rng = IsaacWordRng::rand(&mut *os_rng); *rng = IsaacWordRng::rand(&mut *os_rng);
} }

28
components/remutex/lib.rs
View file

@ -159,7 +159,7 @@ unsafe impl<T> Sync for ReentrantMutex<T> where T: Send {}
impl<T> ReentrantMutex<T> { impl<T> ReentrantMutex<T> {
pub fn new(data: T) -> ReentrantMutex<T> { pub fn new(data: T) -> ReentrantMutex<T> {
debug!("{:?} Creating new lock.", ThreadId::current()); trace!("{:?} Creating new lock.", ThreadId::current());
ReentrantMutex { ReentrantMutex {
mutex: HandOverHandMutex::new(), mutex: HandOverHandMutex::new(),
count: Cell::new(0), count: Cell::new(0),
@ -168,53 +168,53 @@ impl<T> ReentrantMutex<T> {
} }
pub fn lock(&self) -> LockResult<ReentrantMutexGuard<T>> { pub fn lock(&self) -> LockResult<ReentrantMutexGuard<T>> {
debug!("{:?} Locking.", ThreadId::current()); trace!("{:?} Locking.", ThreadId::current());
if self.mutex.owner() != Some(ThreadId::current()) { if self.mutex.owner() != Some(ThreadId::current()) {
debug!("{:?} Becoming owner.", ThreadId::current()); trace!("{:?} Becoming owner.", ThreadId::current());
if let Err(_) = self.mutex.lock() { if let Err(_) = self.mutex.lock() {
debug!("{:?} Poison!", ThreadId::current()); trace!("{:?} Poison!", ThreadId::current());
return Err(PoisonError::new(self.mk_guard())); return Err(PoisonError::new(self.mk_guard()));
} }
debug!("{:?} Became owner.", ThreadId::current()); trace!("{:?} Became owner.", ThreadId::current());
} }
Ok(self.mk_guard()) Ok(self.mk_guard())
} }
pub fn try_lock(&self) -> TryLockResult<ReentrantMutexGuard<T>> { pub fn try_lock(&self) -> TryLockResult<ReentrantMutexGuard<T>> {
debug!("{:?} Try locking.", ThreadId::current()); trace!("{:?} Try locking.", ThreadId::current());
if self.mutex.owner() != Some(ThreadId::current()) { if self.mutex.owner() != Some(ThreadId::current()) {
debug!("{:?} Becoming owner?", ThreadId::current()); trace!("{:?} Becoming owner?", ThreadId::current());
if let Err(err) = self.mutex.try_lock() { if let Err(err) = self.mutex.try_lock() {
match err { match err {
TryLockError::WouldBlock => { TryLockError::WouldBlock => {
debug!("{:?} Would block.", ThreadId::current()); trace!("{:?} Would block.", ThreadId::current());
return Err(TryLockError::WouldBlock) return Err(TryLockError::WouldBlock)
}, },
TryLockError::Poisoned(_) => { TryLockError::Poisoned(_) => {
debug!("{:?} Poison!", ThreadId::current()); trace!("{:?} Poison!", ThreadId::current());
return Err(TryLockError::Poisoned(PoisonError::new(self.mk_guard()))); return Err(TryLockError::Poisoned(PoisonError::new(self.mk_guard())));
}, },
} }
} }
debug!("{:?} Became owner.", ThreadId::current()); trace!("{:?} Became owner.", ThreadId::current());
} }
Ok(self.mk_guard()) Ok(self.mk_guard())
} }
fn unlock(&self) { fn unlock(&self) {
debug!("{:?} Unlocking.", ThreadId::current()); trace!("{:?} Unlocking.", ThreadId::current());
let count = self.count.get().checked_sub(1).expect("Underflowed lock count."); let count = self.count.get().checked_sub(1).expect("Underflowed lock count.");
debug!("{:?} Decrementing count to {}.", ThreadId::current(), count); trace!("{:?} Decrementing count to {}.", ThreadId::current(), count);
self.count.set(count); self.count.set(count);
if count == 0 { if count == 0 {
debug!("{:?} Releasing mutex.", ThreadId::current()); trace!("{:?} Releasing mutex.", ThreadId::current());
self.mutex.unlock(); self.mutex.unlock();
} }
} }
fn mk_guard(&self) -> ReentrantMutexGuard<T> { fn mk_guard(&self) -> ReentrantMutexGuard<T> {
let count = self.count.get().checked_add(1).expect("Overflowed lock count."); let count = self.count.get().checked_add(1).expect("Overflowed lock count.");
debug!("{:?} Incrementing count to {}.", ThreadId::current(), count); trace!("{:?} Incrementing count to {}.", ThreadId::current(), count);
self.count.set(count); self.count.set(count);
ReentrantMutexGuard { mutex: self } ReentrantMutexGuard { mutex: self }
} }

14
components/script/dom/bindings/conversions.rs
View file

@ -362,7 +362,7 @@ pub unsafe fn get_dom_class(obj: *mut JSObject) -> Result<&'static DOMClass, ()>
let dom_class: *const DOMClass = GetProxyHandlerExtra(obj) as *const DOMClass; let dom_class: *const DOMClass = GetProxyHandlerExtra(obj) as *const DOMClass;
return Ok(&*dom_class); return Ok(&*dom_class);
} }
debug!("not a dom object"); trace!("not a dom object");
Err(()) Err(())
} }
@ -380,27 +380,27 @@ pub unsafe fn private_from_proto_check<F>(mut obj: *mut JSObject,
{ {
let dom_class = try!(get_dom_class(obj).or_else(|_| { let dom_class = try!(get_dom_class(obj).or_else(|_| {
if IsWrapper(obj) { if IsWrapper(obj) {
debug!("found wrapper"); trace!("found wrapper");
obj = UnwrapObject(obj, /* stopAtWindowProxy = */ 0); obj = UnwrapObject(obj, /* stopAtWindowProxy = */ 0);
if obj.is_null() { if obj.is_null() {
debug!("unwrapping security wrapper failed"); trace!("unwrapping security wrapper failed");
Err(()) Err(())
} else { } else {
assert!(!IsWrapper(obj)); assert!(!IsWrapper(obj));
debug!("unwrapped successfully"); trace!("unwrapped successfully");
get_dom_class(obj) get_dom_class(obj)
} }
} else { } else {
debug!("not a dom wrapper"); trace!("not a dom wrapper");
Err(()) Err(())
} }
})); }));
if proto_check(dom_class) { if proto_check(dom_class) {
debug!("good prototype"); trace!("good prototype");
Ok(private_from_object(obj)) Ok(private_from_object(obj))
} else { } else {
debug!("bad prototype"); trace!("bad prototype");
Err(()) Err(())
} }
} }

8
components/script/dom/bindings/trace.rs
View file

@ -129,7 +129,7 @@ pub fn trace_jsval(tracer: *mut JSTracer, description: &str, val: &Heap<JSVal>)
return; return;
} }
debug!("tracing value {}", description); trace!("tracing value {}", description);
CallValueTracer(tracer, CallValueTracer(tracer,
val.ptr.get() as *mut _, val.ptr.get() as *mut _,
GCTraceKindToAscii(val.get().trace_kind())); GCTraceKindToAscii(val.get().trace_kind()));
@ -140,7 +140,7 @@ pub fn trace_jsval(tracer: *mut JSTracer, description: &str, val: &Heap<JSVal>)
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn trace_reflector(tracer: *mut JSTracer, description: &str, reflector: &Reflector) { pub fn trace_reflector(tracer: *mut JSTracer, description: &str, reflector: &Reflector) {
unsafe { unsafe {
debug!("tracing reflector {}", description); trace!("tracing reflector {}", description);
CallUnbarrieredObjectTracer(tracer, CallUnbarrieredObjectTracer(tracer,
reflector.rootable(), reflector.rootable(),
GCTraceKindToAscii(TraceKind::Object)); GCTraceKindToAscii(TraceKind::Object));
@ -150,7 +150,7 @@ pub fn trace_reflector(tracer: *mut JSTracer, description: &str, reflector: &Ref
/// Trace a `JSObject`. /// Trace a `JSObject`.
pub fn trace_object(tracer: *mut JSTracer, description: &str, obj: &Heap<*mut JSObject>) { pub fn trace_object(tracer: *mut JSTracer, description: &str, obj: &Heap<*mut JSObject>) {
unsafe { unsafe {
debug!("tracing {}", description); trace!("tracing {}", description);
CallObjectTracer(tracer, CallObjectTracer(tracer,
obj.ptr.get() as *mut _, obj.ptr.get() as *mut _,
GCTraceKindToAscii(TraceKind::Object)); GCTraceKindToAscii(TraceKind::Object));
@ -734,7 +734,7 @@ impl<'a, T: JSTraceable> DerefMut for RootedVec<'a, T> {
/// SM Callback that traces the rooted traceables /// SM Callback that traces the rooted traceables
pub unsafe fn trace_traceables(tracer: *mut JSTracer) { pub unsafe fn trace_traceables(tracer: *mut JSTracer) {
debug!("tracing stack-rooted traceables"); trace!("tracing stack-rooted traceables");
ROOTED_TRACEABLES.with(|ref traceables| { ROOTED_TRACEABLES.with(|ref traceables| {
let traceables = traceables.borrow(); let traceables = traceables.borrow();
traceables.trace(tracer); traceables.trace(tracer);

4
components/script/dom/bindings/weakref.rs
View file

@ -55,7 +55,7 @@ pub trait WeakReferenceable: DomObject + Sized {
DOM_WEAK_SLOT) DOM_WEAK_SLOT)
.to_private() as *mut WeakBox<Self>; .to_private() as *mut WeakBox<Self>;
if ptr.is_null() { if ptr.is_null() {
debug!("Creating new WeakBox holder for {:p}.", self); trace!("Creating new WeakBox holder for {:p}.", self);
ptr = Box::into_raw(box WeakBox { ptr = Box::into_raw(box WeakBox {
count: Cell::new(1), count: Cell::new(1),
value: Cell::new(Some(NonZero::new(self))), value: Cell::new(Some(NonZero::new(self))),
@ -65,7 +65,7 @@ pub trait WeakReferenceable: DomObject + Sized {
let box_ = &*ptr; let box_ = &*ptr;
assert!(box_.value.get().is_some()); assert!(box_.value.get().is_some());
let new_count = box_.count.get() + 1; let new_count = box_.count.get() + 1;
debug!("Incrementing WeakBox refcount for {:p} to {}.", trace!("Incrementing WeakBox refcount for {:p} to {}.",
self, self,
new_count); new_count);
box_.count.set(new_count); box_.count.set(new_count);