--- a/testing/marionette/driver/marionette_driver/marionette.py
+++ b/testing/marionette/driver/marionette_driver/marionette.py
@@ -593,17 +593,17 @@ class Marionette(object):
             self.instance = instance_class(host=self.host, port=self.port,
                                            bin=self.bin, profile=self.profile,
                                            app_args=app_args,
                                            symbols_path=symbols_path,
                                            gecko_log=gecko_log, prefs=prefs,
                                            addons=self.addons,
                                            workspace=workspace)
             self.instance.start()
-            assert(self.wait_for_port(timeout=startup_timeout)), "Timed out waiting for port!"
+            self.raise_for_port(self.wait_for_port(timeout=startup_timeout))
 
         if emulator:
             self.runner = B2GEmulatorRunner(b2g_home=homedir,
                                             no_window=self.no_window,
                                             logdir=logdir,
                                             arch=emulator,
                                             sdcard=sdcard,
                                             symbols_path=symbols_path,
@@ -612,26 +612,26 @@ class Marionette(object):
                                             resolution=emulator_res,
                                             profile=self.profile,
                                             addons=self.addons,
                                             adb_path=adb_path,
                                             process_args=process_args)
             self.emulator = self.runner.device
             self.emulator.start()
             self.port = self.emulator.setup_port_forwarding(remote_port=self.port)
-            assert(self.emulator.wait_for_port(self.port)), "Timed out waiting for port!"
+            self.raise_for_port(self.emulator.wait_for_port(self.port))
 
         if connect_to_running_emulator:
             self.runner = B2GEmulatorRunner(b2g_home=homedir,
                                             logdir=logdir,
                                             process_args=process_args)
             self.emulator = self.runner.device
             self.emulator.connect()
             self.port = self.emulator.setup_port_forwarding(remote_port=self.port)
-            assert(self.emulator.wait_for_port(self.port)), "Timed out waiting for port!"
+            self.raise_for_port(self.emulator.wait_for_port(self.port))
 
         if emulator:
             if busybox:
                 self.emulator.install_busybox(busybox=busybox)
             self.emulator.wait_for_system_message(self)
 
         # for callbacks from a protocol level 2 or lower remote,
         # we store the callback ID so it can be used by _send_emulator_result
@@ -669,16 +669,22 @@ class Marionette(object):
             return False
         finally:
             s.close()
 
     def wait_for_port(self, timeout=60):
         return transport.wait_for_port(self.host, self.port, timeout=timeout)
 
     @do_crash_check
+    def raise_for_port(self, port_obtained):
+        if not port_obtained:
+            raise IOError("Timed out waiting for port!")
+
+
+    @do_crash_check
     def _send_message(self, name, params=None, key=None):
         """Send a blocking message to the server.
 
         Marionette provides an asynchronous, non-blocking interface and
         this attempts to paper over this by providing a synchronous API
         to the user.
 
         In particular, the Python client can be instructed to carry out
@@ -1092,17 +1098,17 @@ class Marionette(object):
             }
             """ % (pref, value))
             if not pref_exists:
                 break
         self.set_context(self.CONTEXT_CONTENT)
         if not pref_exists:
             self.delete_session()
             self.instance.restart(prefs)
-            assert(self.wait_for_port()), "Timed out waiting for port!"
+            self.raise_for_port(self.wait_for_port())
             self.start_session()
             self._reset_timeouts()
 
     def restart(self, clean=False, in_app=False):
         """
         This will terminate the currently running instance, and spawn a new instance
         with the same profile and then reuse the session id when creating a session again.
 
@@ -1129,17 +1135,17 @@ class Marionette(object):
             self._send_message("quitApplication", {"flags": restart_flags})
             self.client.close()
             # The instance is restarting itself; we will no longer be able to
             # track it by pid, so mark it as 'detached'.
             self.instance.detached = True
         else:
             self.delete_session()
             self.instance.restart(clean=clean)
-        assert(self.wait_for_port()), "Timed out waiting for port!"
+        self.raise_for_port(self.wait_for_port())
         self.start_session(session_id=self.session_id)
         self._reset_timeouts()
 
         # Give consumers who depended on the old session a
         # chance to re-initialize and/or restore state.
         for handler in self.restart_handlers:
             handler()