Move logers into seperate logger files

Constellation seems to have lots of code that could be moved into
seperate files. `FromScriptLogger` and `FromCompositorLogger` seem
to qualify for that.
Moved FromScriptLogger and FromScriptLogger to logger file.

components/constellation/constellation.rs

@@ -102,7 +102,6 @@ use crate::session_history::{
 };
 use crate::timer_scheduler::TimerScheduler;
 use background_hang_monitor::HangMonitorRegister;
-use backtrace::Backtrace;
 use bluetooth_traits::BluetoothRequest;
 use canvas_traits::canvas::{CanvasId, CanvasMsg};
 use canvas_traits::webgl::WebGLThreads;
@@ -127,7 +126,6 @@ use ipc_channel::Error as IpcError;
 use keyboard_types::webdriver::Event as WebDriverInputEvent;
 use keyboard_types::KeyboardEvent;
 use layout_traits::LayoutThreadFactory;
-use log::{Level, LevelFilter, Log, Metadata, Record};
 use media::{GLPlayerThreads, WindowGLContext};
 use msg::constellation_msg::{
     BackgroundHangMonitorControlMsg, BackgroundHangMonitorRegister, HangMonitorAlert,
@@ -168,7 +166,6 @@ use script_traits::{SWManagerMsg, SWManagerSenders, UpdatePipelineIdReason, WebD
 use serde::{Deserialize, Serialize};
 use servo_config::{opts, pref};
 use servo_rand::{random, Rng, ServoRng, SliceRandom};
-use servo_remutex::ReentrantMutex;
 use servo_url::{Host, ImmutableOrigin, ServoUrl};
 use std::borrow::{Cow, ToOwned};
 use std::collections::hash_map::Entry;
@@ -613,113 +610,6 @@ enum ExitPipelineMode {
     Force,
 }
 
-/// The constellation uses logging to perform crash reporting.
-/// The constellation receives all `warn!`, `error!` and `panic!` messages,
-/// and generates a crash report when it receives a panic.
-
-/// A logger directed at the constellation from content processes
-#[derive(Clone)]
-pub struct FromScriptLogger {
-    /// A channel to the constellation
-    pub script_to_constellation_chan: Arc<ReentrantMutex<ScriptToConstellationChan>>,
-}
-
-impl FromScriptLogger {
-    /// Create a new constellation logger.
-    pub fn new(script_to_constellation_chan: ScriptToConstellationChan) -> FromScriptLogger {
-        FromScriptLogger {
-            script_to_constellation_chan: Arc::new(ReentrantMutex::new(
-                script_to_constellation_chan,
-            )),
-        }
-    }
-
-    /// The maximum log level the constellation logger is interested in.
-    pub fn filter(&self) -> LevelFilter {
-        LevelFilter::Warn
-    }
-}
-
-impl Log for FromScriptLogger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        metadata.level() <= Level::Warn
-    }
-
-    fn log(&self, record: &Record) {
-        if let Some(entry) = log_entry(record) {
-            debug!("Sending log entry {:?}.", entry);
-            let thread_name = thread::current().name().map(ToOwned::to_owned);
-            let msg = FromScriptMsg::LogEntry(thread_name, entry);
-            let chan = self
-                .script_to_constellation_chan
-                .lock()
-                .unwrap_or_else(|err| err.into_inner());
-            let _ = chan.send(msg);
-        }
-    }
-
-    fn flush(&self) {}
-}
-
-/// A logger directed at the constellation from the compositor
-#[derive(Clone)]
-pub struct FromCompositorLogger {
-    /// A channel to the constellation
-    pub constellation_chan: Arc<ReentrantMutex<Sender<FromCompositorMsg>>>,
-}
-
-impl FromCompositorLogger {
-    /// Create a new constellation logger.
-    pub fn new(constellation_chan: Sender<FromCompositorMsg>) -> FromCompositorLogger {
-        FromCompositorLogger {
-            constellation_chan: Arc::new(ReentrantMutex::new(constellation_chan)),
-        }
-    }
-
-    /// The maximum log level the constellation logger is interested in.
-    pub fn filter(&self) -> LevelFilter {
-        LevelFilter::Warn
-    }
-}
-
-impl Log for FromCompositorLogger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        metadata.level() <= Level::Warn
-    }
-
-    fn log(&self, record: &Record) {
-        if let Some(entry) = log_entry(record) {
-            debug!("Sending log entry {:?}.", entry);
-            let top_level_id = TopLevelBrowsingContextId::installed();
-            let thread_name = thread::current().name().map(ToOwned::to_owned);
-            let msg = FromCompositorMsg::LogEntry(top_level_id, thread_name, entry);
-            let chan = self
-                .constellation_chan
-                .lock()
-                .unwrap_or_else(|err| err.into_inner());
-            let _ = chan.send(msg);
-        }
-    }
-
-    fn flush(&self) {}
-}
-
-/// Rust uses `Record` for storing logging, but servo converts that to
-/// a `LogEntry`. We do this so that we can record panics as well as log
-/// messages, and because `Record` does not implement serde (de)serialization,
-/// so cannot be used over an IPC channel.
-fn log_entry(record: &Record) -> Option<LogEntry> {
-    match record.level() {
-        Level::Error if thread::panicking() => Some(LogEntry::Panic(
-            format!("{}", record.args()),
-            format!("{:?}", Backtrace::new()),
-        )),
-        Level::Error => Some(LogEntry::Error(format!("{}", record.args()))),
-        Level::Warn => Some(LogEntry::Warn(format!("{}", record.args()))),
-        _ => None,
-    }
-}
-
 /// The number of warnings to include in each crash report.
 const WARNINGS_BUFFER_SIZE: usize = 32;