implement console.group(), console.groupEnd()

components/devtools/lib.rs

@@ -54,6 +54,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::error::Error;
+use std::iter;
 use std::net::{Shutdown, TcpListener, TcpStream};
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::sync::{Arc, Mutex};
@@ -308,19 +309,34 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         actors.register(box performance);
     }
 
+    let mut indent_level = 0;
+
     fn handle_console_message(actors: Arc<Mutex<ActorRegistry>>,
                               id: PipelineId,
                               worker_id: Option<WorkerId>,
                               console_message: ConsoleMessage,
                               actor_pipelines: &HashMap<PipelineId, String>,
-                              actor_workers: &HashMap<(PipelineId, WorkerId), String>) {
+                              actor_workers: &HashMap<(PipelineId, WorkerId), String>,
+                              indent_level: &mut usize) {
+
+        match console_message.logLevel {
+            LogLevel::Group => *indent_level += 2,
+            LogLevel::GroupEnd => {
+                if *indent_level >= 2 {
+                    *indent_level -= 2;
+                }
+            },
+            _ => {},
+        }
+
         let console_actor_name = match find_console_actor(actors.clone(), id, worker_id, actor_workers,
                                                           actor_pipelines) {
             Some(name) => name,
             None => return,
         };
         let actors = actors.lock().unwrap();
         let console_actor = actors.find::<ConsoleActor>(&console_actor_name);
+        let indent = iter::repeat("  ").take(*indent_level).collect::<String>();
         let msg = ConsoleAPICall {
             from: console_actor.name.clone(),
             __type__: "consoleAPICall".to_owned(),
@@ -333,7 +349,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                     _ => "log"
                 }.to_owned(),
                 timeStamp: precise_time_ns(),
-                arguments: vec!(console_message.message),
+                arguments: vec!(indent + &console_message.message),
                 filename: console_message.filename,
                 lineNumber: console_message.lineNumber,
                 columnNumber: console_message.columnNumber,
@@ -535,7 +551,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                         console_message,
                         worker_id)) =>
                 handle_console_message(actors.clone(), id, worker_id, console_message,
-                                       &actor_pipelines, &actor_workers),
+                                       &actor_pipelines, &actor_workers, &mut indent_level),
             DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ReportCSSError(
                         id,
                         css_error)) => {
@@ -547,7 +563,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                     columnNumber: css_error.column,
                 };
                 handle_console_message(actors.clone(), id, None, console_message,
-                                       &actor_pipelines, &actor_workers)
+                                       &actor_pipelines, &actor_workers, &mut indent_level)
             },
             DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::NetworkEvent(
                         request_id, network_event)) => {

components/devtools_traits/lib.rs

@@ -216,6 +216,8 @@ pub enum LogLevel {
     Info,
     Warn,
     Error,
+    Group,
+    GroupEnd,
 }
 
 #[derive(Clone, Deserialize, Serialize)]

components/script/dom/console.rs

@@ -41,47 +41,39 @@ impl Console {
             chan.send(devtools_message).unwrap();
         }
     }
+
+    fn send_messages(&self, log_level: LogLevel, messages: Vec<DOMString>) {
+        for message in messages {
+            println!("{}", message);
+            self.send_to_devtools(log_level.clone(), message);
+        }
+    }
 }
 
 impl ConsoleMethods for Console {
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/log
     fn Log(&self, messages: Vec<DOMString>) {
-        for message in messages {
-            println!("{}", message);
-            self.send_to_devtools(LogLevel::Log, message);
-        }
+        self.send_messages(LogLevel::Log, messages);
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console
     fn Debug(&self, messages: Vec<DOMString>) {
-        for message in messages {
-            println!("{}", message);
-            self.send_to_devtools(LogLevel::Debug, message);
-        }
+        self.send_messages(LogLevel::Debug, messages);
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/info
     fn Info(&self, messages: Vec<DOMString>) {
-        for message in messages {
-            println!("{}", message);
-            self.send_to_devtools(LogLevel::Info, message);
-        }
+        self.send_messages(LogLevel::Info, messages);
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/warn
     fn Warn(&self, messages: Vec<DOMString>) {
-        for message in messages {
-            println!("{}", message);
-            self.send_to_devtools(LogLevel::Warn, message);
-        }
+        self.send_messages(LogLevel::Warn, messages);
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/error
     fn Error(&self, messages: Vec<DOMString>) {
-        for message in messages {
-            println!("{}", message);
-            self.send_to_devtools(LogLevel::Error, message);
-        }
+        self.send_messages(LogLevel::Error, messages);
     }
 
     // https://developer.mozilla.org/en-US/docs/Web/API/Console/assert
@@ -92,6 +84,16 @@ impl ConsoleMethods for Console {
             self.send_to_devtools(LogLevel::Error, message);
         }
     }
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Console/group
+    fn Group(&self, messages: Vec<DOMString>) {
+        self.send_messages(LogLevel::Group, messages);
+    }
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Console/groupEnd
+    fn GroupEnd(&self) {
+        self.send_messages(LogLevel::GroupEnd, vec![]);
+    }
 }
 
 fn prepare_message(logLevel: LogLevel, message: DOMString) -> ConsoleMessage {

components/script/dom/webidls/Console.webidl

@@ -18,4 +18,6 @@ interface Console {
   void warn(DOMString... messages);
   void error(DOMString... messages);
   void assert(boolean condition, optional DOMString message);
+  void group(DOMString... messages);
+  void groupEnd();
 };