WIP iframe handling.

src/components/script/dom/bindings/element.rs

@@ -6,8 +6,10 @@ use dom::bindings::node::unwrap;
 use dom::bindings::utils::jsval_to_str;
 use dom::bindings::utils::{domstring_to_jsval, WrapNewBindingObject};
 use dom::bindings::utils::{str, CacheableWrapper, DOM_OBJECT_SLOT, DOMString};
-use dom::element::*;
+use dom::element::Element;
-use dom::node::{AbstractNode, Element, ElementNodeTypeId, ScriptView};
+use dom::element::{HTMLImageElementTypeId, HTMLHeadElementTypeId, HTMLScriptElementTypeId,
+                   HTMLDivElementTypeId};
+use dom::node::{AbstractNode, ScriptView, ElementNodeTypeId};
 use layout_interface::{ContentBoxQuery, ContentBoxResponse};
 use script_task::task_from_context;
 use super::utils;

src/components/script/dom/element.rs

@@ -8,6 +8,7 @@ use dom::bindings::utils::DOMString;
 use dom::clientrect::ClientRect;
 use dom::clientrectlist::ClientRectList;
 use dom::node::{ElementNodeTypeId, Node, ScriptView};
+use html::hubbub_html_parser::HtmlParserResult;
 use layout_interface::{ContentBoxQuery, ContentBoxResponse, ContentBoxesQuery};
 use layout_interface::{ContentBoxesResponse};
 
@@ -37,6 +38,7 @@ pub enum ElementTypeId {
     HTMLHeadElementTypeId,
     HTMLHeadingElementTypeId,
     HTMLHtmlElementTypeId,
+    HTMLIframeElementTypeId,
     HTMLImageElementTypeId,
     HTMLInputElementTypeId,
     HTMLItalicElementTypeId,
@@ -107,6 +109,12 @@ pub struct HTMLHeadingElement {
     level: HeadingLevel,
 }
 
+pub struct HTMLIframeElement {
+    parent: Element,
+    frame: Option<Url>,
+    parse_result: Option<Port<HtmlParserResult>>
+}
+
 pub struct HTMLImageElement {
     parent: Element,
     image: Option<Url>,

src/components/script/dom/node.rs

@@ -10,7 +10,7 @@ use dom::bindings::utils::WrapperCache;
 use dom::bindings;
 use dom::characterdata::CharacterData;
 use dom::document::Document;
-use dom::element::{Element, ElementTypeId, HTMLImageElement, HTMLImageElementTypeId};
+use dom::element::{Element, ElementTypeId, HTMLImageElement, HTMLImageElementTypeId, HTMLIframeElementTypeId, HTMLIframeElement};
 use dom::element::{HTMLStyleElementTypeId};
 use script_task::global_script_context;
 
@@ -340,6 +340,24 @@ impl<View> AbstractNode<View> {
         self.transmute_mut(f)
     }
 
+    pub fn is_iframe_element(self) -> bool {
+        self.type_id() == ElementNodeTypeId(HTMLIframeElementTypeId)
+    }
+
+    pub fn with_imm_iframe_element<R>(self, f: &fn(&HTMLIframeElement) -> R) -> R {
+        if !self.is_iframe_element() {
+            fail!(~"node is not an iframe element");
+        }
+        self.transmute(f)
+    }
+
+    pub fn with_mut_iframe_element<R>(self, f: &fn(&mut HTMLIframeElement) -> R) -> R {
+        if !self.is_iframe_element() {
+            fail!(~"node is not an iframe element");
+        }
+        self.transmute_mut(f)
+    }
+
     pub fn is_style_element(self) -> bool {
         self.type_id() == ElementNodeTypeId(HTMLStyleElementTypeId)
     }

src/components/script/html/hubbub_html_parser.rs

@@ -2,8 +2,33 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::element::*;
+use dom::element::{HTMLAnchorElementTypeId, HTMLAsideElementTypeId, HTMLBRElementTypeId,
-use dom::node::{AbstractNode, Comment, Doctype, Element, ElementNodeTypeId, Node, ScriptView};
+                   HTMLBodyElementTypeId, HTMLBoldElementTypeId, HTMLDivElementTypeId,
+                   HTMLFontElementTypeId, HTMLFormElementTypeId, HTMLHRElementTypeId,
+                   HTMLHeadElementTypeId, HTMLHtmlElementTypeId,
+                   HTMLImageElementTypeId, HTMLIframeElementTypeId, HTMLInputElementTypeId,
+                   HTMLItalicElementTypeId, HTMLLinkElementTypeId, HTMLListItemElementTypeId,
+                   HTMLMetaElementTypeId, HTMLOListElementTypeId, HTMLOptionElementTypeId,
+                   HTMLParagraphElementTypeId, HTMLScriptElementTypeId,
+                   HTMLSectionElementTypeId, HTMLSelectElementTypeId, HTMLSmallElementTypeId,
+                   HTMLSpanElementTypeId, HTMLStyleElementTypeId, HTMLTableBodyElementTypeId,
+                   HTMLTableCellElementTypeId, HTMLTableElementTypeId,
+                   HTMLTableRowElementTypeId, HTMLTitleElementTypeId, HTMLUListElementTypeId,
+                   UnknownElementTypeId};
+use dom::element::{HTMLAnchorElement, HTMLAsideElement, HTMLBRElement, HTMLBodyElement,
+                   HTMLBoldElement, HTMLDivElement, HTMLFontElement, HTMLFormElement,
+                   HTMLHRElement, HTMLHeadElement, HTMLHeadingElement, HTMLHtmlElement,
+                   HTMLInputElement, HTMLImageElement, HTMLIframeElement,
+                   HTMLItalicElement, HTMLLinkElement, HTMLListItemElement, HTMLMetaElement,
+                   HTMLOListElement, HTMLOptionElement, HTMLParagraphElement,
+                   HTMLScriptElement, HTMLSectionElement, HTMLSelectElement, HTMLSmallElement,
+                   HTMLSpanElement, HTMLStyleElement, HTMLTableBodyElement,
+                   HTMLTableCellElement, HTMLTableElement, HTMLTableRowElement,
+                   HTMLTitleElement, HTMLUListElement};
+use dom::element::{HTMLHeadingElementTypeId, Heading1, Heading2, Heading3, Heading4, Heading5,
+                   Heading6};
+use dom::element::{Element, Attr};
+use dom::node::{AbstractNode, Comment, Doctype, ElementNodeTypeId, Node, ScriptView};
 use dom::node::{Text};
 use html::cssparse::{InlineProvenance, StylesheetProvenance, UrlProvenance, spawn_css_parser};
 use newcss::stylesheet::Stylesheet;
@@ -52,7 +77,7 @@ enum JSMessage {
     JSTaskExit
 }
 
-struct HtmlParserResult {
+pub struct HtmlParserResult {
     root: AbstractNode<ScriptView>,
     style_port: Port<Option<Stylesheet>>,
     js_port: Port<JSResult>,
@@ -194,6 +219,8 @@ fn build_element_from_tag(tag: &str) -> AbstractNode<ScriptView> {
     handle_element!(tag, "ul",      HTMLUListElementTypeId, HTMLUListElement, []);
 
     handle_element!(tag, "img", HTMLImageElementTypeId, HTMLImageElement, [(image: None)]);
+    handle_element!(tag, "iframe",  HTMLIframeElementTypeId, HTMLIframeElement,
+                    [(frame: None), (parse_result: None)]);
 
     handle_element!(tag, "h1", HTMLHeadingElementTypeId, HTMLHeadingElement, [(level: Heading1)]);
     handle_element!(tag, "h2", HTMLHeadingElementTypeId, HTMLHeadingElement, [(level: Heading2)]);
@@ -213,6 +240,7 @@ pub fn parse_html(url: Url,
                   image_cache_task: ImageCacheTask) -> HtmlParserResult {
     // Spawn a CSS parser to receive links to CSS style sheets.
     let resource_task2 = resource_task.clone();
+    let resource_task3 = resource_task.clone();
 
     let (stylesheet_port, stylesheet_chan) = comm::stream();
     let stylesheet_chan = Cell::new(stylesheet_chan);
@@ -314,6 +342,29 @@ pub fn parse_html(url: Url,
                         }
                     }
                 },
+                ElementNodeTypeId(HTMLIframeElementTypeId) => {
+                    do node.with_mut_iframe_element |iframe_element| {
+                        let src_opt = iframe_element.parent.get_attr("src").map(|x| x.to_str());
+                        match src_opt {
+                            None => {}
+                            Some(src) => {
+                                let iframe_url = make_url(src, Some(url2.clone()));
+                                iframe_element.frame = Some(iframe_url.clone());
+                                let (parse_port, parse_chan) = comm::stream();
+                                iframe_element.parse_result = Some(parse_port);
+                                let image_cache_task2 = Cell::new(image_cache_task.clone());
+                                let resource_task3 = Cell::new(resource_task3.clone());
+                                let iframe_url = Cell::new(iframe_url);
+                                do task::spawn {
+                                    let result = parse_html(iframe_url.take(),
+                                                            resource_task3.take(),
+                                                            image_cache_task2.take());
+                                    parse_chan.send(result);
+                                }
+                            }
+                        }
+                    }
+                }
                 ElementNodeTypeId(HTMLImageElementTypeId) => {
                     do node.with_mut_image_element |image_element| {
                         let src_opt = image_element.parent.get_attr("src").map(|x| x.to_str());