diff --git a/components/script/dom/bindings/js.rs b/components/script/dom/bindings/js.rs
index 17853287590..f24115a349a 100644
--- a/components/script/dom/bindings/js.rs
+++ b/components/script/dom/bindings/js.rs
@@ -248,6 +248,17 @@ impl<T: Reflectable> MutNullableJS<T> {
     pub unsafe fn get_inner(&self) -> Option<JS<T>> {
         self.ptr.get()
     }
+
+    pub fn or_init(&self, cb: || -> Temporary<T>) -> Temporary<T> {
+        match self.get() {
+            Some(inner) => inner,
+            None => {
+                let inner = cb();
+                self.assign(Some(inner));
+                inner
+            },
+        }
+    }
 }
 
 impl<T: Reflectable> JS<T> {
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 726e7e69516..f282aa3b483 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -483,10 +483,7 @@ impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
 impl<'a> DocumentMethods for JSRef<'a, Document> {
     // http://dom.spec.whatwg.org/#dom-document-implementation
     fn Implementation(self) -> Temporary<DOMImplementation> {
-        if self.implementation.get().is_none() {
-            self.implementation.assign(Some(DOMImplementation::new(self)));
-        }
-        self.implementation.get().unwrap()
+        self.implementation.or_init(|| DOMImplementation::new(self))
     }
 
     // http://dom.spec.whatwg.org/#dom-document-url
@@ -874,23 +871,21 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
     }
 
     fn Images(self) -> Temporary<HTMLCollection> {
-        if self.images.get().is_none() {
+        self.images.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box ImagesFilter;
-            self.images.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.images.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Embeds(self) -> Temporary<HTMLCollection> {
-        if self.embeds.get().is_none() {
+        self.embeds.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box EmbedsFilter;
-            self.embeds.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.embeds.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Plugins(self) -> Temporary<HTMLCollection> {
@@ -898,54 +893,49 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
     }
 
     fn Links(self) -> Temporary<HTMLCollection> {
-        if self.links.get().is_none() {
+        self.links.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box LinksFilter;
-            self.links.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.links.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Forms(self) -> Temporary<HTMLCollection> {
-        if self.forms.get().is_none() {
+        self.forms.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box FormsFilter;
-            self.forms.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.forms.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Scripts(self) -> Temporary<HTMLCollection> {
-        if self.scripts.get().is_none() {
+        self.scripts.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box ScriptsFilter;
-            self.scripts.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.scripts.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Anchors(self) -> Temporary<HTMLCollection> {
-        if self.anchors.get().is_none() {
+        self.anchors.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box AnchorsFilter;
-            self.anchors.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.anchors.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Applets(self) -> Temporary<HTMLCollection> {
         // FIXME: This should be return OBJECT elements containing applets.
-        if self.applets.get().is_none() {
+        self.applets.or_init(|| {
             let window = self.window.root();
             let root = NodeCast::from_ref(self);
             let filter = box AppletsFilter;
-            self.applets.assign(Some(HTMLCollection::create(*window, root, filter)));
-        }
-        self.applets.get().unwrap()
+            HTMLCollection::create(*window, root, filter)
+        })
     }
 
     fn Location(self) -> Temporary<Location> {
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index a6df60e92f0..0e6e00ed200 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -10,7 +10,7 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::EventTargetCast;
 use dom::bindings::error::{Fallible, InvalidCharacter};
 use dom::bindings::global;
-use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalSettable};
+use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::browsercontext::BrowserContext;
 use dom::console::Console;
@@ -207,36 +207,19 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
     }
 
     fn Location(self) -> Temporary<Location> {
-        if self.location.get().is_none() {
-            let page = self.page.clone();
-            let location = Location::new(self, page);
-            self.location.assign(Some(location));
-        }
-        self.location.get().unwrap()
+        self.location.or_init(|| Location::new(self, self.page.clone()))
     }
 
     fn SessionStorage(self) -> Temporary<Storage> {
-        if self.session_storage.get().is_none() {
-            let session_storage = Storage::new(&global::Window(self));
-            self.session_storage.assign(Some(session_storage));
-        }
-        self.session_storage.get().unwrap()
+        self.session_storage.or_init(|| Storage::new(&global::Window(self)))
     }
 
     fn Console(self) -> Temporary<Console> {
-        if self.console.get().is_none() {
-            let console = Console::new(global::Window(self));
-            self.console.assign(Some(console));
-        }
-        self.console.get().unwrap()
+        self.console.or_init(|| Console::new(global::Window(self)))
     }
 
     fn Navigator(self) -> Temporary<Navigator> {
-        if self.navigator.get().is_none() {
-            let navigator = Navigator::new(self);
-            self.navigator.assign(Some(navigator));
-        }
-        self.navigator.get().unwrap()
+        self.navigator.or_init(|| Navigator::new(self))
     }
 
     fn SetTimeout(self, _cx: *mut JSContext, callback: Function, timeout: i32, args: Vec<JSVal>) -> i32 {
@@ -284,11 +267,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
     }
 
     fn Performance(self) -> Temporary<Performance> {
-        if self.performance.get().is_none() {
-            let performance = Performance::new(self);
-            self.performance.assign(Some(performance));
-        }
-        self.performance.get().unwrap()
+        self.performance.or_init(|| Performance::new(self))
     }
 
     event_handler!(click, GetOnclick, SetOnclick)
@@ -297,11 +276,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
     error_event_handler!(error, GetOnerror, SetOnerror)
 
     fn Screen(self) -> Temporary<Screen> {
-        if self.screen.get().is_none() {
-            let screen = Screen::new(self);
-            self.screen.assign(Some(screen));
-        }
-        self.screen.get().unwrap()
+        self.screen.or_init(|| Screen::new(self))
     }
 
     fn Debug(self, message: DOMString) {