Refactor FormData code to match updated spec

Use Atoms instead of Strings as keys

1 files changed, 53 insertions, 37 deletions

diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index 01fc4b140c6..f0cc080489c 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -5,32 +5,33 @@
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::FormDataBinding;
 use dom::bindings::codegen::Bindings::FormDataBinding::FormDataMethods;
-use dom::bindings::codegen::UnionTypes::FileOrString;
-use dom::bindings::codegen::UnionTypes::FileOrString::{eFile, eString};
+use dom::bindings::codegen::UnionTypes::BlobOrUSVString::{self, eBlob, eUSVString};
 use dom::bindings::error::{Fallible};
 use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::str::USVString;
 use dom::blob::Blob;
 use dom::file::File;
 use dom::htmlformelement::HTMLFormElement;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
+use string_cache::Atom;
 use util::str::DOMString;
 
 #[derive(JSTraceable, Clone)]
 #[must_root]
 #[derive(HeapSizeOf)]
 pub enum FormDatum {
-    StringData(DOMString),
-    FileData(JS<File>)
+    StringData(String),
+    BlobData(JS<Blob>)
 }
 
 #[dom_struct]
 pub struct FormData {
     reflector_: Reflector,
-    data: DOMRefCell<HashMap<DOMString, Vec<FormDatum>>>,
+    data: DOMRefCell<HashMap<Atom, Vec<FormDatum>>>,
     global: GlobalField,
     form: Option<JS<HTMLFormElement>>
 }
@@ -51,72 +52,87 @@ impl FormData {
     }
 
     pub fn Constructor(global: GlobalRef, form: Option<&HTMLFormElement>) -> Fallible<Root<FormData>> {
+        // TODO: Construct form data set for form if it is supplied
         Ok(FormData::new(form, global))
     }
 }
 
 impl FormDataMethods for FormData {
-    #[allow(unrooted_must_root)]
     // https://xhr.spec.whatwg.org/#dom-formdata-append
-    fn Append(&self, name: DOMString, value: &Blob, filename: Option<DOMString>) {
-        let file = FormDatum::FileData(JS::from_rooted(&self.get_file_from_blob(value, filename)));
+    fn Append(&self, name: USVString, value: USVString) {
         let mut data = self.data.borrow_mut();
-        match data.entry(name) {
-            Occupied(entry) => entry.into_mut().push(file),
-            Vacant(entry) => {
-                entry.insert(vec!(file));
-            }
+        match data.entry(Atom::from(&*name.0)) {
+            Occupied(entry) => entry.into_mut().push(FormDatum::StringData(value.0)),
+            Vacant  (entry) => { entry.insert(vec!(FormDatum::StringData(value.0))); }
         }
     }
 
+    #[allow(unrooted_must_root)]
     // https://xhr.spec.whatwg.org/#dom-formdata-append
-    fn Append_(&self, name: DOMString, value: DOMString) {
+    fn Append_(&self, name: USVString, value: &Blob, filename: Option<USVString>) {
+        let blob = FormDatum::BlobData(JS::from_rooted(&self.get_file_or_blob(value, filename)));
         let mut data = self.data.borrow_mut();
-        match data.entry(name) {
-            Occupied(entry) => entry.into_mut().push(FormDatum::StringData(value)),
-            Vacant  (entry) => { entry.insert(vec!(FormDatum::StringData(value))); },
+        match data.entry(Atom::from(&*name.0)) {
+            Occupied(entry) => entry.into_mut().push(blob),
+            Vacant(entry) => {
+                entry.insert(vec!(blob));
+            }
         }
     }
 
     // https://xhr.spec.whatwg.org/#dom-formdata-delete
-    fn Delete(&self, name: DOMString) {
-        self.data.borrow_mut().remove(&name);
+    fn Delete(&self, name: USVString) {
+        self.data.borrow_mut().remove(&Atom::from(&*name.0));
     }
 
     // https://xhr.spec.whatwg.org/#dom-formdata-get
-    fn Get(&self, name: DOMString) -> Option<FileOrString> {
+    fn Get(&self, name: USVString) -> Option<BlobOrUSVString> {
         self.data.borrow()
-                 .get(&name)
+                 .get(&Atom::from(&*name.0))
                  .map(|entry| match entry[0] {
-                     FormDatum::StringData(ref s) => eString(s.clone()),
-                     FormDatum::FileData(ref f) => eFile(Root::from_ref(&*f)),
+                     FormDatum::StringData(ref s) => eUSVString(USVString(s.clone())),
+                     FormDatum::BlobData(ref b) => eBlob(Root::from_ref(&*b)),
                  })
     }
 
-    // https://xhr.spec.whatwg.org/#dom-formdata-has
-    fn Has(&self, name: DOMString) -> bool {
-        self.data.borrow().contains_key(&name)
+    // https://xhr.spec.whatwg.org/#dom-formdata-getall
+    fn GetAll(&self, name: USVString) -> Vec<BlobOrUSVString> {
+        self.data.borrow()
+                 .get(&Atom::from(&*name.0))
+                 .map_or(vec![], |data|
+                    data.iter().map(|item| match *item {
+                        FormDatum::StringData(ref s) => eUSVString(USVString(s.clone())),
+                        FormDatum::BlobData(ref b) => eBlob(Root::from_ref(&*b)),
+                    }).collect()
+                 )
     }
 
-    // https://xhr.spec.whatwg.org/#dom-formdata-set
-    fn Set_(&self, name: DOMString, value: DOMString) {
-        self.data.borrow_mut().insert(name, vec!(FormDatum::StringData(value)));
+    // https://xhr.spec.whatwg.org/#dom-formdata-has
+    fn Has(&self, name: USVString) -> bool {
+        self.data.borrow().contains_key(&Atom::from(&*name.0))
     }
 
     #[allow(unrooted_must_root)]
     // https://xhr.spec.whatwg.org/#dom-formdata-set
-    fn Set(&self, name: DOMString, value: &Blob, filename: Option<DOMString>) {
-        let file = FormDatum::FileData(JS::from_rooted(&self.get_file_from_blob(value, filename)));
-        self.data.borrow_mut().insert(name, vec!(file));
+    fn Set(&self, name: USVString, value: BlobOrUSVString) {
+        let val = match value {
+            eUSVString(s) => FormDatum::StringData(s.0),
+            eBlob(b) => FormDatum::BlobData(JS::from_rooted(&b))
+        };
+        self.data.borrow_mut().insert(Atom::from(&*name.0), vec!(val));
     }
 }
 
 
 impl FormData {
-    fn get_file_from_blob(&self, value: &Blob, filename: Option<DOMString>) -> Root<File> {
-        let global = self.global.root();
-        let f = value.downcast::<File>();
-        let name = filename.unwrap_or(f.map(|inner| inner.name().clone()).unwrap_or(DOMString::from("blob")));
-        File::new(global.r(), value, name)
+    fn get_file_or_blob(&self, value: &Blob, filename: Option<USVString>) -> Root<Blob> {
+        match filename {
+            Some(fname) => {
+                let global = self.global.root();
+                let name = DOMString::from(fname.0);
+                Root::upcast(File::new(global.r(), value, name))
+            }
+            None => Root::from_ref(value)
+        }
     }
 }