diff --git a/components/net/about_loader.rs b/components/net/about_loader.rs
index 7f3b93d293e..3fd1a09c315 100644
--- a/components/net/about_loader.rs
+++ b/components/net/about_loader.rs
@@ -4,7 +4,8 @@
 
 use net_traits::{LoadData, Metadata};
 use net_traits::ProgressMsg::Done;
-use resource_task::{TargetedLoadResponse, start_sending, ResponseSenders};
+use mime_classifier::MIMEClassifier;
+use resource_task::start_sending;
 use file_loader;
 
 use url::Url;
@@ -13,16 +14,13 @@ use util::resource_files::resources_dir_path;
 
 use std::borrow::IntoCow;
 use std::fs::PathExt;
-use std::sync::mpsc::Sender;
+use std::sync::Arc;
 
-pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan.clone(),
-        eventual_consumer: load_data.consumer.clone(),
-    };
+pub fn factory(mut load_data: LoadData, classifier: Arc<MIMEClassifier>) {
     match load_data.url.non_relative_scheme_data().unwrap() {
         "blank" => {
-            let chan = start_sending(senders, Metadata {
+            let start_chan = load_data.consumer;
+            let chan = start_sending(start_chan, Metadata {
                 final_url: load_data.url,
                 content_type: Some(("text".to_string(), "html".to_string())),
                 charset: Some("utf-8".to_string()),
@@ -40,10 +38,11 @@ pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>
             load_data.url = Url::from_file_path(&*path).unwrap();
         }
         _ => {
-            start_sending(senders, Metadata::default(load_data.url))
+            let start_chan = load_data.consumer;
+            start_sending(start_chan, Metadata::default(load_data.url))
                 .send(Done(Err("Unknown about: URL.".to_string()))).unwrap();
             return
         }
     };
-    file_loader::factory(load_data, start_chan)
+    file_loader::factory(load_data, classifier)
 }
diff --git a/components/net/data_loader.rs b/components/net/data_loader.rs
index a758ce33550..dc1b4356390 100644
--- a/components/net/data_loader.rs
+++ b/components/net/data_loader.rs
@@ -4,34 +4,30 @@
 
 use net_traits::{LoadData, Metadata};
 use net_traits::ProgressMsg::{Payload, Done};
-use resource_task::{TargetedLoadResponse, start_sending, ResponseSenders};
+use mime_classifier::MIMEClassifier;
+use resource_task::start_sending;
 
 use rustc_serialize::base64::FromBase64;
 
 use hyper::mime::Mime;
+use std::sync::Arc;
 use url::{percent_decode, SchemeData};
 
-use std::sync::mpsc::Sender;
-
-pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
+pub fn factory(load_data: LoadData, _classifier: Arc<MIMEClassifier>) {
     // NB: we don't spawn a new task.
     // Hypothesis: data URLs are too small for parallel base64 etc. to be worth it.
     // Should be tested at some point.
     // Left in separate function to allow easy moving to a task, if desired.
-    load(load_data, start_chan)
+    load(load_data)
 }
 
-fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
+fn load(load_data: LoadData) {
+    let start_chan = load_data.consumer;
     let url = load_data.url;
     assert!(&*url.scheme == "data");
 
     let mut metadata = Metadata::default(url.clone());
 
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan,
-        eventual_consumer: load_data.consumer,
-    };
-
     // Split out content type and data.
     let mut scheme_data = match url.scheme_data {
         SchemeData::NonRelative(scheme_data) => scheme_data,
@@ -46,7 +42,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
     }
     let parts: Vec<&str> = scheme_data.splitn(1, ',').collect();
     if parts.len() != 2 {
-        start_sending(senders, metadata).send(Done(Err("invalid data uri".to_string()))).unwrap();
+        start_sending(start_chan, metadata).send(Done(Err("invalid data uri".to_string()))).unwrap();
         return;
     }
 
@@ -64,7 +60,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
     let content_type: Option<Mime> = ct_str.parse().ok();
     metadata.set_content_type(content_type.as_ref());
 
-    let progress_chan = start_sending(senders, metadata);
+    let progress_chan = start_sending(start_chan, metadata);
     let bytes = percent_decode(parts[1].as_bytes());
 
     if is_base64 {
@@ -93,11 +89,9 @@ fn assert_parse(url:          &'static str,
                 data:         Option<Vec<u8>>) {
     use std::sync::mpsc::channel;
     use url::Url;
-    use sniffer_task;
 
     let (start_chan, start_port) = channel();
-    let sniffer_task = sniffer_task::new_sniffer_task();
-    load(LoadData::new(Url::parse(url).unwrap(), start_chan), sniffer_task);
+    load(LoadData::new(Url::parse(url).unwrap(), start_chan));
 
     let response = start_port.recv().unwrap();
     assert_eq!(&response.metadata.content_type, &content_type);
diff --git a/components/net/file_loader.rs b/components/net/file_loader.rs
index 636c14f60e5..83fcc7ed59f 100644
--- a/components/net/file_loader.rs
+++ b/components/net/file_loader.rs
@@ -4,55 +4,78 @@
 
 use net_traits::{LoadData, Metadata, ProgressMsg};
 use net_traits::ProgressMsg::{Payload, Done};
-use resource_task::{start_sending, TargetedLoadResponse, ResponseSenders};
+use mime_classifier::MIMEClassifier;
+use resource_task::{start_sending, start_sending_sniffed};
 
 use std::borrow::ToOwned;
 use std::io;
 use std::fs::File;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::sync::mpsc::Sender;
 use util::task::spawn_named;
 
 static READ_SIZE: uint = 8192;
 
+enum ReadStatus {
+    Partial(Vec<u8>),
+    EOF,
+}
+
+fn read_block(reader: &mut io::Read) -> Result<ReadStatus, String> {
+    let mut buf = vec![0; READ_SIZE];
+    match reader.read(buf.as_mut_slice()) {
+        Ok(0) => return Ok(ReadStatus::EOF),
+        Ok(n) => {
+            buf.truncate(n);
+            Ok(ReadStatus::Partial(buf))
+        }
+        Err(e) => Err(e.description().to_string()),
+    }
+}
+
 fn read_all(reader: &mut io::Read, progress_chan: &Sender<ProgressMsg>)
-        -> Result<(), String> {
+            -> Result<(), String> {
     loop {
-        let mut buf = vec![0; READ_SIZE];
-        match reader.read(buf.as_mut_slice()) {
-            Ok(0) => return Ok(()),
-            Ok(n) => {
-                buf.truncate(n);
-                progress_chan.send(Payload(buf)).unwrap();
-            },
-            Err(e) => return Err(e.description().to_string()),
+        match try!(read_block(reader)) {
+            ReadStatus::Partial(buf) => progress_chan.send(Payload(buf)).unwrap(),
+            ReadStatus::EOF => return Ok(()),
         }
     }
 }
 
-pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
+pub fn factory(load_data: LoadData, classifier: Arc<MIMEClassifier>) {
     let url = load_data.url;
+    let start_chan = load_data.consumer;
     assert!(&*url.scheme == "file");
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan,
-        eventual_consumer: load_data.consumer,
-    };
-    let progress_chan = start_sending(senders, Metadata::default(url.clone()));
     spawn_named("file_loader".to_owned(), move || {
+        let metadata = Metadata::default(url.clone());
         let file_path: Result<PathBuf, ()> = url.to_file_path();
         match file_path {
             Ok(file_path) => {
                 match File::open(&file_path) {
                     Ok(ref mut reader) => {
-                        let res = read_all(reader, &progress_chan);
+                        let res = read_block(reader);
+                        let (res, progress_chan) = match res {
+                            Ok(ReadStatus::Partial(buf)) => {
+                                let progress_chan = start_sending_sniffed(start_chan, metadata,
+                                                                          classifier, &buf);
+                                progress_chan.send(Payload(buf)).unwrap();
+                                (read_all(reader, &progress_chan), progress_chan)
+                            }
+                            Ok(ReadStatus::EOF) | Err(_) =>
+                                (res.map(|_| ()), start_sending(start_chan, metadata)),
+                        };
                         progress_chan.send(Done(res)).unwrap();
                     }
                     Err(e) => {
+                        let progress_chan = start_sending(start_chan, metadata);
                         progress_chan.send(Done(Err(e.description().to_string()))).unwrap();
                     }
                 }
             }
             Err(_) => {
+                let progress_chan = start_sending(start_chan, metadata);
                 progress_chan.send(Done(Err(url.to_string()))).unwrap();
             }
         }
diff --git a/components/net/http_loader.rs b/components/net/http_loader.rs
index 2dadcdfa3d9..c59066293dd 100644
--- a/components/net/http_loader.rs
+++ b/components/net/http_loader.rs
@@ -2,10 +2,10 @@
  * 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 net_traits::{ControlMsg, CookieSource, LoadData, Metadata};
-use net_traits::ProgressMsg;
+use net_traits::{ControlMsg, CookieSource, LoadData, LoadResponse, Metadata};
 use net_traits::ProgressMsg::{Payload, Done};
-use resource_task::{TargetedLoadResponse, start_sending_opt, ResponseSenders};
+use mime_classifier::MIMEClassifier;
+use resource_task::{start_sending_opt, start_sending_sniffed_opt};
 
 use log;
 use std::collections::HashSet;
@@ -21,6 +21,7 @@ use hyper::status::{StatusCode, StatusClass};
 use std::error::Error;
 use openssl::ssl::{SslContext, SslVerifyMode};
 use std::io::{self, Read, Write};
+use std::sync::Arc;
 use std::sync::mpsc::{Sender, channel};
 use std::thunk::Invoke;
 use util::task::spawn_named;
@@ -31,36 +32,50 @@ use url::{Url, UrlParser};
 use std::borrow::ToOwned;
 
 pub fn factory(cookies_chan: Sender<ControlMsg>)
-               -> Box<Invoke<(LoadData, Sender<TargetedLoadResponse>)> + Send> {
-    box move |(load_data, start_chan)| {
-        spawn_named("http_loader".to_owned(), move || load(load_data, start_chan, cookies_chan))
+               -> Box<Invoke<(LoadData, Arc<MIMEClassifier>)> + Send> {
+    box move |(load_data, classifier)| {
+        spawn_named("http_loader".to_owned(), move || load(load_data, classifier, cookies_chan))
     }
 }
 
-fn send_error(url: Url, err: String, senders: ResponseSenders) {
+fn send_error(url: Url, err: String, start_chan: Sender<LoadResponse>) {
     let mut metadata: Metadata = Metadata::default(url);
     metadata.status = None;
 
-    match start_sending_opt(senders, metadata) {
+    match start_sending_opt(start_chan, metadata) {
         Ok(p) => p.send(Done(Err(err))).unwrap(),
         _ => {}
     };
 }
 
-fn load(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>, cookies_chan: Sender<ControlMsg>) {
+enum ReadResult {
+    Payload(Vec<u8>),
+    EOF,
+}
+
+fn read_block<R: Read>(reader: &mut R) -> Result<ReadResult, ()> {
+    let mut buf = vec![0; 1024];
+
+    match reader.read(buf.as_mut_slice()) {
+        Ok(len) if len > 0 => {
+            unsafe { buf.set_len(len); }
+            Ok(ReadResult::Payload(buf))
+        }
+        Ok(_) => Ok(ReadResult::EOF),
+        Err(_) => Err(()),
+    }
+}
+
+fn load(mut load_data: LoadData, classifier: Arc<MIMEClassifier>, cookies_chan: Sender<ControlMsg>) {
     // FIXME: At the time of writing this FIXME, servo didn't have any central
     //        location for configuration. If you're reading this and such a
     //        repository DOES exist, please update this constant to use it.
     let max_redirects = 50u;
     let mut iters = 0u;
+    let start_chan = load_data.consumer;
     let mut url = load_data.url.clone();
     let mut redirected_to = HashSet::new();
 
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan,
-        eventual_consumer: load_data.consumer
-    };
-
     // If the URL is a view-source scheme then the scheme data contains the
     // real URL that should be used for which the source is to be viewed.
     // Change our existing URL to that and keep note that we are viewing
@@ -73,7 +88,7 @@ fn load(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>, cooki
             "http" | "https" => {}
             _ => {
                 let s = format!("The {} scheme with view-source is not supported", url.scheme);
-                send_error(url, s, senders);
+                send_error(url, s, start_chan);
                 return;
             }
         };
@@ -84,7 +99,7 @@ fn load(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>, cooki
         iters = iters + 1;
 
         if iters > max_redirects {
-            send_error(url, "too many redirects".to_string(), senders);
+            send_error(url, "too many redirects".to_string(), start_chan);
             return;
         }
 
@@ -92,7 +107,7 @@ fn load(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>, cooki
             "http" | "https" => {}
             _ => {
                 let s = format!("{} request, but we don't support that scheme", url.scheme);
-                send_error(url, s, senders);
+                send_error(url, s, start_chan);
                 return;
             }
         }
@@ -125,13 +140,13 @@ reason: \"certificate verify failed\" }]";
             ) => {
                 let mut image = resources_dir_path();
                 image.push("badcert.html");
-                let load_data = LoadData::new(Url::from_file_path(&*image).unwrap(), senders.eventual_consumer);
-                file_loader::factory(load_data, senders.immediate_consumer);
+                let load_data = LoadData::new(Url::from_file_path(&*image).unwrap(), start_chan);
+                file_loader::factory(load_data, classifier);
                 return;
             },
             Err(e) => {
                 println!("{:?}", e);
-                send_error(url, e.description().to_string(), senders);
+                send_error(url, e.description().to_string(), start_chan);
                 return;
             }
         };
@@ -179,13 +194,13 @@ reason: \"certificate verify failed\" }]";
                 let mut writer = match req.start() {
                     Ok(w) => w,
                     Err(e) => {
-                        send_error(url, e.description().to_string(), senders);
+                        send_error(url, e.description().to_string(), start_chan);
                         return;
                     }
                 };
                 match writer.write_all(&*data) {
                     Err(e) => {
-                        send_error(url, e.description().to_string(), senders);
+                        send_error(url, e.description().to_string(), start_chan);
                         return;
                     }
                     _ => {}
@@ -200,7 +215,7 @@ reason: \"certificate verify failed\" }]";
                 match req.start() {
                     Ok(w) => w,
                     Err(e) => {
-                        send_error(url, e.description().to_string(), senders);
+                        send_error(url, e.description().to_string(), start_chan);
                         return;
                     }
                 }
@@ -209,7 +224,7 @@ reason: \"certificate verify failed\" }]";
         let mut response = match writer.send() {
             Ok(r) => r,
             Err(e) => {
-                send_error(url, e.description().to_string(), senders);
+                send_error(url, e.description().to_string(), start_chan);
                 return;
             }
         };
@@ -240,7 +255,7 @@ reason: \"certificate verify failed\" }]";
                         Some(ref c) => {
                             if c.preflight {
                                 // The preflight lied
-                                send_error(url, "Preflight fetch inconsistent with main fetch".to_string(), senders);
+                                send_error(url, "Preflight fetch inconsistent with main fetch".to_string(), start_chan);
                                 return;
                             } else {
                                 // XXXManishearth There are some CORS-related steps here,
@@ -252,7 +267,7 @@ reason: \"certificate verify failed\" }]";
                     let new_url = match UrlParser::new().base_url(&url).parse(&new_url) {
                         Ok(u) => u,
                         Err(e) => {
-                            send_error(url, e.to_string(), senders);
+                            send_error(url, e.to_string(), start_chan);
                             return;
                         }
                     };
@@ -268,7 +283,7 @@ reason: \"certificate verify failed\" }]";
                     }
 
                     if redirected_to.contains(&url) {
-                        send_error(url, "redirect loop".to_string(), senders);
+                        send_error(url, "redirect loop".to_string(), start_chan);
                         return;
                     }
 
@@ -291,11 +306,6 @@ reason: \"certificate verify failed\" }]";
         metadata.headers = Some(adjusted_headers);
         metadata.status = Some(response.status_raw().clone());
 
-        let progress_chan = match start_sending_opt(senders, metadata) {
-            Ok(p) => p,
-            _ => return
-        };
-
         let mut encoding_str: Option<String> = None;
         //FIXME: Implement Content-Encoding Header https://github.com/hyperium/hyper/issues/391
         if let Some(encodings) = response.headers.get_raw("content-encoding") {
@@ -313,14 +323,14 @@ reason: \"certificate verify failed\" }]";
             Some(encoding) => {
                 if encoding == "gzip" {
                     let mut response_decoding = GzDecoder::new(response).unwrap();
-                    send_data(&mut response_decoding, progress_chan);
+                    send_data(&mut response_decoding, start_chan, metadata, classifier);
                 } else if encoding == "deflate" {
                     let mut response_decoding = DeflateDecoder::new(response);
-                    send_data(&mut response_decoding, progress_chan);
+                    send_data(&mut response_decoding, start_chan, metadata, classifier);
                 }
             },
             None => {
-                send_data(&mut response, progress_chan);
+                send_data(&mut response, start_chan, metadata, classifier);
             }
         }
 
@@ -329,25 +339,35 @@ reason: \"certificate verify failed\" }]";
     }
 }
 
-fn send_data<R: Read>(reader: &mut R, progress_chan: Sender<ProgressMsg>) {
-    loop {
-        let mut buf = Vec::with_capacity(1024);
+fn send_data<R: Read>(reader: &mut R,
+                      start_chan: Sender<LoadResponse>,
+                      metadata: Metadata,
+                      classifier: Arc<MIMEClassifier>) {
+    let (progress_chan, mut chunk) = {
+        let buf = match read_block(reader) {
+            Ok(ReadResult::Payload(buf)) => buf,
+            _ => vec!(),
+        };
+        let p = match start_sending_sniffed_opt(start_chan, metadata, classifier, &buf) {
+            Ok(p) => p,
+            _ => return
+        };
+        (p, buf)
+    };
 
-        unsafe { buf.set_len(1024); }
-        match reader.read(buf.as_mut_slice()) {
-            Ok(len) if len > 0 => {
-                unsafe { buf.set_len(len); }
-                if progress_chan.send(Payload(buf)).is_err() {
-                    // The send errors when the receiver is out of scope,
-                    // which will happen if the fetch has timed out (or has been aborted)
-                    // so we don't need to continue with the loading of the file here.
-                    return;
-                }
-            }
-            Ok(_) | Err(_) => {
-                let _ = progress_chan.send(Done(Ok(())));
-                break;
-            }
+    loop {
+        if progress_chan.send(Payload(chunk)).is_err() {
+            // The send errors when the receiver is out of scope,
+            // which will happen if the fetch has timed out (or has been aborted)
+            // so we don't need to continue with the loading of the file here.
+            return;
         }
+
+        chunk = match read_block(reader) {
+            Ok(ReadResult::Payload(buf)) => buf,
+            Ok(ReadResult::EOF) | Err(_) => break,
+        };
     }
+
+    let _ = progress_chan.send(Done(Ok(())));
 }
diff --git a/components/net/image_cache_task.rs b/components/net/image_cache_task.rs
index 03ee5c8a52e..df38f9d7c31 100644
--- a/components/net/image_cache_task.rs
+++ b/components/net/image_cache_task.rs
@@ -428,11 +428,10 @@ mod tests {
     use net_traits::image_cache_task::ImageResponseMsg::*;
     use net_traits::image_cache_task::Msg::*;
 
-    use resource_task::{start_sending, ResponseSenders};
+    use resource_task::start_sending;
     use net_traits::{ControlMsg, Metadata, ProgressMsg, ResourceTask};
     use net_traits::image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg};
     use net_traits::ProgressMsg::{Payload, Done};
-    use sniffer_task;
     use profile::time;
     use std::sync::mpsc::{Sender, channel, Receiver};
     use url::Url;
@@ -534,12 +533,7 @@ mod tests {
             loop {
                 match port.recv().unwrap() {
                     ControlMsg::Load(response) => {
-                        let sniffer_task = sniffer_task::new_sniffer_task();
-                        let senders = ResponseSenders {
-                            immediate_consumer: sniffer_task,
-                            eventual_consumer: response.consumer.clone(),
-                        };
-                        let chan = start_sending(senders, Metadata::default(
+                        let chan = start_sending(response.consumer, Metadata::default(
                             Url::parse("file:///fake").unwrap()));
                         on_load.invoke(chan);
                     }
@@ -709,12 +703,7 @@ mod tests {
             loop {
                 match port.recv().unwrap() {
                     ControlMsg::Load(response) => {
-                        let sniffer_task = sniffer_task::new_sniffer_task();
-                        let senders = ResponseSenders {
-                            immediate_consumer: sniffer_task,
-                            eventual_consumer: response.consumer.clone(),
-                        };
-                        let chan = start_sending(senders, Metadata::default(
+                        let chan = start_sending(response.consumer, Metadata::default(
                             Url::parse("file:///fake").unwrap()));
                         chan.send(Payload(test_image_bin()));
                         chan.send(Done(Ok(())));
@@ -763,12 +752,7 @@ mod tests {
             loop {
                 match port.recv().unwrap() {
                     ControlMsg::Load(response) => {
-                        let sniffer_task = sniffer_task::new_sniffer_task();
-                        let senders = ResponseSenders {
-                            immediate_consumer: sniffer_task,
-                            eventual_consumer: response.consumer.clone(),
-                        };
-                        let chan = start_sending(senders, Metadata::default(
+                        let chan = start_sending(response.consumer, Metadata::default(
                             Url::parse("file:///fake").unwrap()));
                         chan.send(Payload(test_image_bin()));
                         chan.send(Done(Err("".to_string())));
diff --git a/components/net/lib.rs b/components/net/lib.rs
index 46b123630d8..bd2bd882570 100644
--- a/components/net/lib.rs
+++ b/components/net/lib.rs
@@ -46,7 +46,7 @@ pub mod image_cache_task;
 pub mod pub_domains;
 pub mod resource_task;
 pub mod storage_task;
-mod sniffer_task;
+mod mime_classifier;
 
 /// An implementation of the [Fetch spec](http://fetch.spec.whatwg.org/)
 pub mod fetch {
diff --git a/components/net/mime_classifier.rs b/components/net/mime_classifier.rs
new file mode 100644
index 00000000000..773436d92d9
--- /dev/null
+++ b/components/net/mime_classifier.rs
@@ -0,0 +1,1415 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 std::borrow::ToOwned;
+use std::cmp::max;
+
+pub struct MIMEClassifier {
+   image_classifier: GroupedClassifier,
+   audio_video_classifer: GroupedClassifier,
+   scriptable_classifier: GroupedClassifier,
+   plaintext_classifier: GroupedClassifier,
+   archive_classifer: GroupedClassifier,
+   binary_or_plaintext: BinaryOrPlaintextClassifier,
+   feeds_classifier: FeedsClassifier
+}
+
+impl MIMEClassifier {
+    //Performs MIME Type Sniffing Algorithm (section 7)
+    pub fn classify(&self,
+                    no_sniff: bool,
+                    check_for_apache_bug: bool,
+                    supplied_type: &Option<(String, String)>,
+                    data: &Vec<u8>) -> Option<(String, String)> {
+
+        match *supplied_type{
+            None => {
+              return self.sniff_unknown_type(!no_sniff, data);
+            }
+            Some((ref media_type, ref media_subtype)) => {
+                match (media_type.as_slice(), media_subtype.as_slice()) {
+                    ("uknown", "unknown") | ("application", "uknown") | ("*", "*") => {
+                        return self.sniff_unknown_type(!no_sniff,data);
+                    }
+                    _ => {
+                        if no_sniff {
+                            return supplied_type.clone();
+                        }
+                        if check_for_apache_bug {
+                          return self.sniff_text_or_data(data);
+                        }
+
+                        if MIMEClassifier::is_xml(media_type, media_subtype) {
+                          return supplied_type.clone();
+                        }
+                        //Inplied in section 7.3, but flow is not clear
+                        if MIMEClassifier::is_html(media_type, media_subtype) {
+                            return self.feeds_classifier
+                                       .classify(data)
+                                       .or(supplied_type.clone());
+                         }
+
+                         if media_type.as_slice() == "image" {
+                           let tp = self.image_classifier.classify(data);
+                           if tp.is_some() {
+                               return tp;
+                           }
+                         }
+
+                         match (media_type.as_slice(), media_subtype.as_slice()) {
+                             ("audio", _) | ("video", _) | ("application", "ogg") => {
+                                 let tp = self.audio_video_classifer.classify(data);
+                                 if tp.is_some() {
+                                     return tp;
+                                 }
+                             }
+                             _ => {}
+                         }
+                    }
+                }
+            }
+        }
+        return supplied_type.clone();
+    }
+
+    pub fn new()->MIMEClassifier {
+         MIMEClassifier{
+             image_classifier: GroupedClassifier::image_classifer(),
+             audio_video_classifer: GroupedClassifier::audio_video_classifer(),
+             scriptable_classifier: GroupedClassifier::scriptable_classifier(),
+             plaintext_classifier: GroupedClassifier::plaintext_classifier(),
+             archive_classifer: GroupedClassifier::archive_classifier(),
+             binary_or_plaintext: BinaryOrPlaintextClassifier,
+             feeds_classifier: FeedsClassifier
+         }
+    }
+    //some sort of iterator over the classifiers might be better?
+    fn sniff_unknown_type(&self, sniff_scriptable: bool, data: &Vec<u8>) ->
+      Option<(String,String)> {
+        if sniff_scriptable {
+            let tp = self.scriptable_classifier.classify(data);
+            if tp.is_some() {return tp;}
+        }
+
+        let tp = self.plaintext_classifier.classify(data);
+        if tp.is_some() {return tp;}
+
+        let tp = self.image_classifier.classify(data);
+        if tp.is_some() {return tp;}
+
+        let tp = self.audio_video_classifer.classify(data);
+        if tp.is_some() {return tp;}
+
+        let tp = self.archive_classifer.classify(data);
+        if tp.is_some() {return tp;}
+
+        self.binary_or_plaintext.classify(data)
+    }
+
+    fn sniff_text_or_data(&self, data: &Vec<u8>) -> Option<(String, String)> {
+        self.binary_or_plaintext.classify(data)
+    }
+    fn is_xml(tp: &str, sub_tp: &str) -> bool {
+        let suffix = &sub_tp[(max((sub_tp.len() as int) - ("+xml".len() as int), 0i) as uint)..];
+        match (tp, sub_tp, suffix) {
+            (_, _, "+xml") | ("application", "xml",_) | ("text", "xml",_) => {true}
+            _ => {false}
+      }
+    }
+    fn is_html(tp: &str, sub_tp: &str) -> bool {
+        tp=="text" && sub_tp=="html"
+    }
+}
+
+fn as_string_option(tup: Option<(&'static str, &'static str)>) -> Option<(String,String)> {
+    tup.map(|(a, b)| (a.to_owned(), b.to_owned()))
+}
+
+//Interface used for composite types
+trait MIMEChecker {
+    fn classify(&self, data: &Vec<u8>)->Option<(String, String)>;
+}
+
+trait Matches {
+    fn matches(&mut self, matches: &[u8])->bool;
+}
+
+impl <'a, T: Iterator<Item=&'a u8> + Clone> Matches for T {
+
+    // Matching function that works on an iterator.
+    // see if the next matches.len() bytes in data_iterator equal matches
+    // move iterator and return true or just return false
+    //
+    // Params
+    // self: an iterator
+    // matches: a vector of bytes to match
+    //
+    // Return
+    // true if the next n elements of self match n elements of matches
+    // false otherwise
+    //
+    // Side effects
+    // moves the iterator when match is found
+    fn matches(&mut self, matches: &[u8]) -> bool {
+        for (byte_a, byte_b) in self.clone().take(matches.len()).zip(matches.iter()) {
+            if byte_a != byte_b {
+                return false;
+            }
+        }
+        self.nth(matches.len());
+        true
+    }
+}
+
+struct ByteMatcher {
+    pattern: &'static [u8],
+    mask: &'static [u8],
+    leading_ignore: &'static [u8],
+    content_type: (&'static str,&'static str)
+}
+
+impl ByteMatcher {
+    fn matches(&self, data: &Vec<u8>) -> Option<uint> {
+
+        if data.len() < self.pattern.len() {
+            return None;
+        }
+        //TODO replace with iterators if I ever figure them out...
+        let mut i = 0u;
+        let max_i = data.len()-self.pattern.len();
+
+        loop {
+            if !self.leading_ignore.iter().any(|x| *x == data[i]) {
+                break;
+            }
+
+            i=i + 1;
+            if i > max_i {
+                return None;
+            }
+        }
+        for j in range(0u,self.pattern.len()) {
+            if (data[i] & self.mask[j]) != (self.pattern[j] & self.mask[j]) {
+                return None;
+            }
+            i = i + 1;
+        }
+        Some(i)
+    }
+}
+
+impl MIMEChecker for ByteMatcher {
+    fn classify(&self, data: &Vec<u8>) -> Option<(String, String)> {
+        self.matches(data).map(|_| {
+            (self.content_type.0.to_owned(), self.content_type.1.to_owned())
+        })
+    }
+}
+
+struct TagTerminatedByteMatcher {
+  matcher: ByteMatcher
+}
+
+impl MIMEChecker for TagTerminatedByteMatcher {
+    fn classify(&self, data: &Vec<u8>) -> Option<(String, String)> {
+        let pattern = self.matcher.matches(data);
+        let pattern_matches = pattern.map(|j| j < data.len() && (data[j] == b' ' || data[j] == b'>'));
+        if pattern_matches.unwrap_or(false) {
+            Some((self.matcher.content_type.0.to_owned(),
+                  self.matcher.content_type.1.to_owned()))
+        } else {
+            None
+        }
+    }
+}
+struct Mp4Matcher;
+
+impl Mp4Matcher {
+    fn matches(&self,data: &Vec<u8>) -> bool {
+        if data.len() < 12 {
+            return false;
+        }
+        let box_size = ((data[0] as u32) << 3 | (data[1] as u32) << 2 |
+                        (data[2] as u32) << 1 | (data[3] as u32)) as uint;
+        if (data.len() < box_size) || (box_size % 4 != 0) {
+            return false;
+        }
+        //TODO replace with iterators
+        let ftyp = [0x66, 0x74, 0x79, 0x70];
+        let mp4 =  [0x6D, 0x70, 0x34];
+
+        for i in range(4u,8u) {
+            if data[i] != ftyp[i - 4] {
+                return false;
+            }
+        }
+        let mut all_match = true;
+        for i in range(8u,11u) {
+            if data[i]!=mp4[i - 8u] {
+                all_match = false;
+                break;
+            }
+        }
+        if all_match {
+            return true;
+        }
+
+        let mut bytes_read = 16u;
+
+        while bytes_read < box_size {
+            all_match = true;
+            for i in range(0u,3u) {
+                if mp4[i] != data[i + bytes_read] {
+                    all_match = false;
+                    break;
+                }
+            }
+            if all_match {
+                return true;
+            }
+
+            bytes_read = bytes_read + 4;
+        }
+        false
+    }
+
+}
+impl MIMEChecker for Mp4Matcher {
+    fn classify(&self, data: &Vec<u8>) -> Option<(String, String)> {
+        if self.matches(data) {
+            Some(("video".to_owned(), "mp4".to_owned()))
+        } else {
+            None
+        }
+    }
+}
+
+struct BinaryOrPlaintextClassifier;
+
+impl BinaryOrPlaintextClassifier {
+    fn classify_impl(&self, data: &Vec<u8>) -> Option<(&'static str, &'static str)> {
+        if (data.len() >=2 &&
+            ((data[0] == 0xFFu8 && data[1] == 0xFEu8) ||
+            (data[0] == 0xFEu8 && data[1] == 0xFFu8))) ||
+            (data.len() >= 3 && data[0] == 0xEFu8 && data[1] == 0xBBu8 && data[2] == 0xBFu8)
+        {
+            Some(("text", "plain"))
+        }
+        else if data.len() >= 1 && data.iter().any(|&x| x <= 0x08u8 ||
+                                                        x == 0x0Bu8 ||
+                                                        (x >= 0x0Eu8 && x <= 0x1Au8) ||
+                                                        (x >= 0x1Cu8 && x <= 0x1Fu8)) {
+            Some(("application", "octet-stream"))
+        }
+        else {
+            Some(("text", "plain"))
+        }
+    }
+}
+impl MIMEChecker for BinaryOrPlaintextClassifier {
+    fn classify(&self, data: &Vec<u8>) -> Option<(String, String)> {
+        return as_string_option(self.classify_impl(data));
+    }
+}
+struct GroupedClassifier {
+   byte_matchers: Vec<Box<MIMEChecker + Send + Sync>>,
+}
+impl GroupedClassifier {
+    fn image_classifer() -> GroupedClassifier {
+        GroupedClassifier {
+            byte_matchers: vec![
+                box ByteMatcher::image_x_icon(),
+                box ByteMatcher::image_x_icon_cursor(),
+                box ByteMatcher::image_bmp(),
+                box ByteMatcher::image_gif89a(),
+                box ByteMatcher::image_gif87a(),
+                box ByteMatcher::image_webp(),
+                box ByteMatcher::image_png(),
+                box ByteMatcher::image_jpeg(),
+            ]
+        }
+    }
+    fn audio_video_classifer() -> GroupedClassifier {
+        GroupedClassifier{
+            byte_matchers: vec![
+                box ByteMatcher::video_webm(),
+                box ByteMatcher::audio_basic(),
+                box ByteMatcher::audio_aiff(),
+                box ByteMatcher::audio_mpeg(),
+                box ByteMatcher::application_ogg(),
+                box ByteMatcher::audio_midi(),
+                box ByteMatcher::video_avi(),
+                box ByteMatcher::audio_wave(),
+                box Mp4Matcher
+            ]
+        }
+    }
+    fn scriptable_classifier() -> GroupedClassifier {
+        GroupedClassifier{
+            byte_matchers: vec![
+                box ByteMatcher::text_html_doctype(),
+                box ByteMatcher::text_html_page(),
+                box ByteMatcher::text_html_head(),
+                box ByteMatcher::text_html_script(),
+                box ByteMatcher::text_html_iframe(),
+                box ByteMatcher::text_html_h1(),
+                box ByteMatcher::text_html_div(),
+                box ByteMatcher::text_html_font(),
+                box ByteMatcher::text_html_table(),
+                box ByteMatcher::text_html_a(),
+                box ByteMatcher::text_html_style(),
+                box ByteMatcher::text_html_title(),
+                box ByteMatcher::text_html_b(),
+                box ByteMatcher::text_html_body(),
+                box ByteMatcher::text_html_br(),
+                box ByteMatcher::text_html_p(),
+                box ByteMatcher::text_html_comment(),
+                box ByteMatcher::text_xml(),
+                box ByteMatcher::application_pdf()
+            ]
+        }
+
+    }
+    fn plaintext_classifier() -> GroupedClassifier {
+        GroupedClassifier{
+            byte_matchers: vec![
+                box ByteMatcher::text_plain_utf_8_bom(),
+                box ByteMatcher::text_plain_utf_16le_bom(),
+                box ByteMatcher::text_plain_utf_16be_bom(),
+                box ByteMatcher::application_postscript()
+            ]
+        }
+    }
+    fn archive_classifier() -> GroupedClassifier {
+        GroupedClassifier {
+            byte_matchers: vec![
+                box ByteMatcher::application_x_gzip(),
+                box ByteMatcher::application_zip(),
+                box ByteMatcher::application_x_rar_compressed()
+            ]
+        }
+    }
+
+    // TODO: Use this in font context classifier
+    #[allow(dead_code)]
+    fn font_classifier() -> GroupedClassifier {
+        GroupedClassifier {
+            byte_matchers: vec![
+                box ByteMatcher::application_font_woff(),
+                box ByteMatcher::true_type_collection(),
+                box ByteMatcher::open_type(),
+                box ByteMatcher::true_type(),
+                box ByteMatcher::application_vnd_ms_font_object(),
+            ]
+        }
+    }
+}
+impl MIMEChecker for GroupedClassifier {
+   fn classify(&self,data: &Vec<u8>) -> Option<(String, String)> {
+        self.byte_matchers
+            .iter()
+            .filter_map(|matcher| matcher.classify(data))
+            .next()
+   }
+}
+
+struct FeedsClassifier;
+impl FeedsClassifier {
+    fn classify_impl(&self,data: &Vec<u8>) -> Option<(&'static str,&'static str)> {
+        let length = data.len();
+        let mut data_iterator = data.iter();
+
+        // acceptable byte sequences
+        let utf8_bom = &[0xEFu8, 0xBBu8, 0xBFu8];
+
+        // can not be feed unless length is > 3
+        if length < 3 {
+            return None;
+        }
+
+        // eat the first three bytes if they are equal to UTF-8 BOM
+        data_iterator.matches(utf8_bom);
+
+        // continuously search for next "<" until end of data_iterator
+        // TODO: need max_bytes to prevent inadvertently examining html document
+        //       eg. an html page with a feed example
+        while !data_iterator.find(|&data_iterator| *data_iterator == b'<').is_none() {
+
+            if data_iterator.matches(b"?") {
+                // eat until ?>
+                while !data_iterator.matches(b"?>") {
+                    if data_iterator.next().is_none() {
+                        return None;
+                    }
+                }
+            } else if data_iterator.matches(b"!--") {
+                // eat until -->
+                while !data_iterator.matches(b"-->") {
+                    if data_iterator.next().is_none() {
+                        return None;
+                    }
+                }
+            } else if data_iterator.matches(b"!") {
+                data_iterator.find(|&data_iterator| *data_iterator == b'>');
+            } else if data_iterator.matches(b"rss") {
+                return Some(("application", "rss+xml"));
+            } else if data_iterator.matches(b"feed") {
+                return Some(("application", "atom+xml"));
+            } else if data_iterator.matches(b"rdf: RDF") {
+                while !data_iterator.next().is_none() {
+                    if data_iterator.matches(b"http: //purl.org/rss/1.0/") {
+                        while !data_iterator.next().is_none() {
+                            if data_iterator.matches(b"http: //www.w3.org/1999/02/22-rdf-syntax-ns#") {
+                                return Some(("application", "rss+xml"));
+                            }
+                        }
+                    } else if data_iterator.matches(b"http: //www.w3.org/1999/02/22-rdf-syntax-ns#") {
+                        while !data_iterator.next().is_none() {
+                            if data_iterator.matches(b"http: //purl.org/rss/1.0/") {
+                                return Some(("application", "rss+xml"));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        None
+    }
+}
+
+impl MIMEChecker for FeedsClassifier {
+    fn classify(&self,data: &Vec<u8>) -> Option<(String, String)> {
+       as_string_option(self.classify_impl(data))
+    }
+}
+
+//Contains hard coded byte matchers
+//TODO: These should be configured and not hard coded
+impl ByteMatcher {
+    //A Windows Icon signature
+    fn image_x_icon()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x00\x00\x01\x00",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("image", "x-icon"),
+            leading_ignore: &[]
+        }
+    }
+    //A Windows Cursor signature.
+    fn image_x_icon_cursor()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x00\x00\x02\x00",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("image", "x-icon"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "BM", a BMP signature.
+    fn image_bmp()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"BM",
+            mask: b"\xFF\xFF",
+            content_type: ("image", "bmp"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "GIF89a", a GIF signature.
+    fn image_gif89a()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"GIF89a",
+            mask: b"\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("image", "gif"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "GIF87a", a GIF signature.
+    fn image_gif87a()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"GIF87a",
+            mask: b"\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("image", "gif"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "RIFF" followed by four bytes followed by the string "WEBPVP".
+    fn image_webp()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"RIFF\x00\x00\x00\x00WEBPVP",
+            mask: b"\xFF\xFF\xFF\xFF\x00\x00\x00\x00,\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("image", "webp"),
+            leading_ignore: &[]
+        }
+    }
+    //An error-checking byte followed by the string "PNG" followed by CR LF SUB LF, the PNG
+    //signature.
+    fn image_png()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x89PNG\r\n\x1A\n",
+            mask: b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("image", "png"),
+            leading_ignore: &[]
+        }
+    }
+    // The JPEG Start of Image marker followed by the indicator byte of another marker.
+    fn image_jpeg()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\xFF\xD8\xFF",
+            mask: b"\xFF\xFF\xFF",
+            content_type: ("image", "jpeg"),
+            leading_ignore: &[]
+        }
+    }
+    //The WebM signature. [TODO: Use more bytes?]
+    fn video_webm()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x1A\x45\xDF\xA3",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("video", "webm"),
+            leading_ignore: &[]
+        }
+    }
+    //The string ".snd", the basic audio signature.
+    fn audio_basic()->ByteMatcher {
+        ByteMatcher{
+            pattern: b".snd",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("audio", "basic"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "FORM" followed by four bytes followed by the string "AIFF", the AIFF signature.
+    fn audio_aiff()->ByteMatcher {
+        ByteMatcher{
+            pattern:  b"FORM\x00\x00\x00\x00AIFF",
+            mask:  b"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF",
+            content_type: ("audio", "aiff"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "ID3", the ID3v2-tagged MP3 signature.
+    fn audio_mpeg()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"ID3",
+            mask: b"\xFF\xFF\xFF",
+            content_type: ("audio", "mpeg"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "OggS" followed by NUL, the Ogg container signature.
+    fn application_ogg()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"OggS",
+            mask: b"\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("application", "ogg"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "MThd" followed by four bytes representing the number 6 in 32 bits (big-endian),
+    //the MIDI signature.
+    fn audio_midi()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"MThd\x00\x00\x00\x06",
+            mask: b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("audio", "midi"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "RIFF" followed by four bytes followed by the string "AVI ", the AVI signature.
+    fn video_avi()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"RIFF\x00\x00\x00\x00AVI ",
+            mask: b"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF",
+            content_type: ("video", "avi"),
+            leading_ignore: &[]
+        }
+    }
+    // The string "RIFF" followed by four bytes followed by the string "WAVE", the WAVE signature.
+    fn audio_wave()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"RIFF\x00\x00\x00\x00WAVE",
+            mask: b"\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF",
+            content_type: ("audio", "wave"),
+            leading_ignore: &[]
+        }
+    }
+    // doctype terminated with Tag terminating (TT) Byte
+    fn text_html_doctype()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<!DOCTYPE HTML",
+                mask: b"\xFF\xFF\xDF\xDF\xDF\xDF\xDF\xDF\xDF\xFF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+           }
+        }
+    }
+
+    // HTML terminated with Tag terminating (TT) Byte: 0x20 (SP)
+    fn text_html_page()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<HTML",
+                mask: b"\xFF\xDF\xDF\xDF\xDF\xFF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // head terminated with Tag Terminating (TT) Byte
+    fn text_html_head()->TagTerminatedByteMatcher {
+         TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<HEAD",
+                mask: b"\xFF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // script terminated with Tag Terminating (TT) Byte
+    fn text_html_script()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher {
+                pattern: b"<SCRIPT",
+                mask: b"\xFF\xDF\xDF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // iframe terminated with Tag Terminating (TT) Byte
+    fn text_html_iframe()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<IFRAME",
+                mask: b"\xFF\xDF\xDF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // h1 terminated with Tag Terminating (TT) Byte
+    fn text_html_h1()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<H1",
+                mask: b"\xFF\xDF\xFF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // div terminated with Tag Terminating (TT) Byte
+    fn text_html_div()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<DIV",
+                mask: b"\xFF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // font terminated with Tag Terminating (TT) Byte
+    fn text_html_font()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<FONT",
+                mask: b"\xFF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // table terminated with Tag Terminating (TT) Byte
+    fn text_html_table()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+            pattern: b"<TABLE",
+            mask: b"\xFF\xDF\xDF\xDF\xDF\xDF",
+            content_type: ("text", "html"),
+            leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // a terminated with Tag Terminating (TT) Byte
+    fn text_html_a()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<A",
+                mask: b"\xFF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // style terminated with Tag Terminating (TT) Byte
+    fn text_html_style()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<STYLE",
+                mask: b"\xFF\xDF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // title terminated with Tag Terminating (TT) Byte
+    fn text_html_title()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<TITLE",
+                mask: b"\xFF\xDF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // b terminated with Tag Terminating (TT) Byte
+    fn text_html_b()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<B",
+                mask: b"\xFF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // body terminated with Tag Terminating (TT) Byte
+    fn text_html_body()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<BODY",
+                mask: b"\xFF\xDF\xDF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // br terminated with Tag Terminating (TT) Byte
+    fn text_html_br()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<BR",
+                mask: b"\xFF\xDF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // p terminated with Tag Terminating (TT) Byte
+    fn text_html_p()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<P",
+                mask: b"\xFF\xDF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    // comment terminated with Tag Terminating (TT) Byte
+    fn text_html_comment()->TagTerminatedByteMatcher {
+        TagTerminatedByteMatcher {
+            matcher: ByteMatcher{
+                pattern: b"<!--",
+                mask: b"\xFF\xFF\xFF\xFF",
+                content_type: ("text", "html"),
+                leading_ignore: b"\t\n\x0C\r "
+            }
+        }
+    }
+
+    //The string "<?xml".
+    fn text_xml()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"<?xml",
+            mask: b"\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("text", "xml"),
+            leading_ignore: b"\t\n\x0C\r "
+     }
+    }
+    //The string "%PDF-", the PDF signature.
+    fn application_pdf()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"%PDF",
+            mask: b"\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("application", "pdf"),
+            leading_ignore: &[]
+        }
+    }
+    //34 bytes followed by the string "LP", the Embedded OpenType signature.
+    // TODO: Use this in font context classifier
+    #[allow(dead_code)]
+    fn application_vnd_ms_font_object()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
+                       \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
+                       \x00\x00LP",
+            mask: b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
+                    \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
+                    \x00\x00\xFF\xFF",
+            content_type: ("application", "vnd.ms-fontobject"),
+            leading_ignore: &[]
+        }
+    }
+    //4 bytes representing the version number 1.0, a TrueType signature.
+    // TODO: Use this in font context classifier
+    #[allow(dead_code)]
+    fn true_type()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x00\x01\x00\x00",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("(TrueType)", ""),
+            leading_ignore: &[]
+        }
+    }
+    //The string "OTTO", the OpenType signature.
+    // TODO: Use this in font context classifier
+    #[allow(dead_code)]
+    fn open_type()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"OTTO",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("(OpenType)", ""),
+            leading_ignore: &[]
+        }
+    }
+    // The string "ttcf", the TrueType Collection signature.
+    // TODO: Use this in font context classifier
+    #[allow(dead_code)]
+    fn true_type_collection()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"ttcf",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("(TrueType Collection)", ""),
+            leading_ignore: &[]
+        }
+    }
+    // The string "wOFF", the Web Open Font Format signature.
+    // TODO: Use this in font context classifier
+    #[allow(dead_code)]
+    fn application_font_woff()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"wOFF",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("application", "font-woff"),
+            leading_ignore: &[]
+        }
+    }
+    //The GZIP archive signature.
+    fn application_x_gzip()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\x1F\x8B\x08",
+            mask: b"\xFF\xFF\xFF",
+            content_type: ("application", "x-gzip"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "PK" followed by ETX EOT, the ZIP archive signature.
+    fn application_zip()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"PK\x03\x04",
+            mask: b"\xFF\xFF\xFF\xFF",
+            content_type: ("application", "zip"),
+            leading_ignore: &[]
+        }
+    }
+    //The string "Rar " followed by SUB BEL NUL, the RAR archive signature.
+    fn application_x_rar_compressed()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"Rar \x1A\x07\x00",
+            mask: b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("application", "x-rar-compressed"),
+            leading_ignore: &[]
+        }
+    }
+    // The string "%!PS-Adobe-", the PostScript signature.
+    fn application_postscript()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"%!PS-Adobe-",
+            mask:  b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
+            content_type: ("application", "postscript"),
+            leading_ignore: &[]
+        }
+    }
+    // UTF-16BE BOM
+    fn text_plain_utf_16be_bom()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\xFE\xFF\x00\x00",
+            mask: b"\xFF\xFF\x00\x00",
+            content_type: ("text", "plain"),
+            leading_ignore: &[]
+        }
+    }
+    //UTF-16LE BOM
+    fn text_plain_utf_16le_bom()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\xFF\xFE\x00\x00",
+            mask: b"\xFF\xFF\x00\x00",
+            content_type: ("text", "plain"),
+            leading_ignore: &[]
+        }
+    }
+    //UTF-8 BOM
+    fn text_plain_utf_8_bom()->ByteMatcher {
+        ByteMatcher{
+            pattern: b"\xEF\xBB\xBF\x00",
+            mask: b"\xFF\xFF\xFF\x00",
+            content_type: ("text", "plain"),
+            leading_ignore: &[]
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::old_io::File;
+    use std::os;
+    use super::Mp4Matcher;
+    use super::MIMEClassifier;
+    use super::as_string_option;
+
+    #[test]
+    fn test_sniff_mp4_matcher() {
+        let matcher = Mp4Matcher;
+
+        let p = Path::new("../../tests/content/parsable_mime/video/mp4/test.mp4");
+        let mut file = File::open(&p);
+        let read_result = file.read_to_end();
+        match read_result {
+            Ok(data) => {
+                println!("Data Length {:?}",data.len());
+                if !matcher.matches(&data) {
+                    panic!("Didn't read mime type")
+                }
+            },
+            Err(e) => panic!("Couldn't read from file with error {}",e)
+        }
+    }
+
+    #[cfg(test)]
+    fn test_sniff_full(filename_orig: &Path,type_string: &str,subtype_string: &str,
+                                supplied_type: Option<(&'static str,&'static str)>){
+        let current_working_directory = os::getcwd().unwrap();
+        println!("The current directory is {}", current_working_directory.display());
+
+        let mut filename = Path::new("../../tests/content/parsable_mime/");
+
+        filename.push(filename_orig);
+        let classifier = MIMEClassifier::new();
+
+        let mut file = File::open(&filename);
+        let read_result = file.read_to_end();
+        match read_result {
+            Ok(data) => {
+                match classifier.classify(false, false, &as_string_option(supplied_type), &data) {
+                    Some((parsed_type, parsed_subtp)) => {
+                         if (parsed_type.as_slice() != type_string) ||
+                            (parsed_subtp.as_slice() != subtype_string) {
+                            panic!("File {} parsed incorrectly should be {}/{}, parsed as {}/{}",
+                                   filename.as_str().unwrap(), type_string, subtype_string,
+                                   parsed_type, parsed_subtp);
+                        }
+                    }
+                    None => panic!("No classification found for {} with supplied type {:?}",
+                                   filename.as_str().unwrap(), supplied_type),
+                }
+            }
+            Err(e) => panic!("Couldn't read from file {} with error {}",
+                             filename.as_str().unwrap(), e),
+        }
+    }
+
+    #[cfg(test)]
+    fn test_sniff_classification(file: &str,type_string: &str,subtype_string: &str,
+                           supplied_type: Option<(&'static str,&'static str)>){
+        let mut x = Path::new("./");
+        x.push(type_string);
+        x.push(subtype_string);
+        x.push(file);
+        test_sniff_full(&x,type_string,subtype_string,supplied_type);
+    }
+    #[cfg(test)]
+    fn test_sniff_classification_sup(file: &str,type_string: &'static str,subtype_string: &str) {
+        test_sniff_classification(file,type_string,subtype_string, None);
+        let class_type = Some((type_string, ""));
+        test_sniff_classification(file,type_string,subtype_string,class_type);
+    }
+
+    #[test]
+    fn test_sniff_x_icon() {
+        test_sniff_classification_sup("test.ico", "image", "x-icon");
+    }
+
+    #[test]
+    fn test_sniff_x_icon_cursor() {
+        test_sniff_classification_sup("test_cursor.ico", "image", "x-icon");
+    }
+
+    #[test]
+    fn test_sniff_bmp() {
+        test_sniff_classification_sup("test.bmp", "image", "bmp");
+    }
+
+    #[test]
+    fn test_sniff_gif87a() {
+        test_sniff_classification_sup("test87a", "image", "gif");
+    }
+
+    #[test]
+    fn test_sniff_gif89a() {
+        test_sniff_classification_sup("test89a.gif", "image", "gif");
+    }
+
+    #[test]
+    fn test_sniff_webp() {
+        test_sniff_classification_sup("test.webp", "image", "webp");
+    }
+
+    #[test]
+    fn test_sniff_png() {
+        test_sniff_classification_sup("test.png", "image", "png");
+    }
+
+    #[test]
+    fn test_sniff_jpg() {
+        test_sniff_classification_sup("test.jpg", "image", "jpeg");
+    }
+
+    #[test]
+    fn test_sniff_webm() {
+        test_sniff_classification_sup("test.webm", "video", "webm");
+    }
+
+    #[test]
+    fn test_sniff_mp4() {
+        test_sniff_classification_sup("test.mp4", "video", "mp4");
+    }
+
+    #[test]
+    fn test_sniff_avi() {
+        test_sniff_classification_sup("test.avi", "video", "avi");
+    }
+
+    #[test]
+    fn test_sniff_basic() {
+        test_sniff_classification_sup("test.au", "audio", "basic");
+    }
+
+    #[test]
+    fn test_sniff_aiff() {
+        test_sniff_classification_sup("test.aif", "audio", "aiff");
+    }
+
+    #[test]
+    fn test_sniff_mpeg() {
+        test_sniff_classification_sup("test.mp3", "audio", "mpeg");
+    }
+
+    #[test]
+    fn test_sniff_midi() {
+        test_sniff_classification_sup("test.mid", "audio", "midi");
+    }
+
+    #[test]
+    fn test_sniff_wave() {
+        test_sniff_classification_sup("test.wav", "audio", "wave");
+    }
+
+    #[test]
+    fn test_sniff_ogg() {
+        test_sniff_classification("small.ogg", "application", "ogg", None);
+        test_sniff_classification("small.ogg", "application", "ogg", Some(("audio", "")));
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_sniff_vsn_ms_fontobject() {
+        test_sniff_classification_sup("vnd.ms-fontobject", "application", "vnd.ms-fontobject");
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_sniff_true_type() {
+        test_sniff_full(&Path::new("unknown/true_type.ttf"), "(TrueType)", "", None);
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_sniff_open_type() {
+        test_sniff_full(&Path::new("unknown/open_type"), "(OpenType)", "", None);
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_sniff_true_type_collection() {
+        test_sniff_full(&Path::new("unknown/true_type_collection.ttc"), "(TrueType Collection)", "", None);
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_sniff_woff() {
+        test_sniff_classification_sup("test.wof", "application", "font-woff");
+    }
+
+    #[test]
+    fn test_sniff_gzip() {
+        test_sniff_classification("test.gz", "application", "x-gzip", None);
+    }
+
+    #[test]
+    fn test_sniff_zip() {
+        test_sniff_classification("test.zip", "application", "zip", None);
+    }
+
+    #[test]
+    fn test_sniff_rar() {
+        test_sniff_classification("test.rar", "application", "x-rar-compressed", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_doctype_20() {
+        test_sniff_classification("text_html_doctype_20.html", "text", "html", None);
+        test_sniff_classification("text_html_doctype_20_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_doctype_3e() {
+        test_sniff_classification("text_html_doctype_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_doctype_3e_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_page_20() {
+        test_sniff_classification("text_html_page_20.html", "text", "html", None);
+        test_sniff_classification("text_html_page_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_page_3e() {
+        test_sniff_classification("text_html_page_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_page_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_head_20() {
+        test_sniff_classification("text_html_head_20.html", "text", "html", None);
+        test_sniff_classification("text_html_head_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_head_3e() {
+        test_sniff_classification("text_html_head_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_head_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_script_20() {
+        test_sniff_classification("text_html_script_20.html", "text", "html", None);
+        test_sniff_classification("text_html_script_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_script_3e() {
+        test_sniff_classification("text_html_script_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_script_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_iframe_20() {
+        test_sniff_classification("text_html_iframe_20.html", "text", "html", None);
+        test_sniff_classification("text_html_iframe_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_iframe_3e() {
+        test_sniff_classification("text_html_iframe_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_iframe_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_h1_20() {
+        test_sniff_classification("text_html_h1_20.html", "text", "html", None);
+        test_sniff_classification("text_html_h1_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_h1_3e() {
+        test_sniff_classification("text_html_h1_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_h1_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_div_20() {
+        test_sniff_classification("text_html_div_20.html", "text", "html", None);
+        test_sniff_classification("text_html_div_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_div_3e() {
+        test_sniff_classification("text_html_div_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_div_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_font_20() {
+        test_sniff_classification("text_html_font_20.html", "text", "html", None);
+        test_sniff_classification("text_html_font_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_font_3e() {
+        test_sniff_classification("text_html_font_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_font_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_table_20() {
+        test_sniff_classification("text_html_table_20.html", "text", "html", None);
+        test_sniff_classification("text_html_table_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_table_3e() {
+        test_sniff_classification("text_html_table_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_table_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_a_20() {
+        test_sniff_classification("text_html_a_20.html", "text", "html", None);
+        test_sniff_classification("text_html_a_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_a_3e() {
+        test_sniff_classification("text_html_a_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_a_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_style_20() {
+        test_sniff_classification("text_html_style_20.html", "text", "html", None);
+        test_sniff_classification("text_html_style_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_style_3e() {
+        test_sniff_classification("text_html_style_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_style_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_title_20() {
+        test_sniff_classification("text_html_title_20.html", "text", "html", None);
+        test_sniff_classification("text_html_title_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_title_3e() {
+        test_sniff_classification("text_html_title_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_title_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_b_20() {
+        test_sniff_classification("text_html_b_20.html", "text", "html", None);
+        test_sniff_classification("text_html_b_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_b_3e() {
+        test_sniff_classification("text_html_b_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_b_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_body_20() {
+        test_sniff_classification("text_html_body_20.html", "text", "html", None);
+        test_sniff_classification("text_html_body_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_body_3e() {
+        test_sniff_classification("text_html_body_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_body_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_br_20() {
+        test_sniff_classification("text_html_br_20.html", "text", "html", None);
+        test_sniff_classification("text_html_br_20_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_br_3e() {
+        test_sniff_classification("text_html_br_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_br_3e_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_p_20() {
+        test_sniff_classification("text_html_p_20.html", "text", "html", None);
+        test_sniff_classification("text_html_p_20_u.html", "text", "html", None);
+    }
+    #[test]
+    fn test_sniff_text_html_p_3e() {
+        test_sniff_classification("text_html_p_3e.html", "text", "html", None);
+        test_sniff_classification("text_html_p_3e_u.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_comment_20() {
+        test_sniff_classification("text_html_comment_20.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_text_html_comment_3e() {
+        test_sniff_classification("text_html_comment_3e.html", "text", "html", None);
+    }
+
+    #[test]
+    fn test_sniff_xml() {
+        test_sniff_classification("test.xml", "text", "xml", None);
+    }
+
+    #[test]
+    fn test_sniff_pdf() {
+        test_sniff_classification("test.pdf", "application", "pdf", None);
+    }
+
+    #[test]
+    fn test_sniff_postscript() {
+        test_sniff_classification("test.ps", "application", "postscript", None);
+    }
+
+    #[test]
+    fn test_sniff_utf_16be_bom() {
+        test_sniff_classification("utf16bebom.txt", "text", "plain", None);
+    }
+
+    #[test]
+    fn test_sniff_utf_16le_bom() {
+        test_sniff_classification("utf16lebom.txt", "text", "plain", None);
+    }
+
+    #[test]
+    fn test_sniff_utf_8_bom() {
+        test_sniff_classification("utf8bom.txt", "text", "plain", None);
+    }
+
+    #[test]
+    fn test_sniff_rss_feed() {
+        test_sniff_full(&Path::new("text/xml/feed.rss"), "application", "rss+xml", Some(("text", "html")));
+    }
+
+    #[test]
+    fn test_sniff_atom_feed() {
+        test_sniff_full(&Path::new("text/xml/feed.atom"), "application", "atom+xml", Some(("text", "html")));
+    }
+}
diff --git a/components/net/resource_task.rs b/components/net/resource_task.rs
index 2865a03f657..a63cf83a7af 100644
--- a/components/net/resource_task.rs
+++ b/components/net/resource_task.rs
@@ -8,14 +8,14 @@ use about_loader;
 use data_loader;
 use file_loader;
 use http_loader;
-use sniffer_task;
-use sniffer_task::SnifferTask;
 use cookie_storage::CookieStorage;
 use cookie;
+use mime_classifier::MIMEClassifier;
 
 use net_traits::{ControlMsg, LoadData, LoadResponse};
 use net_traits::{Metadata, ProgressMsg, ResourceTask};
 use net_traits::ProgressMsg::Done;
+use util::opts;
 use util::task::spawn_named;
 
 use hyper::header::UserAgent;
@@ -29,6 +29,7 @@ use std::collections::HashMap;
 use std::env;
 use std::fs::File;
 use std::io::{BufReader, Read};
+use std::sync::Arc;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::thunk::Invoke;
 
@@ -58,32 +59,41 @@ pub fn global_init() {
     }
 }
 
-/// A LoadResponse directed at a particular consumer
-pub struct TargetedLoadResponse {
-    pub load_response: LoadResponse,
-    pub consumer: Sender<LoadResponse>,
+/// For use by loaders in responding to a Load message.
+pub fn start_sending(start_chan: Sender<LoadResponse>, metadata: Metadata) -> Sender<ProgressMsg> {
+    start_sending_opt(start_chan, metadata).ok().unwrap()
 }
 
-// Data structure containing ports
-pub struct ResponseSenders {
-    pub immediate_consumer: Sender<TargetedLoadResponse>,
-    pub eventual_consumer: Sender<LoadResponse>,
+/// For use by loaders in responding to a Load message that allows content sniffing.
+pub fn start_sending_sniffed(start_chan: Sender<LoadResponse>, metadata: Metadata,
+                             classifier: Arc<MIMEClassifier>, partial_body: &Vec<u8>)
+                             -> Sender<ProgressMsg> {
+    start_sending_sniffed_opt(start_chan, metadata, classifier, partial_body).ok().unwrap()
+}
+
+/// For use by loaders in responding to a Load message that allows content sniffing.
+pub fn start_sending_sniffed_opt(start_chan: Sender<LoadResponse>, mut metadata: Metadata,
+                                 classifier: Arc<MIMEClassifier>, partial_body: &Vec<u8>)
+                                 -> Result<Sender<ProgressMsg>, ()> {
+    if opts::get().sniff_mime_types {
+        // TODO: should be calculated in the resource loader, from pull requeset #4094
+        let nosniff = false;
+        let check_for_apache_bug = false;
+
+        metadata.content_type = classifier.classify(nosniff, check_for_apache_bug,
+                                                    &metadata.content_type, &partial_body);
+
+    }
+
+    start_sending_opt(start_chan, metadata)
 }
 
 /// For use by loaders in responding to a Load message.
-pub fn start_sending(senders: ResponseSenders, metadata: Metadata) -> Sender<ProgressMsg> {
-    start_sending_opt(senders, metadata).ok().unwrap()
-}
-
-/// For use by loaders in responding to a Load message.
-pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result<Sender<ProgressMsg>, ()> {
+pub fn start_sending_opt(start_chan: Sender<LoadResponse>, metadata: Metadata) -> Result<Sender<ProgressMsg>, ()> {
     let (progress_chan, progress_port) = channel();
-    let result = senders.immediate_consumer.send(TargetedLoadResponse {
-        load_response: LoadResponse {
-            metadata:      metadata,
-            progress_port: progress_port,
-        },
-        consumer: senders.eventual_consumer
+    let result = start_chan.send(LoadResponse {
+        metadata:      metadata,
+        progress_port: progress_port,
     });
     match result {
         Ok(_) => Ok(progress_chan),
@@ -94,10 +104,9 @@ pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result
 /// Create a ResourceTask
 pub fn new_resource_task(user_agent: Option<String>) -> ResourceTask {
     let (setup_chan, setup_port) = channel();
-    let sniffer_task = sniffer_task::new_sniffer_task();
     let setup_chan_clone = setup_chan.clone();
     spawn_named("ResourceManager".to_owned(), move || {
-        ResourceManager::new(setup_port, user_agent, sniffer_task, setup_chan_clone).start();
+        ResourceManager::new(setup_port, user_agent, setup_chan_clone).start();
     });
     setup_chan
 }
@@ -139,20 +148,20 @@ pub fn replace_hosts(mut load_data: LoadData, host_table: *mut HashMap<String, S
 struct ResourceManager {
     from_client: Receiver<ControlMsg>,
     user_agent: Option<String>,
-    sniffer_task: SnifferTask,
     cookie_storage: CookieStorage,
     resource_task: Sender<ControlMsg>,
+    mime_classifier: Arc<MIMEClassifier>,
 }
 
 impl ResourceManager {
-    fn new(from_client: Receiver<ControlMsg>, user_agent: Option<String>, sniffer_task: SnifferTask,
+    fn new(from_client: Receiver<ControlMsg>, user_agent: Option<String>,
            resource_task: Sender<ControlMsg>) -> ResourceManager {
         ResourceManager {
             from_client: from_client,
             user_agent: user_agent,
-            sniffer_task: sniffer_task,
             cookie_storage: CookieStorage::new(),
             resource_task: resource_task,
+            mime_classifier: Arc::new(MIMEClassifier::new()),
         }
     }
 }
@@ -193,15 +202,11 @@ impl ResourceManager {
         }
 
         self.user_agent.as_ref().map(|ua| load_data.headers.set(UserAgent(ua.clone())));
-        let senders = ResponseSenders {
-            immediate_consumer: self.sniffer_task.clone(),
-            eventual_consumer: load_data.consumer.clone(),
-        };
 
-        fn from_factory(factory: fn(LoadData, Sender<TargetedLoadResponse>))
-                        -> Box<Invoke<(LoadData, Sender<TargetedLoadResponse>)> + Send> {
-            box move |(load_data, start_chan)| {
-                factory(load_data, start_chan)
+        fn from_factory(factory: fn(LoadData, Arc<MIMEClassifier>))
+                        -> Box<Invoke<(LoadData, Arc<MIMEClassifier>)> + Send> {
+            box move |(load_data, classifier)| {
+                factory(load_data, classifier)
             }
         }
 
@@ -212,14 +217,14 @@ impl ResourceManager {
             "about" => from_factory(about_loader::factory),
             _ => {
                 debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
-                start_sending(senders, Metadata::default(load_data.url))
+                start_sending(load_data.consumer, Metadata::default(load_data.url))
                     .send(ProgressMsg::Done(Err("no loader for scheme".to_string()))).unwrap();
                 return
             }
         };
         debug!("resource_task: loading url: {}", load_data.url.serialize());
 
-        loader.invoke((load_data, self.sniffer_task.clone()));
+        loader.invoke((load_data, self.mime_classifier.clone()));
     }
 }
 
diff --git a/components/net/sniffer_task.rs b/components/net/sniffer_task.rs
deleted file mode 100644
index f3ec4c988ea..00000000000
--- a/components/net/sniffer_task.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * 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/. */
-
-//! A task that sniffs data
-use std::sync::mpsc::{channel, Receiver, Sender};
-use std::thread::Builder;
-use resource_task::{TargetedLoadResponse};
-
-pub type SnifferTask = Sender<TargetedLoadResponse>;
-
-pub fn new_sniffer_task() -> SnifferTask {
-    let(sen, rec) = channel();
-    let builder = Builder::new().name("SnifferManager".to_string());
-    builder.spawn(move || {
-        SnifferManager::new(rec).start();
-    }).unwrap();
-    sen
-}
-
-struct SnifferManager {
-    data_receiver: Receiver<TargetedLoadResponse>,
-}
-
-impl SnifferManager {
-    fn new(data_receiver: Receiver <TargetedLoadResponse>) -> SnifferManager {
-        SnifferManager {
-            data_receiver: data_receiver,
-        }
-    }
-}
-
-impl SnifferManager {
-    fn start(self) {
-        loop {
-            match self.data_receiver.recv() {
-                Ok(snif_data) => {
-                    let _ = snif_data.consumer.send(snif_data.load_response);
-                }
-                Err(_) => break,
-            }
-        }
-    }
-}
diff --git a/components/util/opts.rs b/components/util/opts.rs
index 41245e3c7cb..43390a69ecc 100644
--- a/components/util/opts.rs
+++ b/components/util/opts.rs
@@ -132,6 +132,9 @@ pub struct Opts {
 
     /// A specific path to find required resources (such as user-agent.css).
     pub resources_path: Option<String>,
+
+    /// Whether MIME sniffing should be used
+    pub sniff_mime_types: bool,
 }
 
 fn print_usage(app: &str, opts: &[getopts::OptGroup]) {
@@ -212,6 +215,7 @@ pub fn default_opts() -> Opts {
         validate_display_list_geometry: false,
         profile_tasks: false,
         resources_path: None,
+        sniff_mime_types: false,
     }
 }
 
@@ -244,6 +248,7 @@ pub fn from_cmdline_args(args: &[String]) -> bool {
         getopts::optflag("h", "help", "Print this message"),
         getopts::optopt("r", "render-api", "Set the rendering API to use", "gl|mesa"),
         getopts::optopt("", "resources-path", "Path to find static resources", "/home/servo/resources"),
+        getopts::optflag("", "sniff-mime-types" , "Enable MIME sniffing"),
     );
 
     let opt_match = match getopts::getopts(args, opts.as_slice()) {
@@ -371,6 +376,7 @@ pub fn from_cmdline_args(args: &[String]) -> bool {
         relayout_event: debug_options.contains(&"relayout-event"),
         validate_display_list_geometry: debug_options.contains(&"validate-display-list-geometry"),
         resources_path: opt_match.opt_str("resources-path"),
+        sniff_mime_types: opt_match.opt_present("sniff-mime-types"),
     };
 
     set_opts(opts);
diff --git a/tests/content/parsable_mime/application/font-woff/test.wof b/tests/content/parsable_mime/application/font-woff/test.wof
new file mode 100755
index 00000000000..a1393ebee1d
--- /dev/null
+++ b/tests/content/parsable_mime/application/font-woff/test.wof
@@ -0,0 +1 @@
+wOFF
\ No newline at end of file
diff --git a/tests/content/parsable_mime/application/ogg/small.ogg b/tests/content/parsable_mime/application/ogg/small.ogg
new file mode 100644
index 00000000000..0d7f43eb795
Binary files /dev/null and b/tests/content/parsable_mime/application/ogg/small.ogg differ
diff --git a/tests/content/parsable_mime/application/pdf/test.pdf b/tests/content/parsable_mime/application/pdf/test.pdf
new file mode 100644
index 00000000000..e7c6e62775f
--- /dev/null
+++ b/tests/content/parsable_mime/application/pdf/test.pdf
@@ -0,0 +1,157 @@
+%PDF-1.2 
+%����
+ 
+9 0 obj
+<<
+/Length 10 0 R
+/Filter /FlateDecode 
+>>
+stream
+H�͐�J�0�� ��{��f�$M��n�-���[&je���ۤ�~�$���}�Ʌ�Ij���s����~�X�-],��$Y���)�'N�u�1!���V�?��?
+�b1Rbb�҉�H�[��TD:#�&ح��X���i�$qnf�����]������a��{��أ���q|J�Ls]�Q�I��j�%��9��`�঺��U�ite�z�$����OeB�Ēү�R��@zܗ���g���<���
+endstream
+endobj
+10 0 obj
+246
+endobj
+4 0 obj
+<<
+/Type /Page
+/Parent 5 0 R
+/Resources <<
+/Font <<
+/F0 6 0 R 
+/F1 7 0 R 
+>>
+/ProcSet 2 0 R
+>>
+/Contents 9 0 R
+>>
+endobj
+6 0 obj
+<<
+/Type /Font
+/Subtype /TrueType
+/Name /F0
+/BaseFont /Arial
+/Encoding /WinAnsiEncoding
+>>
+endobj
+7 0 obj
+<<
+/Type /Font
+/Subtype /TrueType
+/Name /F1
+/BaseFont /BookAntiqua,Bold
+/FirstChar 31
+/LastChar 255
+/Widths [ 750 250 278 402 606 500 889 833 227 333 333 444 606 250 333 250 
+296 500 500 500 500 500 500 500 500 500 500 250 250 606 606 606 
+444 747 778 667 722 833 611 556 833 833 389 389 778 611 1000 833 
+833 611 833 722 611 667 778 778 1000 667 667 667 333 606 333 606 
+500 333 500 611 444 611 500 389 556 611 333 333 611 333 889 611 
+556 611 611 389 444 333 611 556 833 500 556 500 310 606 310 606 
+750 500 750 333 500 500 1000 500 500 333 1000 611 389 1000 750 750 
+750 750 278 278 500 500 606 500 1000 333 998 444 389 833 750 750 
+667 250 278 500 500 606 500 606 500 333 747 438 500 606 333 747 
+500 400 549 361 361 333 576 641 250 333 361 488 500 889 890 889 
+444 778 778 778 778 778 778 1000 722 611 611 611 611 389 389 389 
+389 833 833 833 833 833 833 833 606 833 778 778 778 778 667 611 
+611 500 500 500 500 500 500 778 444 500 500 500 500 333 333 333 
+333 556 611 556 556 556 556 556 549 556 611 611 611 611 556 611 
+556 ]
+/Encoding /WinAnsiEncoding
+/FontDescriptor 8 0 R
+>>
+endobj
+8 0 obj
+<<
+/Type /FontDescriptor
+/FontName /BookAntiqua,Bold
+/Flags 16418
+/FontBBox [ -250 -260 1236 930 ]
+/MissingWidth 750
+/StemV 146
+/StemH 146
+/ItalicAngle 0
+/CapHeight 930
+/XHeight 651
+/Ascent 930
+/Descent 260
+/Leading 210
+/MaxWidth 1030
+/AvgWidth 460
+>>
+endobj
+2 0 obj
+[ /PDF /Text  ]
+endobj
+5 0 obj
+<<
+/Kids [4 0 R ]
+/Count 1
+/Type /Pages
+/MediaBox [ 0 0 612 792 ]
+>>
+endobj
+1 0 obj
+<<
+/Creator (1725.fm)
+/CreationDate (1-Jan-3 18:15PM)
+/Title (1725.PDF)
+/Author (Unknown)
+/Producer (Acrobat PDFWriter 3.02 for Windows)
+/Keywords ()
+/Subject ()
+>>
+endobj
+3 0 obj
+<<
+/Pages 5 0 R
+/Type /Catalog
+/DefaultGray 11 0 R
+/DefaultRGB  12 0 R
+>>
+endobj
+11 0 obj
+[/CalGray
+<<
+/WhitePoint [0.9505 1 1.0891 ]
+/Gamma 0.2468 
+>>
+]
+endobj
+12 0 obj
+[/CalRGB
+<<
+/WhitePoint [0.9505 1 1.0891 ]
+/Gamma [0.2468 0.2468 0.2468 ]
+/Matrix [0.4361 0.2225 0.0139 0.3851 0.7169 0.0971 0.1431 0.0606 0.7141 ]
+>>
+]
+endobj
+xref
+0 13
+0000000000 65535 f
+0000002172 00000 n
+0000002046 00000 n
+0000002363 00000 n
+0000000375 00000 n
+0000002080 00000 n
+0000000518 00000 n
+0000000633 00000 n
+0000001760 00000 n
+0000000021 00000 n
+0000000352 00000 n
+0000002460 00000 n
+0000002548 00000 n
+trailer
+<<
+/Size 13
+/Root 3 0 R
+/Info 1 0 R
+/ID [<47149510433dd4882f05f8c124223734><47149510433dd4882f05f8c124223734>]
+>>
+startxref
+2726
+%%EOF
diff --git a/tests/content/parsable_mime/application/postscript/test.ps b/tests/content/parsable_mime/application/postscript/test.ps
new file mode 100755
index 00000000000..c273ffa3f0f
--- /dev/null
+++ b/tests/content/parsable_mime/application/postscript/test.ps
@@ -0,0 +1 @@
+%!PS-Adobe-
\ No newline at end of file
diff --git a/tests/content/parsable_mime/application/vnd.ms-fontobject/vnd.ms-fontobject b/tests/content/parsable_mime/application/vnd.ms-fontobject/vnd.ms-fontobject
new file mode 100755
index 00000000000..1b84f4c37c1
Binary files /dev/null and b/tests/content/parsable_mime/application/vnd.ms-fontobject/vnd.ms-fontobject differ
diff --git a/tests/content/parsable_mime/application/x-gzip/test.gz b/tests/content/parsable_mime/application/x-gzip/test.gz
new file mode 100644
index 00000000000..3b99b73e6f0
Binary files /dev/null and b/tests/content/parsable_mime/application/x-gzip/test.gz differ
diff --git a/tests/content/parsable_mime/application/x-rar-compressed/test.rar b/tests/content/parsable_mime/application/x-rar-compressed/test.rar
new file mode 100755
index 00000000000..920bd4d8a8c
Binary files /dev/null and b/tests/content/parsable_mime/application/x-rar-compressed/test.rar differ
diff --git a/tests/content/parsable_mime/application/zip/test.zip b/tests/content/parsable_mime/application/zip/test.zip
new file mode 100755
index 00000000000..5c74c9658c6
--- /dev/null
+++ b/tests/content/parsable_mime/application/zip/test.zip
@@ -0,0 +1 @@
+PK
\ No newline at end of file
diff --git a/tests/content/parsable_mime/audio/aiff/test.aif b/tests/content/parsable_mime/audio/aiff/test.aif
new file mode 100644
index 00000000000..ad2e35df40b
Binary files /dev/null and b/tests/content/parsable_mime/audio/aiff/test.aif differ
diff --git a/tests/content/parsable_mime/audio/basic/test.au b/tests/content/parsable_mime/audio/basic/test.au
new file mode 100644
index 00000000000..d4e53deb74a
Binary files /dev/null and b/tests/content/parsable_mime/audio/basic/test.au differ
diff --git a/tests/content/parsable_mime/audio/midi/test.mid b/tests/content/parsable_mime/audio/midi/test.mid
new file mode 100644
index 00000000000..a52838c62bc
Binary files /dev/null and b/tests/content/parsable_mime/audio/midi/test.mid differ
diff --git a/tests/content/parsable_mime/audio/mpeg/test.mp3 b/tests/content/parsable_mime/audio/mpeg/test.mp3
new file mode 100644
index 00000000000..50786790311
Binary files /dev/null and b/tests/content/parsable_mime/audio/mpeg/test.mp3 differ
diff --git a/tests/content/parsable_mime/audio/wave/test.wav b/tests/content/parsable_mime/audio/wave/test.wav
new file mode 100644
index 00000000000..f96276c063c
Binary files /dev/null and b/tests/content/parsable_mime/audio/wave/test.wav differ
diff --git a/tests/content/parsable_mime/image/bmp/test.bmp b/tests/content/parsable_mime/image/bmp/test.bmp
new file mode 100644
index 00000000000..8a1b10bae5e
Binary files /dev/null and b/tests/content/parsable_mime/image/bmp/test.bmp differ
diff --git a/tests/content/parsable_mime/image/gif/test87a b/tests/content/parsable_mime/image/gif/test87a
new file mode 100644
index 00000000000..8d49c776420
Binary files /dev/null and b/tests/content/parsable_mime/image/gif/test87a differ
diff --git a/tests/content/parsable_mime/image/gif/test89a.gif b/tests/content/parsable_mime/image/gif/test89a.gif
new file mode 100644
index 00000000000..0e2995e0821
Binary files /dev/null and b/tests/content/parsable_mime/image/gif/test89a.gif differ
diff --git a/tests/content/parsable_mime/image/jpeg/test.jpg b/tests/content/parsable_mime/image/jpeg/test.jpg
new file mode 100644
index 00000000000..7f758f65d13
Binary files /dev/null and b/tests/content/parsable_mime/image/jpeg/test.jpg differ
diff --git a/tests/content/parsable_mime/image/png/test.png b/tests/content/parsable_mime/image/png/test.png
new file mode 100644
index 00000000000..cc81374d4f5
Binary files /dev/null and b/tests/content/parsable_mime/image/png/test.png differ
diff --git a/tests/content/parsable_mime/image/webp/test.webp b/tests/content/parsable_mime/image/webp/test.webp
new file mode 100755
index 00000000000..5a907eb4ce2
Binary files /dev/null and b/tests/content/parsable_mime/image/webp/test.webp differ
diff --git a/tests/content/parsable_mime/image/x-icon/test.ico b/tests/content/parsable_mime/image/x-icon/test.ico
new file mode 100644
index 00000000000..a2d0ee49098
Binary files /dev/null and b/tests/content/parsable_mime/image/x-icon/test.ico differ
diff --git a/tests/content/parsable_mime/image/x-icon/test_cursor.ico b/tests/content/parsable_mime/image/x-icon/test_cursor.ico
new file mode 100644
index 00000000000..6029d6684d5
Binary files /dev/null and b/tests/content/parsable_mime/image/x-icon/test_cursor.ico differ
diff --git a/tests/content/parsable_mime/text/html/text_html_a_20.html b/tests/content/parsable_mime/text/html/text_html_a_20.html
new file mode 100644
index 00000000000..1b9619279a7
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_a_20.html
@@ -0,0 +1,3 @@
+
+
+  <A 
diff --git a/tests/content/parsable_mime/text/html/text_html_a_20_u.html b/tests/content/parsable_mime/text/html/text_html_a_20_u.html
new file mode 100644
index 00000000000..887a1280650
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_a_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <a 
diff --git a/tests/content/parsable_mime/text/html/text_html_a_3e.html b/tests/content/parsable_mime/text/html/text_html_a_3e.html
new file mode 100644
index 00000000000..610cd08fea4
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_a_3e.html
@@ -0,0 +1,3 @@
+
+
+  <A>
diff --git a/tests/content/parsable_mime/text/html/text_html_a_3e_u.html b/tests/content/parsable_mime/text/html/text_html_a_3e_u.html
new file mode 100644
index 00000000000..48528fdf341
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_a_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <a>
diff --git a/tests/content/parsable_mime/text/html/text_html_b_20.html b/tests/content/parsable_mime/text/html/text_html_b_20.html
new file mode 100644
index 00000000000..5977d2eeaab
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_b_20.html
@@ -0,0 +1,3 @@
+
+
+  <B 
diff --git a/tests/content/parsable_mime/text/html/text_html_b_20_u.html b/tests/content/parsable_mime/text/html/text_html_b_20_u.html
new file mode 100644
index 00000000000..a8a963b95f0
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_b_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <b 
diff --git a/tests/content/parsable_mime/text/html/text_html_b_3e.html b/tests/content/parsable_mime/text/html/text_html_b_3e.html
new file mode 100644
index 00000000000..dc79cd5d568
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_b_3e.html
@@ -0,0 +1,3 @@
+
+
+  <B>
diff --git a/tests/content/parsable_mime/text/html/text_html_b_3e_u.html b/tests/content/parsable_mime/text/html/text_html_b_3e_u.html
new file mode 100644
index 00000000000..0d72d281aec
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_b_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <b>
diff --git a/tests/content/parsable_mime/text/html/text_html_body_20.html b/tests/content/parsable_mime/text/html/text_html_body_20.html
new file mode 100644
index 00000000000..c72b1ad3bec
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_body_20.html
@@ -0,0 +1,3 @@
+
+
+  <BODY 
diff --git a/tests/content/parsable_mime/text/html/text_html_body_20_u.html b/tests/content/parsable_mime/text/html/text_html_body_20_u.html
new file mode 100644
index 00000000000..1d76ebb0f47
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_body_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <body 
diff --git a/tests/content/parsable_mime/text/html/text_html_body_3e.html b/tests/content/parsable_mime/text/html/text_html_body_3e.html
new file mode 100644
index 00000000000..4a66f59ef95
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_body_3e.html
@@ -0,0 +1,3 @@
+
+
+  <BODY>
diff --git a/tests/content/parsable_mime/text/html/text_html_body_3e_u.html b/tests/content/parsable_mime/text/html/text_html_body_3e_u.html
new file mode 100644
index 00000000000..b431695f3ab
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_body_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <body>
diff --git a/tests/content/parsable_mime/text/html/text_html_br_20.html b/tests/content/parsable_mime/text/html/text_html_br_20.html
new file mode 100644
index 00000000000..d04df680012
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_br_20.html
@@ -0,0 +1,3 @@
+
+
+  <BR 
diff --git a/tests/content/parsable_mime/text/html/text_html_br_20_u.html b/tests/content/parsable_mime/text/html/text_html_br_20_u.html
new file mode 100644
index 00000000000..1c0f0ce13ba
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_br_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <br 
diff --git a/tests/content/parsable_mime/text/html/text_html_br_3e.html b/tests/content/parsable_mime/text/html/text_html_br_3e.html
new file mode 100644
index 00000000000..1d40ef06566
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_br_3e.html
@@ -0,0 +1,3 @@
+
+
+  <BR>
diff --git a/tests/content/parsable_mime/text/html/text_html_br_3e_u.html b/tests/content/parsable_mime/text/html/text_html_br_3e_u.html
new file mode 100644
index 00000000000..c4eae116f03
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_br_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <br>
diff --git a/tests/content/parsable_mime/text/html/text_html_comment_20.html b/tests/content/parsable_mime/text/html/text_html_comment_20.html
new file mode 100644
index 00000000000..e9612efc73c
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_comment_20.html
@@ -0,0 +1,3 @@
+
+
+  <!-- 
diff --git a/tests/content/parsable_mime/text/html/text_html_comment_20_u.html b/tests/content/parsable_mime/text/html/text_html_comment_20_u.html
new file mode 100644
index 00000000000..e9612efc73c
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_comment_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <!-- 
diff --git a/tests/content/parsable_mime/text/html/text_html_comment_3e.html b/tests/content/parsable_mime/text/html/text_html_comment_3e.html
new file mode 100644
index 00000000000..44a94ca5a7a
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_comment_3e.html
@@ -0,0 +1,3 @@
+
+
+  <!-->
diff --git a/tests/content/parsable_mime/text/html/text_html_comment_3e_u.html b/tests/content/parsable_mime/text/html/text_html_comment_3e_u.html
new file mode 100644
index 00000000000..44a94ca5a7a
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_comment_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <!-->
diff --git a/tests/content/parsable_mime/text/html/text_html_div_20.html b/tests/content/parsable_mime/text/html/text_html_div_20.html
new file mode 100644
index 00000000000..2ed34363b2f
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_div_20.html
@@ -0,0 +1,3 @@
+
+
+  <DIV 
diff --git a/tests/content/parsable_mime/text/html/text_html_div_20_u.html b/tests/content/parsable_mime/text/html/text_html_div_20_u.html
new file mode 100644
index 00000000000..b98886efd83
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_div_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <div 
diff --git a/tests/content/parsable_mime/text/html/text_html_div_3e.html b/tests/content/parsable_mime/text/html/text_html_div_3e.html
new file mode 100644
index 00000000000..ccf4ca8d70a
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_div_3e.html
@@ -0,0 +1,3 @@
+
+
+  <DIV>
diff --git a/tests/content/parsable_mime/text/html/text_html_div_3e_u.html b/tests/content/parsable_mime/text/html/text_html_div_3e_u.html
new file mode 100644
index 00000000000..c117f0f4cdd
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_div_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <div>
diff --git a/tests/content/parsable_mime/text/html/text_html_doctype_20.html b/tests/content/parsable_mime/text/html/text_html_doctype_20.html
new file mode 100644
index 00000000000..dbeb5a41c2a
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_doctype_20.html
@@ -0,0 +1,3 @@
+
+
+  <!DOCTYPE HTML 
diff --git a/tests/content/parsable_mime/text/html/text_html_doctype_20_u.html b/tests/content/parsable_mime/text/html/text_html_doctype_20_u.html
new file mode 100644
index 00000000000..acede44dffb
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_doctype_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <!doctype html 
diff --git a/tests/content/parsable_mime/text/html/text_html_doctype_3e.html b/tests/content/parsable_mime/text/html/text_html_doctype_3e.html
new file mode 100644
index 00000000000..6a22ea8b978
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_doctype_3e.html
@@ -0,0 +1,4 @@
+
+
+  <!DOCTYPE HTML>
+
diff --git a/tests/content/parsable_mime/text/html/text_html_doctype_3e_u.html b/tests/content/parsable_mime/text/html/text_html_doctype_3e_u.html
new file mode 100644
index 00000000000..8b16e40458e
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_doctype_3e_u.html
@@ -0,0 +1,4 @@
+
+
+  <!doctype html>
+
diff --git a/tests/content/parsable_mime/text/html/text_html_font_20.html b/tests/content/parsable_mime/text/html/text_html_font_20.html
new file mode 100644
index 00000000000..a18fa850617
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_font_20.html
@@ -0,0 +1,3 @@
+
+
+  <FONT 
diff --git a/tests/content/parsable_mime/text/html/text_html_font_20_u.html b/tests/content/parsable_mime/text/html/text_html_font_20_u.html
new file mode 100644
index 00000000000..6a31d2a8aba
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_font_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <font 
diff --git a/tests/content/parsable_mime/text/html/text_html_font_3e.html b/tests/content/parsable_mime/text/html/text_html_font_3e.html
new file mode 100644
index 00000000000..3605840fc5a
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_font_3e.html
@@ -0,0 +1,3 @@
+
+
+  <FONT>
diff --git a/tests/content/parsable_mime/text/html/text_html_font_3e_u.html b/tests/content/parsable_mime/text/html/text_html_font_3e_u.html
new file mode 100644
index 00000000000..1181517947b
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_font_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <font>
diff --git a/tests/content/parsable_mime/text/html/text_html_h1_20.html b/tests/content/parsable_mime/text/html/text_html_h1_20.html
new file mode 100644
index 00000000000..3ed0eb125ff
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_h1_20.html
@@ -0,0 +1,3 @@
+
+
+  <H1 
diff --git a/tests/content/parsable_mime/text/html/text_html_h1_20_u.html b/tests/content/parsable_mime/text/html/text_html_h1_20_u.html
new file mode 100644
index 00000000000..f517b61487e
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_h1_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <h1 
diff --git a/tests/content/parsable_mime/text/html/text_html_h1_3e.html b/tests/content/parsable_mime/text/html/text_html_h1_3e.html
new file mode 100644
index 00000000000..af0bf8c56b9
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_h1_3e.html
@@ -0,0 +1,3 @@
+
+
+  <H1>
diff --git a/tests/content/parsable_mime/text/html/text_html_h1_3e_u.html b/tests/content/parsable_mime/text/html/text_html_h1_3e_u.html
new file mode 100644
index 00000000000..bae85229fcf
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_h1_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <h1>
diff --git a/tests/content/parsable_mime/text/html/text_html_head_20.html b/tests/content/parsable_mime/text/html/text_html_head_20.html
new file mode 100644
index 00000000000..eb322c946e0
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_head_20.html
@@ -0,0 +1,3 @@
+
+
+  <HEAD 
diff --git a/tests/content/parsable_mime/text/html/text_html_head_20_u.html b/tests/content/parsable_mime/text/html/text_html_head_20_u.html
new file mode 100644
index 00000000000..899655a5a2c
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_head_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <head 
diff --git a/tests/content/parsable_mime/text/html/text_html_head_3e.html b/tests/content/parsable_mime/text/html/text_html_head_3e.html
new file mode 100644
index 00000000000..058c7dce4a9
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_head_3e.html
@@ -0,0 +1,3 @@
+
+
+  <HEAD>
diff --git a/tests/content/parsable_mime/text/html/text_html_head_3e_u.html b/tests/content/parsable_mime/text/html/text_html_head_3e_u.html
new file mode 100644
index 00000000000..8a33d623daa
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_head_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <head>
diff --git a/tests/content/parsable_mime/text/html/text_html_iframe_20.html b/tests/content/parsable_mime/text/html/text_html_iframe_20.html
new file mode 100644
index 00000000000..e632915590a
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_iframe_20.html
@@ -0,0 +1,3 @@
+
+
+  <IFRAME 
diff --git a/tests/content/parsable_mime/text/html/text_html_iframe_20_u.html b/tests/content/parsable_mime/text/html/text_html_iframe_20_u.html
new file mode 100644
index 00000000000..527a06e415c
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_iframe_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <iframe 
diff --git a/tests/content/parsable_mime/text/html/text_html_iframe_3e.html b/tests/content/parsable_mime/text/html/text_html_iframe_3e.html
new file mode 100644
index 00000000000..9db0efd47d4
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_iframe_3e.html
@@ -0,0 +1,3 @@
+
+
+  <IFRAME>
diff --git a/tests/content/parsable_mime/text/html/text_html_iframe_3e_u.html b/tests/content/parsable_mime/text/html/text_html_iframe_3e_u.html
new file mode 100644
index 00000000000..e3512c8a5c2
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_iframe_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <iframe>
diff --git a/tests/content/parsable_mime/text/html/text_html_p_20.html b/tests/content/parsable_mime/text/html/text_html_p_20.html
new file mode 100644
index 00000000000..a099441be2b
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_p_20.html
@@ -0,0 +1,3 @@
+
+
+  <P 
diff --git a/tests/content/parsable_mime/text/html/text_html_p_20_u.html b/tests/content/parsable_mime/text/html/text_html_p_20_u.html
new file mode 100644
index 00000000000..ff4befbde7b
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_p_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <p 
diff --git a/tests/content/parsable_mime/text/html/text_html_p_3e.html b/tests/content/parsable_mime/text/html/text_html_p_3e.html
new file mode 100644
index 00000000000..98db18913d0
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_p_3e.html
@@ -0,0 +1,3 @@
+
+
+  <P>
diff --git a/tests/content/parsable_mime/text/html/text_html_p_3e_u.html b/tests/content/parsable_mime/text/html/text_html_p_3e_u.html
new file mode 100644
index 00000000000..9d99a59ed08
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_p_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <p>
diff --git a/tests/content/parsable_mime/text/html/text_html_page_20.html b/tests/content/parsable_mime/text/html/text_html_page_20.html
new file mode 100644
index 00000000000..bb1c4572b25
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_page_20.html
@@ -0,0 +1,3 @@
+
+
+  <HTML 
diff --git a/tests/content/parsable_mime/text/html/text_html_page_20_u.html b/tests/content/parsable_mime/text/html/text_html_page_20_u.html
new file mode 100644
index 00000000000..b3300d9f4e4
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_page_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <html 
diff --git a/tests/content/parsable_mime/text/html/text_html_page_3e.html b/tests/content/parsable_mime/text/html/text_html_page_3e.html
new file mode 100644
index 00000000000..e6a49c51924
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_page_3e.html
@@ -0,0 +1,3 @@
+
+
+  <HTML>
diff --git a/tests/content/parsable_mime/text/html/text_html_page_3e_u.html b/tests/content/parsable_mime/text/html/text_html_page_3e_u.html
new file mode 100644
index 00000000000..2b8ee203d25
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_page_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <html>
diff --git a/tests/content/parsable_mime/text/html/text_html_script_20.html b/tests/content/parsable_mime/text/html/text_html_script_20.html
new file mode 100644
index 00000000000..620c629266c
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_script_20.html
@@ -0,0 +1,3 @@
+
+
+  <SCRIPT 
diff --git a/tests/content/parsable_mime/text/html/text_html_script_20_u.html b/tests/content/parsable_mime/text/html/text_html_script_20_u.html
new file mode 100644
index 00000000000..bd2c58e676c
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_script_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <script 
diff --git a/tests/content/parsable_mime/text/html/text_html_script_3e.html b/tests/content/parsable_mime/text/html/text_html_script_3e.html
new file mode 100644
index 00000000000..d59535f70cd
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_script_3e.html
@@ -0,0 +1,3 @@
+
+
+  <SCRIPT>
diff --git a/tests/content/parsable_mime/text/html/text_html_script_3e_u.html b/tests/content/parsable_mime/text/html/text_html_script_3e_u.html
new file mode 100644
index 00000000000..625c13820f4
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_script_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <script>
diff --git a/tests/content/parsable_mime/text/html/text_html_style_20.html b/tests/content/parsable_mime/text/html/text_html_style_20.html
new file mode 100644
index 00000000000..57bc2a1ecd7
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_style_20.html
@@ -0,0 +1,3 @@
+
+
+  <STYLE 
diff --git a/tests/content/parsable_mime/text/html/text_html_style_20_u.html b/tests/content/parsable_mime/text/html/text_html_style_20_u.html
new file mode 100644
index 00000000000..8163eca3c60
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_style_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <style 
diff --git a/tests/content/parsable_mime/text/html/text_html_style_3e.html b/tests/content/parsable_mime/text/html/text_html_style_3e.html
new file mode 100644
index 00000000000..229d5f951bd
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_style_3e.html
@@ -0,0 +1,3 @@
+
+
+  <STYLE>
diff --git a/tests/content/parsable_mime/text/html/text_html_style_3e_u.html b/tests/content/parsable_mime/text/html/text_html_style_3e_u.html
new file mode 100644
index 00000000000..12d686e4953
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_style_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <style>
diff --git a/tests/content/parsable_mime/text/html/text_html_table_20.html b/tests/content/parsable_mime/text/html/text_html_table_20.html
new file mode 100644
index 00000000000..27cccc6acd6
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_table_20.html
@@ -0,0 +1,3 @@
+
+
+  <TABLE 
diff --git a/tests/content/parsable_mime/text/html/text_html_table_20_u.html b/tests/content/parsable_mime/text/html/text_html_table_20_u.html
new file mode 100644
index 00000000000..556b46e7fc4
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_table_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <table 
diff --git a/tests/content/parsable_mime/text/html/text_html_table_3e.html b/tests/content/parsable_mime/text/html/text_html_table_3e.html
new file mode 100644
index 00000000000..351ee543af8
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_table_3e.html
@@ -0,0 +1,3 @@
+
+
+  <TABLE>
diff --git a/tests/content/parsable_mime/text/html/text_html_table_3e_u.html b/tests/content/parsable_mime/text/html/text_html_table_3e_u.html
new file mode 100644
index 00000000000..6259870bfcf
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_table_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <table>
diff --git a/tests/content/parsable_mime/text/html/text_html_title_20.html b/tests/content/parsable_mime/text/html/text_html_title_20.html
new file mode 100644
index 00000000000..f7d151658d9
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_title_20.html
@@ -0,0 +1,3 @@
+
+
+  <TITLE 
diff --git a/tests/content/parsable_mime/text/html/text_html_title_20_u.html b/tests/content/parsable_mime/text/html/text_html_title_20_u.html
new file mode 100644
index 00000000000..03a072d8ac0
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_title_20_u.html
@@ -0,0 +1,3 @@
+
+
+  <title 
diff --git a/tests/content/parsable_mime/text/html/text_html_title_3e.html b/tests/content/parsable_mime/text/html/text_html_title_3e.html
new file mode 100644
index 00000000000..fedf57b9e4f
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_title_3e.html
@@ -0,0 +1,3 @@
+
+
+  <TITLE>
diff --git a/tests/content/parsable_mime/text/html/text_html_title_3e_u.html b/tests/content/parsable_mime/text/html/text_html_title_3e_u.html
new file mode 100644
index 00000000000..5fbf8a75c47
--- /dev/null
+++ b/tests/content/parsable_mime/text/html/text_html_title_3e_u.html
@@ -0,0 +1,3 @@
+
+
+  <title>
diff --git a/tests/content/parsable_mime/text/plain/utf16bebom.txt b/tests/content/parsable_mime/text/plain/utf16bebom.txt
new file mode 100644
index 00000000000..9fb50d49fb8
Binary files /dev/null and b/tests/content/parsable_mime/text/plain/utf16bebom.txt differ
diff --git a/tests/content/parsable_mime/text/plain/utf16lebom.txt b/tests/content/parsable_mime/text/plain/utf16lebom.txt
new file mode 100644
index 00000000000..d79d81725ec
Binary files /dev/null and b/tests/content/parsable_mime/text/plain/utf16lebom.txt differ
diff --git a/tests/content/parsable_mime/text/plain/utf8bom.txt b/tests/content/parsable_mime/text/plain/utf8bom.txt
new file mode 100644
index 00000000000..56ad8a265ef
--- /dev/null
+++ b/tests/content/parsable_mime/text/plain/utf8bom.txt
@@ -0,0 +1 @@
+    test_file
diff --git a/tests/content/parsable_mime/text/xml/feed.atom b/tests/content/parsable_mime/text/xml/feed.atom
new file mode 100755
index 00000000000..893c3f27a8e
--- /dev/null
+++ b/tests/content/parsable_mime/text/xml/feed.atom
@@ -0,0 +1 @@
+<feed>
diff --git a/tests/content/parsable_mime/text/xml/feed.rss b/tests/content/parsable_mime/text/xml/feed.rss
new file mode 100644
index 00000000000..9dc94d32b51
--- /dev/null
+++ b/tests/content/parsable_mime/text/xml/feed.rss
@@ -0,0 +1,151 @@
+<?xml version="1.0" encoding="windows-1252"?>
+<rss version="2.0">
+  <channel>
+    <title>FeedForAll Sample Feed</title>
+    <description>RSS is a fascinating technology. The uses for RSS are expanding daily. Take a closer look at how various industries are using the benefits of RSS in their businesses.</description>
+    <link>http://www.feedforall.com/industry-solutions.htm</link>
+    <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+    <copyright>Copyright 2004 NotePage, Inc.</copyright>
+    <docs>http://blogs.law.harvard.edu/tech/rss</docs>
+    <language>en-us</language>
+    <lastBuildDate>Tue, 19 Oct 2004 13:39:14 -0400</lastBuildDate>
+    <managingEditor>marketing@feedforall.com</managingEditor>
+    <pubDate>Tue, 19 Oct 2004 13:38:55 -0400</pubDate>
+    <webMaster>webmaster@feedforall.com</webMaster>
+    <generator>FeedForAll Beta1 (0.0.1.8)</generator>
+    <image>
+      <url>http://www.feedforall.com/ffalogo48x48.gif</url>
+      <title>FeedForAll Sample Feed</title>
+      <link>http://www.feedforall.com/industry-solutions.htm</link>
+      <description>FeedForAll Sample Feed</description>
+      <width>48</width>
+      <height>48</height>
+    </image>
+    <item>
+      <title>RSS Solutions for Restaurants</title>
+      <description>&lt;b&gt;FeedForAll &lt;/b&gt;helps Restaurant&apos;s communicate with customers. Let your customers know the latest specials or events.&lt;br&gt;
+&lt;br&gt;
+RSS feed uses include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#FF0000&quot;&gt;Daily Specials &lt;br&gt;
+Entertainment &lt;br&gt;
+Calendar of Events &lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/restaurant.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:09:11 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Schools and Colleges</title>
+      <description>FeedForAll helps Educational Institutions communicate with students about school wide activities, events, and schedules.&lt;br&gt;
+&lt;br&gt;
+RSS feed uses include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#0000FF&quot;&gt;Homework Assignments &lt;br&gt;
+School Cancellations &lt;br&gt;
+Calendar of Events &lt;br&gt;
+Sports Scores &lt;br&gt;
+Clubs/Organization Meetings &lt;br&gt;
+Lunches Menus &lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/schools.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:09:09 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Computer Service Companies</title>
+      <description>FeedForAll helps Computer Service Companies communicate with clients about cyber security and related issues. &lt;br&gt;
+&lt;br&gt;
+Uses include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#0000FF&quot;&gt;Cyber Security Alerts &lt;br&gt;
+Specials&lt;br&gt;
+Job Postings &lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/computer-service.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:09:07 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Governments</title>
+      <description>FeedForAll helps Governments communicate with the general public about positions on various issues, and keep the community aware of changes in important legislative issues. &lt;b&gt;&lt;i&gt;&lt;br&gt;
+&lt;/b&gt;&lt;/i&gt;&lt;br&gt;
+RSS uses Include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#00FF00&quot;&gt;Legislative Calendar&lt;br&gt;
+Votes&lt;br&gt;
+Bulletins&lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/government.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:09:05 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Politicians</title>
+      <description>FeedForAll helps Politicians communicate with the general public about positions on various issues, and keep the community notified of their schedule. &lt;br&gt;
+&lt;br&gt;
+Uses Include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#FF0000&quot;&gt;Blogs&lt;br&gt;
+Speaking Engagements &lt;br&gt;
+Statements&lt;br&gt;
+ &lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/politics.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:09:03 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Meteorologists</title>
+      <description>FeedForAll helps Meteorologists communicate with the general public about storm warnings and weather alerts, in specific regions. Using RSS meteorologists are able to quickly disseminate urgent and life threatening weather warnings. &lt;br&gt;
+&lt;br&gt;
+Uses Include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#0000FF&quot;&gt;Weather Alerts&lt;br&gt;
+Plotting Storms&lt;br&gt;
+School Cancellations &lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/weather.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:09:01 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Realtors &amp; Real Estate Firms</title>
+      <description>FeedForAll helps Realtors and Real Estate companies communicate with clients informing them of newly available properties, and open house announcements. RSS helps to reach a targeted audience and spread the word in an inexpensive, professional manner. &lt;font color=&quot;#0000FF&quot;&gt;&lt;br&gt;
+&lt;/font&gt;&lt;br&gt;
+Feeds can be used for:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#FF0000&quot;&gt;Open House Dates&lt;br&gt;
+New Properties For Sale&lt;br&gt;
+Mortgage Rates&lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/real-estate.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:08:59 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Banks / Mortgage Companies</title>
+      <description>FeedForAll helps &lt;b&gt;Banks, Credit Unions and Mortgage companies&lt;/b&gt; communicate with the general public about rate changes in a prompt and professional manner. &lt;br&gt;
+&lt;br&gt;
+Uses include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#0000FF&quot;&gt;Mortgage Rates&lt;br&gt;
+Foreign Exchange Rates &lt;br&gt;
+Bank Rates&lt;br&gt;
+Specials&lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/banks.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:08:57 -0400</pubDate>
+    </item>
+    <item>
+      <title>RSS Solutions for Law Enforcement</title>
+      <description>&lt;b&gt;FeedForAll&lt;/b&gt; helps Law Enforcement Professionals communicate with the general public and other agencies in a prompt and efficient manner. Using RSS police are able to quickly disseminate urgent and life threatening information. &lt;br&gt;
+&lt;br&gt;
+Uses include:&lt;br&gt;
+&lt;i&gt;&lt;font color=&quot;#0000FF&quot;&gt;Amber Alerts&lt;br&gt;
+Sex Offender Community Notification &lt;br&gt;
+Weather Alerts &lt;br&gt;
+Scheduling &lt;br&gt;
+Security Alerts &lt;br&gt;
+Police Report &lt;br&gt;
+Meetings&lt;/i&gt;&lt;/font&gt;</description>
+      <link>http://www.feedforall.com/law-enforcement.htm</link>
+      <category domain="www.dmoz.com">Computers/Software/Internet/Site Management/Content Management</category>
+      <comments>http://www.feedforall.com/forum</comments>
+      <pubDate>Tue, 19 Oct 2004 11:08:56 -0400</pubDate>
+    </item>
+  </channel>
+</rss>
\ No newline at end of file
diff --git a/tests/content/parsable_mime/text/xml/test.xml b/tests/content/parsable_mime/text/xml/test.xml
new file mode 100644
index 00000000000..8fe8c0e91cf
--- /dev/null
+++ b/tests/content/parsable_mime/text/xml/test.xml
@@ -0,0 +1,6 @@
+      
+<?xml version="1.0" encoding="UTF-8"?>
+<foo>
+  <bar>
+  </bar>
+</foo>
diff --git a/tests/content/parsable_mime/unknown/open_type b/tests/content/parsable_mime/unknown/open_type
new file mode 100644
index 00000000000..9117b12600f
--- /dev/null
+++ b/tests/content/parsable_mime/unknown/open_type
@@ -0,0 +1 @@
+OTTO
\ No newline at end of file
diff --git a/tests/content/parsable_mime/unknown/true_type.ttf b/tests/content/parsable_mime/unknown/true_type.ttf
new file mode 100644
index 00000000000..c0142fea093
Binary files /dev/null and b/tests/content/parsable_mime/unknown/true_type.ttf differ
diff --git a/tests/content/parsable_mime/unknown/true_type_collection.ttc b/tests/content/parsable_mime/unknown/true_type_collection.ttc
new file mode 100644
index 00000000000..42d3cef1e6d
--- /dev/null
+++ b/tests/content/parsable_mime/unknown/true_type_collection.ttc
@@ -0,0 +1 @@
+ttcf
\ No newline at end of file
diff --git a/tests/content/parsable_mime/video/avi/test.avi b/tests/content/parsable_mime/video/avi/test.avi
new file mode 100644
index 00000000000..f6cd837a924
Binary files /dev/null and b/tests/content/parsable_mime/video/avi/test.avi differ
diff --git a/tests/content/parsable_mime/video/mp4/test.mp4 b/tests/content/parsable_mime/video/mp4/test.mp4
new file mode 100644
index 00000000000..1fc478842f5
Binary files /dev/null and b/tests/content/parsable_mime/video/mp4/test.mp4 differ
diff --git a/tests/content/parsable_mime/video/webm/test.webm b/tests/content/parsable_mime/video/webm/test.webm
new file mode 100644
index 00000000000..da946da5290
Binary files /dev/null and b/tests/content/parsable_mime/video/webm/test.webm differ
diff --git a/tests/wpt/metadata/XMLHttpRequest/send-conditional.htm.ini b/tests/wpt/metadata/XMLHttpRequest/send-conditional.htm.ini
deleted file mode 100644
index 98f1333fabb..00000000000
--- a/tests/wpt/metadata/XMLHttpRequest/send-conditional.htm.ini
+++ /dev/null
@@ -1,8 +0,0 @@
-[send-conditional.htm]
-  type: testharness
-  [XMLHttpRequest: send() - conditional requests (tag)]
-    expected: FAIL
-
-  [XMLHttpRequest: send() - conditional requests (date)]
-    expected: FAIL
-