--- a/testing/marionette/harness/marionette/tests/unit/test_anonymous_content.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_anonymous_content.py
@@ -10,24 +10,24 @@ from marionette_driver.marionette import
 from marionette_driver.wait import Wait
 from marionette_driver.by import By
 
 
 class TestAnonymousContent(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
-        self.win = self.marionette.current_window_handle
+        self.win = self.marionette.current_chrome_window_handle
         self.marionette.execute_script("window.open('chrome://marionette/content/test_anonymous_content.xul', 'foo', 'chrome,centerscreen');")
         self.marionette.switch_to_window('foo')
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
 
     def tearDown(self):
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
-        self.marionette.execute_script("window.close();")
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(self.win)
         MarionetteTestCase.tearDown(self)
 
     def test_switch_to_anonymous_frame(self):
         self.marionette.find_element(By.ID, "testAnonymousContentBox")
         anon_browser_el = self.marionette.find_element(By.ID, "browser")
         self.assertTrue("test_anonymous_content.xul" in self.marionette.get_url())
         self.marionette.switch_to_frame(anon_browser_el)

--- a/testing/marionette/harness/marionette/tests/unit/test_checkbox_chrome.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_checkbox_chrome.py
@@ -5,25 +5,25 @@
 from marionette import MarionetteTestCase
 from marionette_driver.by import By
 
 
 class TestSelectedChrome(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
-        self.win = self.marionette.current_window_handle
+        self.win = self.marionette.current_chrome_window_handle
         self.marionette.execute_script("window.open('chrome://marionette/content/test.xul', '_blank', 'chrome,centerscreen');")
 
     def tearDown(self):
-        self.marionette.execute_script("window.close();")
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(self.win)
         MarionetteTestCase.tearDown(self)
 
     def test_selected(self):
-        wins = self.marionette.window_handles
+        wins = self.marionette.chrome_window_handles
         wins.remove(self.win)
         newWin = wins.pop()
         self.marionette.switch_to_window(newWin)
         box = self.marionette.find_element(By.ID, "testBox")
         self.assertFalse(box.is_selected())
         self.assertFalse(self.marionette.execute_script("arguments[0].checked = true;", [box]))
         self.assertTrue(box.is_selected())

--- a/testing/marionette/harness/marionette/tests/unit/test_elementsize_chrome.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_elementsize_chrome.py
@@ -5,29 +5,29 @@
 from marionette import MarionetteTestCase
 from marionette_driver.by import By
 
 
 class TestElementSizeChrome(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
-        self.win = self.marionette.current_window_handle
+        self.win = self.marionette.current_chrome_window_handle
         self.marionette.execute_script(
             "window.open('chrome://marionette/content/test2.xul', 'foo', 'chrome,centerscreen');")
         self.marionette.switch_to_window('foo')
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
 
     def tearDown(self):
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
-        self.marionette.execute_script("window.close();")
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(self.win)
         MarionetteTestCase.tearDown(self)
 
     def testShouldReturnTheSizeOfAnInput(self):
-        wins = self.marionette.window_handles
+        wins = self.marionette.chrome_window_handles
         wins.remove(self.win)
         newWin = wins.pop()
         self.marionette.switch_to_window(newWin)
         shrinko = self.marionette.find_element(By.ID, 'textInput')
         size = shrinko.rect
         self.assertTrue(size['width'] > 0)
         self.assertTrue(size['height'] > 0)

--- a/testing/marionette/harness/marionette/tests/unit/test_import_script.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_import_script.py
@@ -101,26 +101,26 @@ class TestImportScriptContent(Marionette
         self.marionette.import_script(self.another_script_file)
         self.assert_defined("testFunc")
         self.assert_defined("testAnotherFunc")
 
     @skip_if_chrome
     def test_imports_apply_globally(self):
         self.marionette.navigate(
             self.marionette.absolute_url("test_windows.html"))
-        original_window = self.marionette.current_window_handle
+        original_window = self.marionette.current_chrome_window_handle
         self.marionette.find_element(By.LINK_TEXT, "Open new window").click()
 
-        windows = set(self.marionette.window_handles)
+        windows = set(self.marionette.chrome_window_handles)
         print "windows={}".format(windows)
         new_window = windows.difference([original_window]).pop()
         self.marionette.switch_to_window(new_window)
 
         self.marionette.import_script(self.script_file)
-        self.marionette.close()
+        self.marionette.close_chrome_window()
 
         print "switching to original window: {}".format(original_window)
         self.marionette.switch_to_window(original_window)
         self.assert_defined("testFunc")
 
 
 class TestImportScriptChrome(TestImportScriptContent):
     def reset_context(self):

--- a/testing/marionette/harness/marionette/tests/unit/test_key_actions.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_key_actions.py
@@ -75,16 +75,16 @@ class TestKeyActions(MarionetteTestCase)
         # handle that inside the action chain (bug 1295538).
         self.marionette.execute_script('arguments[0].scrollIntoView()', script_args=[el])
         (self.key_action.key_down(Keys.SHIFT)
                         .press(el)
                         .release()
                         .key_up(Keys.SHIFT)
                         .perform())
         self.wait_for_condition(
-            lambda mn: len(self.marionette.window_handles) == 2)
+            lambda mn: len(self.marionette.chrome_window_handles) == 2)
         chrome_window_handles = self.marionette.chrome_window_handles
         chrome_window_handles.remove(start_win)
         [new_win] = chrome_window_handles
         self.marionette.switch_to_window(new_win)
-        self.marionette.close()
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(start_win)
         self.assertEqual(self.key_reporter_value, "")

--- a/testing/marionette/harness/marionette/tests/unit/test_pagesource_chrome.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_pagesource_chrome.py
@@ -4,26 +4,26 @@
 
 from marionette import MarionetteTestCase
 
 
 class TestPageSourceChrome(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
-        self.win = self.marionette.current_window_handle
+        self.win = self.marionette.current_chrome_window_handle
         self.marionette.execute_script("window.open('chrome://marionette/content/test.xul', 'foo', 'chrome,centerscreen');")
         self.marionette.switch_to_window('foo')
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
 
     def tearDown(self):
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
-        self.marionette.execute_script("window.close();")
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(self.win)
         MarionetteTestCase.tearDown(self)
 
     def testShouldReturnXULDetails(self):
-        wins = self.marionette.window_handles
+        wins = self.marionette.chrome_window_handles
         wins.remove(self.win)
         newWin = wins.pop()
         self.marionette.switch_to_window(newWin)
         source  = self.marionette.page_source
         self.assertTrue('<textbox id="textInput"' in source)

--- a/testing/marionette/harness/marionette/tests/unit/test_text_chrome.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_text_chrome.py
@@ -6,47 +6,47 @@ from marionette import MarionetteTestCas
 from marionette_driver.by import By
 
 
 ''' Disabled in bug 896043 and when working on Chrome code re-enable for bug 896046
 class TestTextChrome(MarionetteTestCase):
     def setUp(self):
         MarionetteTestCase.setUp(self)
         self.marionette.set_context("chrome")
-        self.win = self.marionette.current_window_handle
+        self.win = self.marionette.current_chrome_window_handle
         self.marionette.execute_script("window.open('chrome://marionette/content/test.xul', 'foo', 'chrome,centerscreen');")
         self.marionette.switch_to_window('foo')
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
 
     def tearDown(self):
-        self.assertNotEqual(self.win, self.marionette.current_window_handle)
-        self.marionette.execute_script("window.close();")
+        self.assertNotEqual(self.win, self.marionette.current_chrome_window_handle)
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(self.win)
         MarionetteTestCase.tearDown(self)
 
     def test_getText(self):
-        wins = self.marionette.window_handles
+        wins = self.marionette.chrome_window_handles
         wins.remove(self.win)
         newWin = wins.pop()
         self.marionette.switch_to_window(newWin)
         box = self.marionette.find_element(By.ID, "textInput")
         self.assertEqual("test", box.text)
 
     def test_clearText(self):
-        wins = self.marionette.window_handles
+        wins = self.marionette.chrome_window_handles
         wins.remove(self.win)
         newWin = wins.pop()
         self.marionette.switch_to_window(newWin)
         box = self.marionette.find_element(By.ID, "textInput")
         self.assertEqual("test", box.text)
         box.clear()
         self.assertEqual("", box.text)
 
     def test_sendKeys(self):
-        wins = self.marionette.window_handles
+        wins = self.marionette.chrome_window_handles
         wins.remove(self.win)
         newWin = wins.pop()
         self.marionette.switch_to_window(newWin)
         box = self.marionette.find_element(By.ID, "textInput")
         self.assertEqual("test", box.text)
         box.send_keys("at")
         self.assertEqual("attest", box.text)
 '''
\ No newline at end of file

--- a/testing/marionette/harness/marionette/tests/unit/test_window_handles.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_window_handles.py
@@ -90,41 +90,40 @@ class TestWindowHandles(MarionetteTestCa
         self.marionette.switch_to_window(dest_win)
         self.assertEqual(self.marionette.get_url(), "about:blank")
 
     def test_chrome_windows(self):
         opener_page = self.marionette.absolute_url("windowHandles.html")
 
         self.marionette.navigate(opener_page)
 
-        # Window handles don't persist in cases of remoteness change.
-        start_tab = self.marionette.current_window_handle
+        start_win = self.marionette.current_chrome_window_handle
 
         self.marionette.find_element(By.ID, "new-window").click()
 
+        self.assertEqual(len(self.marionette.chrome_window_handles), 2)
         self.assertEqual(len(self.marionette.window_handles), 2)
-        self.assertEqual(len(self.marionette.chrome_window_handles), 2)
-        windows = self.marionette.window_handles
-        windows.remove(start_tab)
-        dest_tab = windows.pop()
-        self.marionette.switch_to_window(dest_tab)
+        windows = self.marionette.chrome_window_handles
+        windows.remove(start_win)
+        dest_win = windows.pop()
+        self.marionette.switch_to_window(dest_win)
 
         self.marionette.navigate(opener_page)
         new_tab_link = self.marionette.find_element(By.ID, "new-tab")
 
         for i in range(3):
             new_tab_link.click()
-            self.marionette.switch_to_window(dest_tab)
+            self.marionette.switch_to_window(dest_win)
             self.wait_for_condition(lambda mn: len(mn.window_handles) == i + 3)
             self.assertEqual(len(self.marionette.chrome_window_handles), 2)
 
         self.marionette.close_chrome_window()
         self.assertEqual(len(self.marionette.chrome_window_handles), 1)
         self.assertEqual(len(self.marionette.window_handles), 1)
-        self.marionette.switch_to_window(start_tab)
+        self.marionette.switch_to_window(start_win)
 
     def test_chrome_window_handles_with_scopes(self):
         start_tab = self.marionette.current_window_handle
         start_chrome_window = self.marionette.current_chrome_window_handle
         start_chrome_windows = self.marionette.chrome_window_handles
 
         # Ensure that we work in chrome scope so we don't have any limitations
         with self.marionette.using_context("chrome"):

--- a/testing/marionette/harness/marionette/tests/unit/test_window_management.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_window_management.py
@@ -29,87 +29,87 @@ var ww = Components.classes["@mozilla.or
                    .getService(Components.interfaces.nsIWindowWatcher);
 var win = ww.getWindowByName("testWin", null);
 if (win != null)
   win.close();
 """)
         self.marionette.set_context("content")
 
     def test_windows(self):
-        orig_win = self.marionette.current_window_handle
-        orig_available = self.marionette.window_handles
+        orig_win = self.marionette.current_chrome_window_handle
+        orig_available = self.marionette.chrome_window_handles
         self.open_new_window()
         # assert we're still in the original window
-        self.assertEqual(self.marionette.current_window_handle, orig_win)
+        self.assertEqual(self.marionette.current_chrome_window_handle, orig_win)
         # assert we can find the new window
         Wait(self.marionette).until(
-            lambda _: len(self.marionette.window_handles) == len(orig_available) + 1,
+            lambda _: len(self.marionette.chrome_window_handles) == len(orig_available) + 1,
             message="The new window has not been opened.")
         # assert that our window is there
-        now_available = self.marionette.window_handles
+        now_available = self.marionette.chrome_window_handles
         self.assertIn(orig_win, now_available)
         new_win = None
         for win in now_available:
             if win != orig_win:
                 new_win = win
         # switch to another window
         self.marionette.switch_to_window(new_win)
-        self.assertEqual(self.marionette.current_window_handle, new_win)
-        self.assertNotEqual(self.marionette.current_window_handle, orig_win)
+        self.assertEqual(self.marionette.current_chrome_window_handle, new_win)
+        self.assertNotEqual(self.marionette.current_chrome_window_handle, orig_win)
         # switch back
         self.marionette.switch_to_window(orig_win)
-        self.assertEqual(self.marionette.current_window_handle, orig_win)
+        self.assertEqual(self.marionette.current_chrome_window_handle, orig_win)
         self.close_new_window()
-        self.assertNotIn(new_win, self.marionette.window_handles)
-        self.assertEqual(self.marionette.current_window_handle, orig_win)
-        self.assertEqual(len(self.marionette.window_handles), len(orig_available))
+        self.assertNotIn(new_win, self.marionette.chrome_window_handles)
+        self.assertEqual(self.marionette.current_chrome_window_handle, orig_win)
+        self.assertEqual(len(self.marionette.chrome_window_handles), len(orig_available))
 
     def testShouldLoadAWindowAndThenCloseIt(self):
         test_html = self.marionette.absolute_url("test_windows.html")
         self.marionette.navigate(test_html)
-        current = self.marionette.current_window_handle
+        current = self.marionette.current_chrome_window_handle
 
         self.marionette.find_element(By.LINK_TEXT, "Open new window").click()
         count = 0
         while True:
-            window_handles = self.marionette.window_handles
+            window_handles = self.marionette.chrome_window_handles
             window_handles.remove(current)
             if len(window_handles) > 0:
                 break
             elif count > 10:
                 self.fail("There were no windows that appeared when we clicked earlier")
             else:
                 time.sleep(1)
             count += 1
 
         self.marionette.switch_to_window(window_handles[0])
         self.assertEqual(self.marionette.title, "We Arrive Here")
 
-        handle = self.marionette.current_window_handle
+        handle = self.marionette.current_chrome_window_handle
 
-        self.assertEqual(self.marionette.current_window_handle, handle)
-        self.assertEqual(2, len(self.marionette.window_handles))
+        self.assertEqual(self.marionette.current_chrome_window_handle, handle)
+        self.assertEqual(2, len(self.marionette.chrome_window_handles))
 
         # Let's close and check
-        self.marionette.close()
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(current)
-        self.assertEqual(1, len(self.marionette.window_handles))
+        self.assertEqual(1, len(self.marionette.chrome_window_handles))
 
     def testShouldCauseAWindowToLoadAndCheckItIsOpenThenCloseIt(self):
         test_html = self.marionette.absolute_url("test_windows.html")
         self.marionette.navigate(test_html)
-        current = self.marionette.current_window_handle
+        current = self.marionette.current_chrome_window_handle
 
         self.marionette.find_element(By.LINK_TEXT,"Open new window").click()
-        all_handles = self.marionette.window_handles
+        all_handles = self.marionette.chrome_window_handles
         self.assertEqual(2, len(all_handles))
         self.marionette.switch_to_window([x for x in all_handles if x != current][0])
 
         # Let's close and check
-        self.marionette.close()
+        self.marionette.close_chrome_window()
         self.marionette.switch_to_window(current)
-        self.assertEqual(1, len(self.marionette.window_handles))
+        self.assertEqual(1, len(self.marionette.chrome_window_handles))
 
     def tearDown(self):
         #ensure that we close the window, regardless of pass/failure
         self.close_new_window()
         MarionetteTestCase.tearDown(self)
 

--- a/testing/marionette/harness/marionette/tests/unit/test_window_switching.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_window_switching.py
@@ -9,41 +9,41 @@ from marionette_driver.errors import NoS
 from marionette_driver.wait import Wait
 
 
 class TestWindowSwitching(MarionetteTestCase):
     def testJSWindowCreationAndSwitching(self):
         test_html = self.marionette.absolute_url("test_windows.html")
         self.marionette.navigate(test_html)
 
-        self.current_window = self.marionette.current_window_handle
+        self.current_window = self.marionette.current_chrome_window_handle
         link = self.marionette.find_element(By.LINK_TEXT, "Open new window")
         link.click()
 
-        windows = self.marionette.window_handles
+        windows = self.marionette.chrome_window_handles
         windows.remove(self.current_window)
         self.marionette.switch_to_window(windows[0])
 
         title = self.marionette.execute_script("return document.title")
         results_page = self.marionette.absolute_url("resultPage.html")
         self.assertEqual(self.marionette.get_url(), results_page)
         self.assertEqual(title, "We Arrive Here")
 
         #ensure navigate works in our current window
         other_page = self.marionette.absolute_url("test.html")
         self.marionette.navigate(other_page)
-        other_window = self.marionette.current_window_handle
+        other_window = self.marionette.current_chrome_window_handle
 
         #try to access its dom
         #since Bug 720714 stops us from checking DOMContentLoaded, we wait a bit
         Wait(self.marionette, timeout=30, ignored_exceptions=NoSuchElementException).until(
             lambda m: m.find_element(By.ID, 'mozLink'))
 
-        self.assertEqual(other_window, self.marionette.current_window_handle)
+        self.assertEqual(other_window, self.marionette.current_chrome_window_handle)
         self.marionette.switch_to_window(self.current_window)
-        self.assertEqual(self.current_window, self.marionette.current_window_handle)
+        self.assertEqual(self.current_window, self.marionette.current_chrome_window_handle)
 
     def tearDown(self):
-        window_handles = self.marionette.window_handles
+        window_handles = self.marionette.chrome_window_handles
         window_handles.remove(self.current_window)
         for handle in window_handles:
             self.marionette.switch_to_window(handle)
-            self.marionette.close()
+            self.marionette.close_chrome_window()