Hold stderr lock when using stdout through Console APIs.

components/script/dom/console.rs

@@ -7,6 +7,7 @@ use dom::bindings::inheritance::Castable;
 use dom::bindings::str::DOMString;
 use dom::globalscope::GlobalScope;
 use dom::workerglobalscope::WorkerGlobalScope;
+use std::io;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/Console
 pub struct Console(());
@@ -27,74 +28,101 @@ impl Console {
     }
 }
 
+// In order to avoid interleaving the stdout output of the Console API methods
+// with stderr that could be in use on other threads, we lock stderr until
+// we're finished with stdout. Since the stderr lock is reentrant, there is
+// no risk of deadlock if the callback ends up trying to write to stderr for
+// any reason.
+fn with_stderr_lock<F>(f: F) where F: FnOnce() {
+    let stderr = io::stderr();
+    let _handle = stderr.lock();
+    f()
+}
+
 impl Console {
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/log
     pub fn Log(global: &GlobalScope, messages: Vec<DOMString>) {
-        for message in messages {
+        with_stderr_lock(move || {
-            println!("{}", message);
+            for message in messages {
-            Self::send_to_devtools(global, LogLevel::Log, message);
+                println!("{}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Log, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console
     pub fn Debug(global: &GlobalScope, messages: Vec<DOMString>) {
-        for message in messages {
+        with_stderr_lock(move || {
-            println!("{}", message);
+            for message in messages {
-            Self::send_to_devtools(global, LogLevel::Debug, message);
+                println!("{}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Debug, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/info
     pub fn Info(global: &GlobalScope, messages: Vec<DOMString>) {
-        for message in messages {
+        with_stderr_lock(move || {
-            println!("{}", message);
+            for message in messages {
-            Self::send_to_devtools(global, LogLevel::Info, message);
+                println!("{}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Info, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/warn
     pub fn Warn(global: &GlobalScope, messages: Vec<DOMString>) {
-        for message in messages {
+        with_stderr_lock(move || {
-            println!("{}", message);
+            for message in messages {
-            Self::send_to_devtools(global, LogLevel::Warn, message);
+                println!("{}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Warn, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/error
     pub fn Error(global: &GlobalScope, messages: Vec<DOMString>) {
-        for message in messages {
+        with_stderr_lock(move || {
-            println!("{}", message);
+            for message in messages {
-            Self::send_to_devtools(global, LogLevel::Error, message);
+                println!("{}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Error, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/assert
     pub fn Assert(global: &GlobalScope, condition: bool, message: Option<DOMString>) {
-        if !condition {
+        with_stderr_lock(move || {
-            let message = message.unwrap_or_else(|| DOMString::from("no message"));
+            if !condition {
-            println!("Assertion failed: {}", message);
+                let message = message.unwrap_or_else(|| DOMString::from("no message"));
-            Self::send_to_devtools(global, LogLevel::Error, message);
+                println!("Assertion failed: {}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Error, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/time
     pub fn Time(global: &GlobalScope, label: DOMString) {
-        if let Ok(()) = global.time(label.clone()) {
+        with_stderr_lock(move || {
-            let message = DOMString::from(format!("{}: timer started", label));
+            if let Ok(()) = global.time(label.clone()) {
-            println!("{}", message);
+                let message = DOMString::from(format!("{}: timer started", label));
-            Self::send_to_devtools(global, LogLevel::Log, message);
+                println!("{}", message);
-        }
+                Self::send_to_devtools(global, LogLevel::Log, message);
+            }
+        })
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd
     pub fn TimeEnd(global: &GlobalScope, label: DOMString) {
-        if let Ok(delta) = global.time_end(&label) {
+        with_stderr_lock(move || {
-            let message = DOMString::from(
+            if let Ok(delta) = global.time_end(&label) {
-                format!("{}: {}ms", label, delta)
+                let message = DOMString::from(
-            );
+                    format!("{}: {}ms", label, delta)
-            println!("{}", message);
+                );
-            Self::send_to_devtools(global, LogLevel::Log, message);
+                println!("{}", message);
-        };
+                Self::send_to_devtools(global, LogLevel::Log, message);
+            };
+        })
     }
 }