Make cached messages appear in FF's devtools.

components/devtools/actors/console.rs

@@ -13,6 +13,7 @@ use protocol::JsonPacketStream;
 use devtools_traits::EvaluateJSReply::{NullValue, VoidValue, NumberValue};
 use devtools_traits::EvaluateJSReply::{StringValue, BooleanValue, ActorValue};
 use devtools_traits::{CachedConsoleMessageTypes, DevtoolScriptControlMsg, PAGE_ERROR, CONSOLE_API};
+use devtools_traits::CachedConsoleMessage;
 use msg::constellation_msg::PipelineId;
 
 use std::collections::BTreeMap;
@@ -21,6 +22,19 @@ use rustc_serialize::json::{self, Json, ToJson};
 use std::net::TcpStream;
 use std::sync::mpsc::{channel, Sender};
 
+trait EncodableConsoleMessage {
+    fn encode(&self) -> json::EncodeResult<String>;
+}
+
+impl EncodableConsoleMessage for CachedConsoleMessage {
+    fn encode(&self) -> json::EncodeResult<String> {
+        match *self {
+            CachedConsoleMessage::PageError(ref a) => json::encode(a),
+            CachedConsoleMessage::ConsoleAPI(ref a) => json::encode(a),
+        }
+    }
+}
+
 #[derive(RustcEncodable)]
 struct StartedListenersTraits {
     customNetworkRequest: bool,
@@ -98,7 +112,9 @@ impl Actor for ConsoleActor {
                 self.script_chan.send(DevtoolScriptControlMsg::GetCachedMessages(
                     self.pipeline, message_types, chan)).unwrap();
                 let messages = try!(port.recv().map_err(|_| ())).into_iter().map(|message| {
-                    json::encode(&message).unwrap().to_json().as_object().unwrap().to_owned()
+                    let json_string = message.encode().unwrap();
+                    let json = Json::from_str(&json_string).unwrap();
+                    json.as_object().unwrap().to_owned()
                 }).collect();
 
                 let msg = GetCachedMessagesReply {

components/devtools_traits/lib.rs

@@ -175,32 +175,37 @@ bitflags! {
 }
 
 #[derive(RustcEncodable)]
+pub struct PageError {
+    pub _type: String,
+    pub errorMessage: String,
+    pub sourceName: String,
+    pub lineText: String,
+    pub lineNumber: u32,
+    pub columnNumber: u32,
+    pub category: String,
+    pub timeStamp: u64,
+    pub error: bool,
+    pub warning: bool,
+    pub exception: bool,
+    pub strict: bool,
+    pub private: bool,
+}
+
+#[derive(RustcEncodable)]
+pub struct ConsoleAPI {
+    pub _type: String,
+    pub level: String,
+    pub filename: String,
+    pub lineNumber: u32,
+    pub functionName: String,
+    pub timeStamp: u64,
+    pub private: bool,
+    pub arguments: Vec<String>,
+}
+
 pub enum CachedConsoleMessage {
-    PageError {
-        __type__: String,
-        errorMessage: String,
-        sourceName: String,
-        lineText: String,
-        lineNumber: u32,
-        columnNumber: u32,
-        category: String,
-        timeStamp: u64,
-        error: bool,
-        warning: bool,
-        exception: bool,
-        strict: bool,
-        private: bool,
-    },
-    ConsoleAPI {
-        __type__: String,
-        level: String,
-        filename: String,
-        lineNumber: u32,
-        functionName: String,
-        timeStamp: u64,
-        private: bool,
-        arguments: Vec<String>,
-    },
+    PageError(PageError),
+    ConsoleAPI(ConsoleAPI),
 }
 
 #[derive(Clone)]

components/script/devtools.rs

@@ -4,6 +4,7 @@
 
 use devtools_traits::{CachedConsoleMessage, CachedConsoleMessageTypes, PAGE_ERROR, CONSOLE_API};
 use devtools_traits::{EvaluateJSReply, NodeInfo, Modification, TimelineMarker, TimelineMarkerType};
+use devtools_traits::{ConsoleAPI, PageError};
 use dom::bindings::conversions::FromJSValConvertible;
 use dom::bindings::conversions::StringificationBehavior;
 use dom::bindings::js::Root;
@@ -104,23 +105,10 @@ pub fn handle_get_cached_messages(_pipeline_id: PipelineId,
     //TODO: check the messageTypes against a global Cache for console messages and page exceptions
     let mut messages = Vec::new();
     if message_types.contains(PAGE_ERROR) {
-        //TODO: do for real
-        messages.push(CachedConsoleMessage::ConsoleAPI {
-            __type__: "consoleAPICall".to_owned(),
-            level: "error".to_owned(),
-            filename: "http://localhost/~mihai/mozilla/test.html".to_owned(),
-            lineNumber: 0,
-            functionName: String::new(),
-            timeStamp: 0,
-            private: false,
-            arguments: Vec::new(),
-        })
-    }
-    if message_types.contains(CONSOLE_API) {
         //TODO: make script error reporter pass all reported errors
         //      to devtools and cache them for returning here.
-        messages.push(CachedConsoleMessage::PageError {
-            __type__: "pageError".to_owned(),
+        let msg = PageError {
+            _type: "PageError".to_owned(),
             errorMessage: "page error test".to_owned(),
             sourceName: String::new(),
             lineText: String::new(),
@@ -133,7 +121,22 @@ pub fn handle_get_cached_messages(_pipeline_id: PipelineId,
             exception: false,
             strict: false,
             private: false,
-        })
+        };
+        messages.push(CachedConsoleMessage::PageError(msg));
+    }
+    if message_types.contains(CONSOLE_API) {
+        //TODO: do for real
+        let msg = ConsoleAPI {
+            _type: "ConsoleAPI".to_owned(),
+            level: "error".to_owned(),
+            filename: "http://localhost/~mihai/mozilla/test.html".to_owned(),
+            lineNumber: 0,
+            functionName: String::new(),
+            timeStamp: 0,
+            private: false,
+            arguments: vec!["console error test".to_owned()],
+        };
+        messages.push(CachedConsoleMessage::ConsoleAPI(msg));
     }
     reply.send(messages).unwrap();
 }