From dad592fb0581cd5c2f76d61ca1548613626c96d4 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Sun, 15 Oct 2017 01:09:32 +0300
Subject: [PATCH 01/14] rename browsercache.py to drivercache.py

---
 src/SeleniumLibrary/utils/{browsercache.py => drivercache.py} | 0
 test/unit/utils/{test_browsercache.py => test_drivercache.py} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename src/SeleniumLibrary/utils/{browsercache.py => drivercache.py} (100%)
 rename test/unit/utils/{test_browsercache.py => test_drivercache.py} (100%)

diff --git a/src/SeleniumLibrary/utils/browsercache.py b/src/SeleniumLibrary/utils/drivercache.py
similarity index 100%
rename from src/SeleniumLibrary/utils/browsercache.py
rename to src/SeleniumLibrary/utils/drivercache.py
diff --git a/test/unit/utils/test_browsercache.py b/test/unit/utils/test_drivercache.py
similarity index 100%
rename from test/unit/utils/test_browsercache.py
rename to test/unit/utils/test_drivercache.py

From 83c1087efb8494b03ea013113977c397888ba636 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Sun, 15 Oct 2017 01:17:45 +0300
Subject: [PATCH 02/14] Fixed DriverCache internal from browser to driver

---
 src/SeleniumLibrary/__init__.py          |  4 +-
 src/SeleniumLibrary/utils/__init__.py    |  2 +-
 src/SeleniumLibrary/utils/drivercache.py | 30 +++++------
 test/unit/utils/test_drivercache.py      | 66 ++++++++++++------------
 4 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 4f60b044b..0b1d533f3 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -34,7 +34,7 @@
                                       WaitingKeywords,
                                       WindowKeywords)
 from SeleniumLibrary.locators import ElementFinder, TableElementFinder
-from SeleniumLibrary.utils import (BrowserCache, Deprecated, LibraryListener,
+from SeleniumLibrary.utils import (Deprecated, DriverCache, LibraryListener,
                                    timestr_to_secs)
 
 
@@ -342,7 +342,7 @@ def __init__(self, timeout=5.0, implicit_wait=0.0,
             WaitingKeywords(self),
             WindowKeywords(self)
         ]
-        self._browsers = BrowserCache()
+        self._browsers = DriverCache()
         DynamicCore.__init__(self, libraries)
         self.ROBOT_LIBRARY_LISTENER = LibraryListener()
         self._element_finder = ElementFinder(self)
diff --git a/src/SeleniumLibrary/utils/__init__.py b/src/SeleniumLibrary/utils/__init__.py
index d27eddecd..6e6cccdcc 100644
--- a/src/SeleniumLibrary/utils/__init__.py
+++ b/src/SeleniumLibrary/utils/__init__.py
@@ -16,8 +16,8 @@
 
 from robot.utils import plural_or_not, secs_to_timestr, timestr_to_secs
 
-from .browsercache import BrowserCache
 from .deprecated import Deprecated
+from .drivercache import DriverCache
 from .librarylistener import LibraryListener
 from .seleniumversion import SELENIUM_VERSION
 from .types import is_falsy, is_noney, is_string, is_truthy
diff --git a/src/SeleniumLibrary/utils/drivercache.py b/src/SeleniumLibrary/utils/drivercache.py
index 8081d9876..c53847958 100644
--- a/src/SeleniumLibrary/utils/drivercache.py
+++ b/src/SeleniumLibrary/utils/drivercache.py
@@ -17,33 +17,33 @@
 from robot.utils import ConnectionCache
 
 
-class BrowserCache(ConnectionCache):
+class DriverCache(ConnectionCache):
 
     def __init__(self):
-        ConnectionCache.__init__(self, no_current_msg='No current browser')
+        ConnectionCache.__init__(self, no_current_msg='No current driver')
         self._closed = set()
 
     @property
-    def browsers(self):
+    def drivers(self):
         return self._connections
 
-    def get_open_browsers(self):
-        open_browsers = []
-        for browser in self._connections:
-            if browser not in self._closed:
-                open_browsers.append(browser)
-        return open_browsers
+    def get_open_drivers(self):
+        open_drivers = []
+        for driver in self._connections:
+            if driver not in self._closed:
+                open_drivers.append(driver)
+        return open_drivers
 
     def close(self):
         if self.current:
-            browser = self.current
-            browser.quit()
+            driver = self.current
+            driver.quit()
             self.current = self._no_current
-            self._closed.add(browser)
+            self._closed.add(driver)
 
     def close_all(self):
-        for browser in self._connections:
-            if browser not in self._closed:
-                browser.quit()
+        for driver in self._connections:
+            if driver not in self._closed:
+                driver.quit()
         self.empty_cache()
         return self.current
diff --git a/test/unit/utils/test_drivercache.py b/test/unit/utils/test_drivercache.py
index 0af45378b..cf47076ad 100644
--- a/test/unit/utils/test_drivercache.py
+++ b/test/unit/utils/test_drivercache.py
@@ -2,62 +2,62 @@
 
 from mockito import mock, verify
 
-from SeleniumLibrary.utils import BrowserCache
+from SeleniumLibrary.utils import DriverCache
 
 
-class BrowserCacheTests(unittest.TestCase):
+class DriverCacheTests(unittest.TestCase):
 
     def test_no_current_message(self):
-        cache = BrowserCache()
+        cache = DriverCache()
         try:
             self.assertRaises(RuntimeError, cache.current.anyMember())
         except RuntimeError as e:
-            self.assertEqual(str(e), "No current browser")
+            self.assertEqual(str(e), "No current driver")
 
     def test_browsers_property(self):
-        cache = BrowserCache()
+        cache = DriverCache()
 
-        browser1 = mock()
-        browser2 = mock()
-        browser3 = mock()
+        driver1 = mock()
+        driver2 = mock()
+        driver3 = mock()
 
-        index1 = cache.register(browser1)
-        index2 = cache.register(browser2)
-        index3 = cache.register(browser3)
+        index1 = cache.register(driver1)
+        index2 = cache.register(driver2)
+        index3 = cache.register(driver3)
 
-        self.assertEqual(len(cache.browsers), 3)
-        self.assertEqual(cache.browsers[0], browser1)
-        self.assertEqual(cache.browsers[1], browser2)
-        self.assertEqual(cache.browsers[2], browser3)
+        self.assertEqual(len(cache.drivers), 3)
+        self.assertEqual(cache.drivers[0], driver1)
+        self.assertEqual(cache.drivers[1], driver2)
+        self.assertEqual(cache.drivers[2], driver3)
         self.assertEqual(index1, 1)
         self.assertEqual(index2, 2)
         self.assertEqual(index3, 3)
 
     def test_get_open_browsers(self):
-        cache = BrowserCache()
+        cache = DriverCache()
 
-        browser1 = mock()
-        browser2 = mock()
-        browser3 = mock()
+        driver1 = mock()
+        driver2 = mock()
+        driver3 = mock()
 
-        cache.register(browser1)
-        cache.register(browser2)
-        cache.register(browser3)
+        cache.register(driver1)
+        cache.register(driver2)
+        cache.register(driver3)
 
-        browsers = cache.get_open_browsers()
-        self.assertEqual(len(browsers), 3)
-        self.assertEqual(browsers[0], browser1)
-        self.assertEqual(browsers[1], browser2)
-        self.assertEqual(browsers[2], browser3)
+        drivers = cache.get_open_drivers()
+        self.assertEqual(len(drivers), 3)
+        self.assertEqual(drivers[0], driver1)
+        self.assertEqual(drivers[1], driver2)
+        self.assertEqual(drivers[2], driver3)
 
         cache.close()
-        browsers = cache.get_open_browsers()
-        self.assertEqual(len(browsers), 2)
-        self.assertEqual(browsers[0], browser1)
-        self.assertEqual(browsers[1], browser2)
+        drivers = cache.get_open_drivers()
+        self.assertEqual(len(drivers), 2)
+        self.assertEqual(drivers[0], driver1)
+        self.assertEqual(drivers[1], driver2)
 
     def test_close(self):
-        cache = BrowserCache()
+        cache = DriverCache()
         browser = mock()
         cache.register(browser)
 
@@ -66,7 +66,7 @@ def test_close(self):
         verify(browser, times=1).quit()
 
     def test_close_only_called_once(self):
-        cache = BrowserCache()
+        cache = DriverCache()
 
         browser1 = mock()
         browser2 = mock()

From cbe4ec1cda7c68dc2eca17e8c9471fe564890092 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Sun, 15 Oct 2017 01:50:32 +0300
Subject: [PATCH 03/14] Changed in code browser(s) to driver(s)

---
 src/SeleniumLibrary/__init__.py               | 16 ++--
 src/SeleniumLibrary/base/context.py           |  8 +-
 src/SeleniumLibrary/keywords/alert.py         |  2 +-
 .../keywords/browsermanagement.py             | 47 +++++----
 src/SeleniumLibrary/keywords/cookie.py        | 12 +--
 src/SeleniumLibrary/keywords/element.py       | 40 ++++----
 src/SeleniumLibrary/keywords/javascript.py    |  4 +-
 src/SeleniumLibrary/keywords/screenshot.py    |  4 +-
 src/SeleniumLibrary/keywords/waiting.py       |  2 +-
 src/SeleniumLibrary/locators/elementfinder.py | 10 +-
 src/SeleniumLibrary/locators/windowmanager.py | 84 ++++++++--------
 test/unit/keywords/test_browsermanagement.py  | 14 +--
 test/unit/keywords/test_cookie.py             | 26 ++---
 .../test_keyword_arguments_waiting.py         |  2 +-
 test/unit/locators/test_elementfinder.py      | 96 +++++++++----------
 test/unit/locators/test_windowmanager.py      | 54 +++++------
 16 files changed, 210 insertions(+), 211 deletions(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 0b1d533f3..8cee36ccd 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -342,7 +342,7 @@ def __init__(self, timeout=5.0, implicit_wait=0.0,
             WaitingKeywords(self),
             WindowKeywords(self)
         ]
-        self._browsers = DriverCache()
+        self._drivers = DriverCache()
         DynamicCore.__init__(self, libraries)
         self.ROBOT_LIBRARY_LISTENER = LibraryListener()
         self._element_finder = ElementFinder(self)
@@ -362,8 +362,8 @@ def run_keyword(self, name, args, kwargs):
             self.failure_occurred()
             raise
 
-    def register_browser(self, browser, alias):
-        return self._browsers.register(browser, alias)
+    def register_driver(self, driver, alias):
+        return self._drivers.register(driver, alias)
 
     def failure_occurred(self):
         """Method that is executed when a SeleniumLibrary keyword fails.
@@ -384,11 +384,11 @@ def failure_occurred(self):
             self._running_on_failure_keyword = False
 
     @property
-    def browser(self):
-        """Current active browser"""
-        if not self._browsers.current:
-            raise RuntimeError('No browser is open')
-        return self._browsers.current
+    def driver(self):
+        """Current active driver"""
+        if not self._drivers.current:
+            raise RuntimeError('No driver is open')
+        return self._drivers.current
 
     def find_element(self, locator, parent=None):
         """Find element matching ``locator``.
diff --git a/src/SeleniumLibrary/base/context.py b/src/SeleniumLibrary/base/context.py
index 5eda0bc7c..bfed50031 100644
--- a/src/SeleniumLibrary/base/context.py
+++ b/src/SeleniumLibrary/base/context.py
@@ -28,12 +28,12 @@ def __init__(self, ctx):
         self.ctx = ctx
 
     @property
-    def browser(self):
-        return self.ctx.browser
+    def driver(self):
+        return self.ctx.driver
 
     @property
-    def browsers(self):
-        return self.ctx._browsers
+    def drivers(self):
+        return self.ctx._drivers
 
     @property
     def element_finder(self):
diff --git a/src/SeleniumLibrary/keywords/alert.py b/src/SeleniumLibrary/keywords/alert.py
index 5756b8943..98022d497 100644
--- a/src/SeleniumLibrary/keywords/alert.py
+++ b/src/SeleniumLibrary/keywords/alert.py
@@ -207,7 +207,7 @@ def _handle_alert(self, alert, action):
 
     def _wait_alert(self, timeout=None):
         timeout = self.get_timeout(timeout)
-        wait = WebDriverWait(self.browser, timeout)
+        wait = WebDriverWait(self.driver, timeout)
         try:
             return wait.until(EC.alert_is_present())
         except WebDriverException:
diff --git a/src/SeleniumLibrary/keywords/browsermanagement.py b/src/SeleniumLibrary/keywords/browsermanagement.py
index cc7ccba23..9709fcdb1 100644
--- a/src/SeleniumLibrary/keywords/browsermanagement.py
+++ b/src/SeleniumLibrary/keywords/browsermanagement.py
@@ -65,15 +65,15 @@ def close_all_browsers(self):
         all browsers are closed.
         """
         self.debug('Closing all browsers.')
-        self.browsers.close_all()
+        self.drivers.close_all()
 
     @keyword
     def close_browser(self):
         """Closes the current browser."""
-        if self.browsers.current:
+        if self.drivers.current:
             self.debug('Closing browser with session id {}.'
-                       .format(self.browser.session_id))
-            self.browsers.close()
+                       .format(self.driver.session_id))
+            self.drivers.close()
 
     @keyword
     def open_browser(self, url, browser='firefox', alias=None,
@@ -141,17 +141,17 @@ def open_browser(self, url, browser='firefox', alias=None,
         else:
             self.info("Opening browser '%s' to base url '%s'." % (browser, url))
         browser_name = browser
-        browser = self._make_browser(browser_name, desired_capabilities,
-                                     ff_profile_dir, remote_url)
+        driver = self._make_browser(browser_name, desired_capabilities,
+                                    ff_profile_dir, remote_url)
         try:
-            browser.get(url)
+            driver.get(url)
         except Exception:
-            self.ctx.register_browser(browser, alias)
+            self.ctx.register_driver(driver, alias)
             self.debug("Opened browser with session id %s but failed "
-                       "to open url '%s'." % (browser.session_id, url))
+                       "to open url '%s'." % (driver.session_id, url))
             raise
-        self.debug('Opened browser with session id %s.' % browser.session_id)
-        return self.ctx.register_browser(browser, alias)
+        self.debug('Opened browser with session id %s.' % driver.session_id)
+        return self.ctx.register_driver(driver, alias)
 
     @keyword
     def create_webdriver(self, driver_name, alias=None, kwargs={},
@@ -200,7 +200,7 @@ def create_webdriver(self, driver_name, alias=None, kwargs={},
         driver = creation_func(**init_kwargs)
         self.debug("Created %s WebDriver instance with session id %s."
                    % (driver_name, driver.session_id))
-        return self.ctx.register_browser(driver, alias)
+        return self.ctx.register_driver(driver, alias)
 
     @keyword
     def switch_browser(self, index_or_alias):
@@ -230,29 +230,28 @@ def switch_browser(self, index_or_alias):
         | `Switch Browser`   | ${index}       |                   |
         """
         try:
-            self.browsers.switch(index_or_alias)
+            self.drivers.switch(index_or_alias)
         except RuntimeError:
             raise RuntimeError("No browser with index or alias '%s' found."
                                % index_or_alias)
         self.debug('Switched to browser with Selenium session id %s.'
-                   % self.browser.session_id)
+                   % self.driver.session_id)
 
     @keyword
     def get_source(self):
         """Returns the entire HTML source of the current page or frame."""
-        return self.browser.page_source
+        return self.driver.page_source
 
     @keyword
     def get_title(self):
         """Returns the title of current page."""
-        return self.browser.title
+        return self.driver.title
 
     @keyword
     def get_location(self):
         """Returns the current browser URL."""
         return self.browser.current_url
 
-
     @keyword
     def location_should_be(self, url):
         """Verifies that current URL is exactly ``url``."""
@@ -309,18 +308,18 @@ def title_should_be(self, title):
     @keyword
     def go_back(self):
         """Simulates the user clicking the back button on their browser."""
-        self.browser.back()
+        self.driver.back()
 
     @keyword
     def go_to(self, url):
         """Navigates the active browser instance to the provided ``url``."""
         self.info("Opening url '%s'" % url)
-        self.browser.get(url)
+        self.driver.get(url)
 
     @keyword
     def reload_page(self):
         """Simulates user reloading page."""
-        self.browser.refresh()
+        self.driver.refresh()
 
     @keyword
     def get_selenium_speed(self):
@@ -368,7 +367,7 @@ def set_selenium_speed(self, value):
         """
         old_speed = self.get_selenium_speed()
         self.ctx.speed = timestr_to_secs(value)
-        for browser in self.browsers.browsers:
+        for browser in self.drivers.browsers:
             self._monkey_patch_speed(browser)
         return old_speed
 
@@ -390,7 +389,7 @@ def set_selenium_timeout(self, value):
         """
         old_timeout = self.get_selenium_timeout()
         self.ctx.timeout = timestr_to_secs(value)
-        for browser in self.browsers.get_open_browsers():
+        for browser in self.drivers.get_open_drivers():
             browser.set_script_timeout(self.ctx.timeout)
         return old_timeout
 
@@ -416,7 +415,7 @@ def set_selenium_implicit_wait(self, value):
         """
         old_wait = self.get_selenium_implicit_wait()
         self.ctx.implicit_wait = timestr_to_secs(value)
-        for browser in self.browsers.get_open_browsers():
+        for browser in self.drivers.get_open_drivers():
             browser.implicitly_wait(self.ctx.implicit_wait)
         return old_wait
 
@@ -427,7 +426,7 @@ def set_browser_implicit_wait(self, value):
         Same as `Set Selenium Implicit Wait` but only affects the current
         browser.
         """
-        self.browser.implicitly_wait(timestr_to_secs(value))
+        self.driver.implicitly_wait(timestr_to_secs(value))
 
     def _get_browser_creation_function(self, browser_name):
         try:
diff --git a/src/SeleniumLibrary/keywords/cookie.py b/src/SeleniumLibrary/keywords/cookie.py
index a961b092b..bd206ed54 100644
--- a/src/SeleniumLibrary/keywords/cookie.py
+++ b/src/SeleniumLibrary/keywords/cookie.py
@@ -28,7 +28,7 @@ class CookieKeywords(LibraryComponent):
     @keyword
     def delete_all_cookies(self):
         """Deletes all cookies."""
-        self.browser.delete_all_cookies()
+        self.driver.delete_all_cookies()
 
     @keyword
     def delete_cookie(self, name):
@@ -36,7 +36,7 @@ def delete_cookie(self, name):
 
         If the cookie is not found, nothing happens.
         """
-        self.browser.delete_cookie(name)
+        self.driver.delete_cookie(name)
 
     @keyword
     def get_cookies(self):
@@ -48,14 +48,14 @@ def get_cookies(self):
         HTTP requests.
         """
         pairs = []
-        for cookie in self.browser.get_cookies():
+        for cookie in self.driver.get_cookies():
             pairs.append(cookie['name'] + "=" + cookie['value'])
         return '; '.join(pairs)
 
     @keyword
     def get_cookie_value(self, name):
         """Deprecated. Use `Get Cookie` instead."""
-        cookie = self.browser.get_cookie(name)
+        cookie = self.driver.get_cookie(name)
         if cookie is not None:
             return cookie['value']
         raise ValueError("Cookie with name %s not found." % name)
@@ -93,7 +93,7 @@ def get_cookie(self, name):
 
         New in SeleniumLibrary 3.0.
         """
-        cookie = self.browser.get_cookie(name)
+        cookie = self.driver.get_cookie(name)
         if not cookie:
             raise CookieNotFound("Cookie with name '%s' not found." % name)
         return CookieInformation(**cookie)
@@ -126,7 +126,7 @@ def add_cookie(self, name, value, path=None, domain=None, secure=None,
             new_cookie['secure'] = is_truthy(secure)
         if not is_noney(expiry):
             new_cookie['expiry'] = self._expiry(expiry)
-        self.browser.add_cookie(new_cookie)
+        self.driver.add_cookie(new_cookie)
 
     def _expiry(self, expiry):
         try:
diff --git a/src/SeleniumLibrary/keywords/element.py b/src/SeleniumLibrary/keywords/element.py
index bb41d5f87..86c2d44e2 100644
--- a/src/SeleniumLibrary/keywords/element.py
+++ b/src/SeleniumLibrary/keywords/element.py
@@ -202,7 +202,7 @@ def assign_id_to_element(self, locator, id):
         """
         self.info("Assigning temporary id '%s' to element '%s'." % (id, locator))
         element = self.find_element(locator)
-        self.browser.execute_script("arguments[0].id = '%s';" % id, element)
+        self.driver.execute_script("arguments[0].id = '%s';" % id, element)
 
     @keyword
     def element_should_be_disabled(self, locator):
@@ -240,10 +240,10 @@ def element_should_be_focused(self, locator):
         New in SeleniumLibrary 3.0.
         """
         element = self.find_element(locator)
-        if self.browser.capabilities['browserName'] != "firefox":
-            focused = self.browser.switch_to.active_element
+        if self.driver.capabilities['browserName'] != "firefox":
+            focused = self.driver.switch_to.active_element
         else:
-            focused = self.browser.execute_script('return document.activeElement;')
+            focused = self.driver.execute_script('return document.activeElement;')
         if element != focused:
             raise AssertionError("Element '%s' does not have focus." % locator)
 
@@ -422,7 +422,7 @@ def click_element_at_coordinates(self, locator, xoffset, yoffset):
         self.info("Clicking element '%s' at coordinates x=%s, y=%s."
                   % (locator, xoffset, yoffset))
         element = self.find_element(locator)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.move_to_element(element)
         action.move_by_offset(xoffset, yoffset)
         action.click()
@@ -437,7 +437,7 @@ def double_click_element(self, locator):
         """
         self.info("Double clicking element '%s'." % locator)
         element = self.find_element(locator)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.double_click(element).perform()
 
     @keyword
@@ -450,7 +450,7 @@ def set_focus_to_element(self, locator):
         Prior to SeleniumLibrary 3.0 this keyword was named `Focus`.
         """
         element = self.find_element(locator)
-        self.browser.execute_script("arguments[0].focus();", element)
+        self.driver.execute_script("arguments[0].focus();", element)
 
     @keyword
     def focus(self, locator):
@@ -470,7 +470,7 @@ def drag_and_drop(self, locator, target):
         """
         element = self.find_element(locator)
         target = self.find_element(target)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.drag_and_drop(element, target).perform()
 
     @keyword
@@ -487,7 +487,7 @@ def drag_and_drop_by_offset(self, locator, xoffset, yoffset):
         | `Drag And Drop By Offset` | myElem | 50 | -35 | # Move myElem 50px right and 35px down |
         """
         element = self.find_element(locator)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.drag_and_drop_by_offset(element, int(xoffset), int(yoffset))
         action.perform()
 
@@ -505,7 +505,7 @@ def mouse_down(self, locator):
         """
         self.info("Simulating Mouse Down on element '%s'." % locator)
         element = self.find_element(locator)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.click_and_hold(element).perform()
 
     @keyword
@@ -520,7 +520,7 @@ def mouse_out(self, locator):
         size = element.size
         offsetx = (size['width'] / 2) + 1
         offsety = (size['height'] / 2) + 1
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.move_to_element(element).move_by_offset(offsetx, offsety)
         action.perform()
 
@@ -533,7 +533,7 @@ def mouse_over(self, locator):
         """
         self.info("Simulating Mouse Over on element '%s'." % locator)
         element = self.find_element(locator)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.move_to_element(element).perform()
 
     @keyword
@@ -545,13 +545,13 @@ def mouse_up(self, locator):
         """
         self.info("Simulating Mouse Up on element '%s'." % locator)
         element = self.find_element(locator)
-        ActionChains(self.browser).release(element).perform()
+        ActionChains(self.driver).release(element).perform()
 
     @keyword
     def open_context_menu(self, locator):
         """Opens context menu on element identified by ``locator``."""
         element = self.find_element(locator)
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.context_click(element).perform()
 
     @keyword
@@ -577,7 +577,7 @@ def simulate_event(self, locator, event):
 evt.initEvent(eventName, true, true);
 return !element.dispatchEvent(evt);
         """
-        self.browser.execute_script(script, element, event)
+        self.driver.execute_script(script, element, event)
 
     @keyword
     def simulate(self, locator, event):
@@ -633,7 +633,7 @@ def mouse_down_on_link(self, locator):
         link text.
         """
         element = self.find_element(locator, tag='link')
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.click_and_hold(element).perform()
 
     @keyword
@@ -684,7 +684,7 @@ def mouse_down_on_image(self, locator):
         syntax. Key attributes for images are ``id``, ``src`` and ``alt``.
         """
         element = self.find_element(locator, tag='image')
-        action = ActionChains(self.browser)
+        action = ActionChains(self.driver)
         action.click_and_hold(element).perform()
 
     @keyword
@@ -796,7 +796,7 @@ def _map_named_key_code_to_special_key(self, key_name):
             raise ValueError(message)
 
     def _page_contains(self, text):
-        self.browser.switch_to.default_content()
+        self.driver.switch_to.default_content()
 
         if self.is_text_present(text):
             return True
@@ -804,9 +804,9 @@ def _page_contains(self, text):
         subframes = self.find_elements("xpath://frame|//iframe")
         self.debug('Current frame has %d subframes.' % len(subframes))
         for frame in subframes:
-            self.browser.switch_to.frame(frame)
+            self.driver.switch_to.frame(frame)
             found_text = self.is_text_present(text)
-            self.browser.switch_to.default_content()
+            self.driver.switch_to.default_content()
             if found_text:
                 return True
         return False
diff --git a/src/SeleniumLibrary/keywords/javascript.py b/src/SeleniumLibrary/keywords/javascript.py
index 4974cbafb..49edff5ea 100644
--- a/src/SeleniumLibrary/keywords/javascript.py
+++ b/src/SeleniumLibrary/keywords/javascript.py
@@ -51,7 +51,7 @@ def execute_javascript(self, *code):
         """
         js = self._get_javascript_to_execute(''.join(code))
         self.info("Executing JavaScript:\n%s" % js)
-        return self.browser.execute_script(js)
+        return self.driver.execute_script(js)
 
     @keyword
     def execute_async_javascript(self, *code):
@@ -76,7 +76,7 @@ def execute_async_javascript(self, *code):
         """
         js = self._get_javascript_to_execute(''.join(code))
         self.info("Executing Asynchronous JavaScript:\n%s" % js)
-        return self.browser.execute_async_script(js)
+        return self.driver.execute_async_script(js)
 
     def _get_javascript_to_execute(self, code):
         codepath = code.replace('/', os.sep)
diff --git a/src/SeleniumLibrary/keywords/screenshot.py b/src/SeleniumLibrary/keywords/screenshot.py
index 2d125a9f5..2446fb1b7 100644
--- a/src/SeleniumLibrary/keywords/screenshot.py
+++ b/src/SeleniumLibrary/keywords/screenshot.py
@@ -89,12 +89,12 @@ def capture_page_screenshot(self,
         | `Capture Page Screenshot` | formatted_index_{index:03}.png         |
         | `File Should Exist`       | ${OUTPUTDIR}/formatted_index_001.png   |
         """
-        if not self.browsers.current:
+        if not self.drivers.current:
             self.info('Cannot capture screenshot because no browser is open.')
             return
         path = self._get_screenshot_path(filename)
         self._create_directory(path)
-        if not self.browser.save_screenshot(path):
+        if not self.driver.save_screenshot(path):
             raise RuntimeError("Failed to save screenshot '{}'.".format(path))
         # Image is shown on its own row and thus previous row is closed on
         # purpose. Depending on Robot's log structure is a bit risky.
diff --git a/src/SeleniumLibrary/keywords/waiting.py b/src/SeleniumLibrary/keywords/waiting.py
index cd1fb1caa..11959d917 100644
--- a/src/SeleniumLibrary/keywords/waiting.py
+++ b/src/SeleniumLibrary/keywords/waiting.py
@@ -44,7 +44,7 @@ def wait_for_condition(self, condition, timeout=None, error=None):
             raise ValueError("Condition '%s' did not have mandatory 'return'."
                              % condition)
         self._wait_until(
-            lambda: self.browser.execute_script(condition) is True,
+            lambda: self.driver.execute_script(condition) is True,
             "Condition '%s' did not become true in <TIMEOUT>." % condition,
             timeout, error
         )
diff --git a/src/SeleniumLibrary/locators/elementfinder.py b/src/SeleniumLibrary/locators/elementfinder.py
index 979afdc69..de8a7a18e 100644
--- a/src/SeleniumLibrary/locators/elementfinder.py
+++ b/src/SeleniumLibrary/locators/elementfinder.py
@@ -70,7 +70,7 @@ def find(self, locator, tag=None, first_only=True, required=True,
         strategy = self._strategies[prefix]
         tag, constraints = self._get_tag_and_constraints(tag)
         elements = strategy(criteria, tag, constraints,
-                            parent=parent or self.browser)
+                            parent=parent or self.driver)
         if required and not elements:
             raise ElementNotFound("{} with locator '{}' not found."
                                   .format(element_type, locator))
@@ -127,7 +127,7 @@ def _find_by_xpath(self, criteria, tag, constraints, parent):
 
     def _find_by_dom(self, criteria, tag, constraints, parent):
         self._disallow_webelement_parent(parent)
-        result = self.browser.execute_script("return %s;" % criteria)
+        result = self.driver.execute_script("return %s;" % criteria)
         if result is None:
             return []
         if not isinstance(result, list):
@@ -138,7 +138,7 @@ def _find_by_sizzle_selector(self, criteria, tag, constraints, parent):
         self._disallow_webelement_parent(parent)
         js = "return jQuery('%s').get();" % criteria.replace("'", "\\'")
         return self._filter_elements(
-            self.browser.execute_script(js),
+            self.driver.execute_script(js),
             tag, constraints)
 
     def _find_by_link_text(self, criteria, tag, constraints, parent):
@@ -169,7 +169,7 @@ def _find_by_tag_name(self, criteria, tag, constraints, parent):
     def _find_by_sc_locator(self, criteria, tag, constraints, parent):
         self._disallow_webelement_parent(parent)
         js = "return isc.AutoTest.getElement('%s')" % criteria.replace("'", "\\'")
-        return self._filter_elements([self.browser.execute_script(js)],
+        return self._filter_elements([self.driver.execute_script(js)],
                                      tag, constraints)
 
     def _find_by_default(self, criteria, tag, constraints, parent):
@@ -280,7 +280,7 @@ def _get_attrs_with_url(self, key_attrs, criteria):
         return attrs
 
     def _get_base_url(self):
-        url = self.browser.current_url
+        url = self.driver.current_url
         if '/' in url:
             url = '/'.join(url.split('/')[:-1])
         return url
diff --git a/src/SeleniumLibrary/locators/windowmanager.py b/src/SeleniumLibrary/locators/windowmanager.py
index 0e9d6cafe..e92c85713 100644
--- a/src/SeleniumLibrary/locators/windowmanager.py
+++ b/src/SeleniumLibrary/locators/windowmanager.py
@@ -49,31 +49,31 @@ def __init__(self, ctx):
     def get_window_infos(self):
         infos = []
         try:
-            starting_handle = self.browser.current_window_handle
+            starting_handle = self.driver.current_window_handle
         except NoSuchWindowException:
             starting_handle = None
         try:
-            for handle in self.browser.window_handles:
-                self.browser.switch_to.window(handle)
-                infos.append(self._get_current_window_info(self.browser))
+            for handle in self.driver.window_handles:
+                self.driver.switch_to.window(handle)
+                infos.append(self._get_current_window_info(self.driver))
         finally:
             if starting_handle:
-                self.browser.switch_to.window(starting_handle)
+                self.driver.switch_to.window(starting_handle)
         return infos
 
     def select(self, locator):
         locator = self._handle_deprecated_locators(locator)
         if not is_string(locator):
-            self._select_by_excludes(self.browser, locator)
+            self._select_by_excludes(self.driver, locator)
         elif locator.upper() == 'CURRENT':
             pass
         elif locator.upper() == 'MAIN':
-            self._select_main_window(self.browser)
+            self._select_main_window(self.driver)
         elif locator.upper() == 'NEW':
-            self._select_by_last_index(self.browser)
+            self._select_by_last_index(self.driver)
         else:
             strategy, locator = self._parse_locator(locator)
-            self._strategies[strategy](self.browser, locator)
+            self._strategies[strategy](self.driver, locator)
 
     def _handle_deprecated_locators(self, locator):
         if not (is_string(locator) or locator is None):
@@ -101,85 +101,85 @@ def _get_locator_separator_index(self, locator):
             return locator.find('=')
         return min(locator.find('='), locator.find(':'))
 
-    def _select_by_title(self, browser, title):
+    def _select_by_title(self, driver, title):
         self._select_matching(
-            browser,
+            driver,
             lambda window_info: window_info.title == title,
             "Unable to locate window with title '%s'." % title
         )
 
-    def _select_by_name(self, browser, name):
+    def _select_by_name(self, driver, name):
         self._select_matching(
-            browser,
+            driver,
             lambda window_info: window_info.name == name,
             "Unable to locate window with name '%s'." % name
         )
 
-    def _select_by_url(self, browser, url):
+    def _select_by_url(self, driver, url):
         self._select_matching(
-            browser,
+            driver,
             lambda window_info: window_info.url == url,
             "Unable to locate window with URL '%s'." % url
         )
 
-    def _select_main_window(self, browser):
-        handles = browser.window_handles
-        browser.switch_to.window(handles[0])
+    def _select_main_window(self, driver):
+        handles = driver.window_handles
+        driver.switch_to.window(handles[0])
 
-    def _select_by_default(self, browser, criteria):
+    def _select_by_default(self, driver, criteria):
         try:
-            starting_handle = browser.current_window_handle
+            starting_handle = driver.current_window_handle
         except NoSuchWindowException:
             starting_handle = None
-        for handle in browser.window_handles:
-            browser.switch_to.window(handle)
+        for handle in driver.window_handles:
+            driver.switch_to.window(handle)
             if criteria == handle:
                 return
-            for item in self._get_current_window_info(browser)[2:4]:
+            for item in self._get_current_window_info(driver)[2:4]:
                 if item == criteria:
                     return
         if starting_handle:
-            browser.switch_to.window(starting_handle)
+            driver.switch_to.window(starting_handle)
         raise WindowNotFound("No window matching handle, name, title or URL "
                              "'%s' found." % criteria)
 
-    def _select_by_last_index(self, browser):
-        handles = browser.window_handles
-        if handles[-1] == browser.current_window_handle:
+    def _select_by_last_index(self, driver):
+        handles = driver.window_handles
+        if handles[-1] == driver.current_window_handle:
             raise WindowNotFound('Window with last index is same as '
                                  'the current window.')
-        browser.switch_to.window(handles[-1])
+        driver.switch_to.window(handles[-1])
 
-    def _select_by_excludes(self, browser, excludes):
-        for handle in browser.window_handles:
+    def _select_by_excludes(self, driver, excludes):
+        for handle in driver.window_handles:
             if handle not in excludes:
-                browser.switch_to.window(handle)
+                driver.switch_to.window(handle)
                 return
         raise WindowNotFound('No window not matching excludes %s found.'
                              % excludes)
 
-    def _select_matching(self, browser, matcher, error):
+    def _select_matching(self, driver, matcher, error):
         try:
-            starting_handle = browser.current_window_handle
+            starting_handle = driver.current_window_handle
         except NoSuchWindowException:
             starting_handle = None
-        for handle in browser.window_handles:
-            browser.switch_to.window(handle)
-            if matcher(self._get_current_window_info(browser)):
+        for handle in driver.window_handles:
+            driver.switch_to.window(handle)
+            if matcher(self._get_current_window_info(driver)):
                 return
         if starting_handle:
-            browser.switch_to.window(starting_handle)
+            driver.switch_to.window(starting_handle)
         raise WindowNotFound(error)
 
-    def _get_current_window_info(self, browser):
+    def _get_current_window_info(self, driver):
         try:
-            id, name = browser.execute_script("return [ window.id, window.name ];")
+            id, name = driver.execute_script("return [ window.id, window.name ];")
         except WebDriverException:
             # The webdriver implementation doesn't support Javascript so we
             # can't get window id or name this way.
             id = name = None
-        return WindowInfo(browser.current_window_handle,
+        return WindowInfo(driver.current_window_handle,
                           id if id is not None else 'undefined',
                           name or 'undefined',
-                          browser.title or 'undefined',
-                          browser.current_url or 'undefined')
+                          driver.title or 'undefined',
+                          driver.current_url or 'undefined')
diff --git a/test/unit/keywords/test_browsermanagement.py b/test/unit/keywords/test_browsermanagement.py
index 81e3d4d94..9ec7e82f6 100644
--- a/test/unit/keywords/test_browsermanagement.py
+++ b/test/unit/keywords/test_browsermanagement.py
@@ -97,17 +97,17 @@ def test_capabilities_attribute_not_modified(self):
     def test_set_selenium_timeout_only_affects_open_browsers(self):
         ctx = mock()
         ctx.timeout = 5.0
-        _browsers = mock()
-        ctx._browsers = _browsers
+        _drivers = mock()
+        ctx._drivers = _drivers
         first_browser, second_browser = mock(), mock()
-        when(_browsers).get_open_browsers().thenReturn(
+        when(_drivers).get_open_drivers().thenReturn(
             [first_browser, second_browser]
         )
         bm = BrowserManagementKeywords(ctx)
         bm.set_selenium_timeout("10 seconds")
         verify(first_browser).set_script_timeout(10.0)
         verify(second_browser).set_script_timeout(10.0)
-        when(_browsers).get_open_browsers().thenReturn(
+        when(_drivers).get_open_drivers().thenReturn(
             []
         )
         bm.set_selenium_timeout("20 seconds")
@@ -131,15 +131,15 @@ def test_create_webdriver(self):
         driver = mock()
         when(FakeWebDriver).__call__(some_arg=1).thenReturn(driver)
         when(FakeWebDriver).__call__(some_arg=2).thenReturn(driver)
-        when(ctx).register_browser(driver, 'fake1').thenReturn(0)
+        when(ctx).register_driver(driver, 'fake1').thenReturn(0)
         webdriver.FakeWebDriver = FakeWebDriver
         try:
             index = bm.create_webdriver('FakeWebDriver', 'fake1', some_arg=1)
-            verify(ctx).register_browser(driver, 'fake1')
+            verify(ctx).register_driver(driver, 'fake1')
             self.assertEqual(index, 0)
             my_kwargs = {'some_arg': 2}
             bm.create_webdriver('FakeWebDriver', 'fake2', kwargs=my_kwargs)
-            verify(ctx).register_browser(driver, 'fake2')
+            verify(ctx).register_driver(driver, 'fake2')
         finally:
             del webdriver.FakeWebDriver
         unstub()
diff --git a/test/unit/keywords/test_cookie.py b/test/unit/keywords/test_cookie.py
index e995b6238..27cfc83d9 100644
--- a/test/unit/keywords/test_cookie.py
+++ b/test/unit/keywords/test_cookie.py
@@ -9,7 +9,7 @@ class KeywordArgumentsCookieTest(unittest.TestCase):
 
     def setUp(self):
         self.ctx = mock()
-        self.ctx.browser = self.browser = mock()
+        self.ctx.driver = self.driver = mock()
         self.cookie = CookieKeywords(self.ctx)
         self.default_cookie = {'name': 'name', 'value': 'value'}
 
@@ -18,57 +18,57 @@ def tearDown(self):
 
     def test_add_cookie_default(self):
         self.cookie.add_cookie('name', 'value')
-        verify(self.browser).add_cookie(self.default_cookie)
+        verify(self.driver).add_cookie(self.default_cookie)
 
     def test_add_cookie_secure_true(self):
         cookie = self.default_cookie
         cookie['secure'] = True
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure='True')
-        verify(self.browser).add_cookie(cookie)
+        verify(self.driver).add_cookie(cookie)
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure='True_text')
-        verify(self.browser, times=2).add_cookie(cookie)
+        verify(self.driver, times=2).add_cookie(cookie)
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure=True)
-        verify(self.browser, times=3).add_cookie(cookie)
+        verify(self.driver, times=3).add_cookie(cookie)
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure='0')
-        verify(self.browser, times=4).add_cookie(cookie)
+        verify(self.driver, times=4).add_cookie(cookie)
 
     def test_add_cookie_secure_false(self):
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure='None')
-        verify(self.browser).add_cookie(self.default_cookie)
+        verify(self.driver).add_cookie(self.default_cookie)
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure='False')
         cookie = self.default_cookie
         cookie['secure'] = False
-        verify(self.browser).add_cookie(cookie)
+        verify(self.driver).add_cookie(cookie)
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure=0)
-        verify(self.browser, times=2).add_cookie(cookie)
+        verify(self.driver, times=2).add_cookie(cookie)
 
     def test_add_cookie_domain_true(self):
         self.cookie.add_cookie('name', 'value', path='None', domain='MyDomain',
                                secure=None)
         cookie = self.default_cookie
         cookie['domain'] = 'MyDomain'
-        verify(self.browser).add_cookie(cookie)
+        verify(self.driver).add_cookie(cookie)
 
     def test_add_cookie_domain_false(self):
         self.cookie.add_cookie('name', 'value', path='None', domain='None',
                                secure=None)
-        verify(self.browser).add_cookie(self.default_cookie)
+        verify(self.driver).add_cookie(self.default_cookie)
 
     def test_add_cookie_path_true(self):
         self.cookie.add_cookie('name', 'value', path='/foo/bar', domain=None,
                                secure=None)
         cookie = self.default_cookie
         cookie['path'] = '/foo/bar'
-        verify(self.browser).add_cookie(cookie)
+        verify(self.driver).add_cookie(cookie)
 
     def test_add_cookie_path_false(self):
         self.cookie.add_cookie('name', 'value', path='None', domain=None,
                                secure=None)
-        verify(self.browser).add_cookie(self.default_cookie)
+        verify(self.driver).add_cookie(self.default_cookie)
diff --git a/test/unit/keywords/test_keyword_arguments_waiting.py b/test/unit/keywords/test_keyword_arguments_waiting.py
index 557fea397..f05d3caac 100644
--- a/test/unit/keywords/test_keyword_arguments_waiting.py
+++ b/test/unit/keywords/test_keyword_arguments_waiting.py
@@ -9,7 +9,7 @@ class KeywordArgumentsWaitingKeywordsTest(unittest.TestCase):
 
     def setUp(self):
         self.ctx = mock()
-        self.ctx.browser = mock()
+        self.ctx.driver = mock()
         self.ctx.timeout = 0.01
         self.waiting = WaitingKeywords(self.ctx)
 
diff --git a/test/unit/locators/test_elementfinder.py b/test/unit/locators/test_elementfinder.py
index 7d3b02e77..f6bb5cc2c 100644
--- a/test/unit/locators/test_elementfinder.py
+++ b/test/unit/locators/test_elementfinder.py
@@ -62,7 +62,7 @@ class ElementFinderParentTests(unittest.TestCase):
 
     def setUp(self):
         self.ctx = mock()
-        self.ctx.browser = self.browser = mock()
+        self.ctx.driver = self.driver = mock()
         self.finder = ElementFinder(self.ctx)
 
     def tearDown(self):
@@ -193,7 +193,7 @@ class ElementFinderTests(unittest.TestCase):
 
     def setUp(self):
         self.ctx = mock()
-        self.ctx.browser = self.browser = mock()
+        self.ctx.driver = self.driver = mock()
         self.finder = ElementFinder(self.ctx)
 
     def tearDown(self):
@@ -207,18 +207,18 @@ def test_non_exisisting_prefix(self):
 
     def test_find_with_no_tag(self):
         self.finder.find("test1", required=False)
-        verify(self.browser).find_elements_by_xpath("//*[(@id='test1' or "
+        verify(self.driver).find_elements_by_xpath("//*[(@id='test1' or "
                                                          "@name='test1')]")
 
     def test_find_with_explicit_default_strategy(self):
         self.finder.find("default=test1", required=False)
-        verify(self.browser).find_elements_by_xpath("//*[(@id='test1' or "
+        verify(self.driver).find_elements_by_xpath("//*[(@id='test1' or "
                                                          "@name='test1')]")
 
     def test_find_with_explicit_default_strategy_and_equals(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("default=page.do?foo=bar", tag='a', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//a[(@id='page.do?foo=bar' or @name='page.do?foo=bar' or "
             "@href='page.do?foo=bar' or "
             "normalize-space(descendant-or-self::text())='page.do?foo=bar' or "
@@ -226,90 +226,90 @@ def test_find_with_explicit_default_strategy_and_equals(self):
 
     def test_find_with_tag(self):
         self.finder.find("test1", tag='div', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//div[(@id='test1' or @name='test1')]")
 
     def test_find_with_locator_with_apos(self):
         self.finder.find("test '1'", required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//*[(@id=\"test '1'\" or @name=\"test '1'\")]")
 
     def test_find_with_locator_with_quote(self):
         self.finder.find("test \"1\"", required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//*[(@id='test \"1\"' or @name='test \"1\"')]")
 
     def test_find_with_locator_with_quote_and_apos(self):
         self.finder.find("test \"1\" and '2'", required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//*[(@id=concat('test \"1\" and ', \"'\", '2', \"'\", '') "
             "or @name=concat('test \"1\" and ', \"'\", '2', \"'\", ''))]")
 
     def test_find_with_a(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='a', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//a[(@id='test1' or @name='test1' or @href='test1' or "
             "normalize-space(descendant-or-self::text())='test1' or "
             "@href='http://localhost/test1')]")
 
     def test_find_with_link_synonym(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='link', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//a[(@id='test1' or @name='test1' or @href='test1' or "
             "normalize-space(descendant-or-self::text())='test1' or "
             "@href='http://localhost/test1')]")
 
     def test_find_with_img(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='img', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//img[(@id='test1' or @name='test1' or @src='test1' or "
             "@alt='test1' or @src='http://localhost/test1')]")
 
     def test_find_with_image_synonym(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='image', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//img[(@id='test1' or @name='test1' or @src='test1' or "
             "@alt='test1' or @src='http://localhost/test1')]")
 
     def test_find_with_input(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='input', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//input[(@id='test1' or @name='test1' or @value='test1' or "
             "@src='test1' or @src='http://localhost/test1')]")
 
     def test_find_with_radio_button_synonym(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='radio button', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//input[@type='radio' and (@id='test1' or @name='test1' or "
             "@value='test1' or @src='test1' or "
             "@src='http://localhost/test1')]")
 
     def test_find_with_checkbox_synonym(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='checkbox', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//input[@type='checkbox' and (@id='test1' or @name='test1' or "
             "@value='test1' or @src='test1' or "
             "@src='http://localhost/test1')]")
 
     def test_find_with_file_upload_synonym(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='file upload', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//input[@type='file' and (@id='test1' or @name='test1' or "
             "@value='test1' or @src='test1' or "
             "@src='http://localhost/test1')]")
 
     def test_find_with_text_field_synonym(self):
-        self.browser.current_url = "http://localhost/mypage.html"
+        self.driver.current_url = "http://localhost/mypage.html"
         self.finder.find("test1", tag='text field', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//input[@type[. = 'date' or . = 'datetime-local' or . = 'email' or "
             ". = 'month' or . = 'number' or . = 'password' or . = 'search' or "
             ". = 'tel' or . = 'text' or . = 'time' or . = 'url' or . = 'week' or . = 'file'] and "
@@ -318,23 +318,23 @@ def test_find_with_text_field_synonym(self):
 
     def test_find_with_button(self):
         self.finder.find("test1", tag='button', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//button[(@id='test1' or @name='test1' or @value='test1' or "
             "normalize-space(descendant-or-self::text())='test1')]")
 
     def test_find_with_select(self):
         self.finder.find("test1", tag='select', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//select[(@id='test1' or @name='test1')]")
 
     def test_find_with_list_synonym(self):
         self.finder.find("test1", tag='list', required=False)
-        verify(self.browser).find_elements_by_xpath(
+        verify(self.driver).find_elements_by_xpath(
             "//select[(@id='test1' or @name='test1')]")
 
     def test_find_with_implicit_xpath(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_xpath(
+        when(self.driver).find_elements_by_xpath(
             "//*[(@test='1')]").thenReturn(elements)
         result = self.finder.find("//*[(@test='1')]", first_only=False)
         self.assertEqual(result, elements)
@@ -345,9 +345,9 @@ def test_find_with_implicit_xpath(self):
     def test_find_by_identifier(self):
         id_elements = self._make_mock_elements('div', 'a')
         name_elements = self._make_mock_elements('span', 'a')
-        when(self.browser).find_elements_by_id("test1").thenReturn(
+        when(self.driver).find_elements_by_id("test1").thenReturn(
             list(id_elements)).thenReturn(list(id_elements))
-        when(self.browser).find_elements_by_name("test1").thenReturn(
+        when(self.driver).find_elements_by_name("test1").thenReturn(
             list(name_elements)).thenReturn(list(name_elements))
         all_elements = list(id_elements)
         all_elements.extend(name_elements)
@@ -359,7 +359,7 @@ def test_find_by_identifier(self):
 
     def test_find_by_id(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_id("test1").thenReturn(
+        when(self.driver).find_elements_by_id("test1").thenReturn(
             elements)
         result = self.finder.find("id=test1", first_only=False)
         self.assertEqual(result, elements)
@@ -368,7 +368,7 @@ def test_find_by_id(self):
 
     def test_find_by_name(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_name("test1").thenReturn(
+        when(self.driver).find_elements_by_name("test1").thenReturn(
             elements)
         result = self.finder.find("name=test1", first_only=False)
         self.assertEqual(result, elements)
@@ -377,7 +377,7 @@ def test_find_by_name(self):
 
     def test_find_by_xpath(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_xpath(
+        when(self.driver).find_elements_by_xpath(
             "//*[(@test='1')]").thenReturn(elements)
         result = self.finder.find("xpath=//*[(@test='1')]", first_only=False)
         self.assertEqual(result, elements)
@@ -388,7 +388,7 @@ def test_find_by_xpath(self):
     def test_find_by_dom(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
         elems = [elements[1], elements[3]]
-        when(self.browser).execute_script(
+        when(self.driver).execute_script(
             "return document.getElementsByTagName('a');").thenReturn(elems)
         result = self.finder.find("dom=document.getElementsByTagName('a')",
                                   first_only=False)
@@ -396,7 +396,7 @@ def test_find_by_dom(self):
 
     def test_find_by_link_text(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_link_text(
+        when(self.driver).find_elements_by_link_text(
             "my link").thenReturn(elements)
         result = self.finder.find("link=my link", first_only=False)
         self.assertEqual(result, elements)
@@ -405,7 +405,7 @@ def test_find_by_link_text(self):
 
     def test_find_by_partial_link_text(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_partial_link_text(
+        when(self.driver).find_elements_by_partial_link_text(
             "my link").thenReturn(elements)
         result = self.finder.find("partial link=my link", first_only=False)
         self.assertEqual(result, elements)
@@ -415,7 +415,7 @@ def test_find_by_partial_link_text(self):
 
     def test_find_by_css_selector(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_css_selector(
+        when(self.driver).find_elements_by_css_selector(
             "#test1").thenReturn(elements)
         result = self.finder.find("css=#test1", first_only=False)
         self.assertEqual(result, elements)
@@ -424,7 +424,7 @@ def test_find_by_css_selector(self):
 
     def test_find_by_class_names(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_class_name(
+        when(self.driver).find_elements_by_class_name(
             "test1").thenReturn(elements)
         result = self.finder.find("class=test1", first_only=False)
         self.assertEqual(result, elements)
@@ -433,7 +433,7 @@ def test_find_by_class_names(self):
 
     def test_find_by_tag_name(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_tag_name(
+        when(self.driver).find_elements_by_tag_name(
             "div").thenReturn(elements)
         result = self.finder.find("tag=div", first_only=False)
         self.assertEqual(result, elements)
@@ -442,9 +442,9 @@ def test_find_by_tag_name(self):
 
     def test_find_with_sloppy_prefix(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_id("test1").thenReturn(
+        when(self.driver).find_elements_by_id("test1").thenReturn(
             elements)
-        when(self.browser).find_elements_by_partial_link_text(
+        when(self.driver).find_elements_by_partial_link_text(
             "test1").thenReturn(elements)
         result = self.finder.find("ID=test1", first_only=False)
         self.assertEqual(result, elements)
@@ -461,7 +461,7 @@ def test_find_with_sloppy_prefix(self):
 
     def test_find_with_sloppy_criteria(self):
         elements = self._make_mock_elements('div', 'a', 'span', 'a')
-        when(self.browser).find_elements_by_id("test1  ").thenReturn(
+        when(self.driver).find_elements_by_id("test1  ").thenReturn(
             elements)
         result = self.finder.find("id= test1  ", first_only=False)
         self.assertEqual(result, elements)
@@ -475,7 +475,7 @@ def test_find_by_id_with_synonym_and_constraints(self):
         elements[5].set_attribute('type', 'text')
         elements[7].set_attribute('type', 'file')
         elements[8].set_attribute('type', 'email')
-        when(self.browser).find_elements_by_id("test1").thenReturn(
+        when(self.driver).find_elements_by_id("test1").thenReturn(
             elements)
         result = self.finder.find("id=test1", first_only=False)
         self.assertEqual(result, elements)
@@ -504,7 +504,7 @@ def test_find_returns_bad_values(self):
                     'find_elements_by_tag_name')
         for bad_value in (None, {'': None}):
             for func_name in locators:
-                when_find_func = getattr(when(self.browser), func_name)
+                when_find_func = getattr(when(self.driver), func_name)
                 when_find_func(any()).thenReturn(bad_value)
             for locator in ("identifier=it", "id=it", "name=it", "xpath=//div",
                             "link=it", "css=div.it", "tag=div", "default"):
diff --git a/test/unit/locators/test_windowmanager.py b/test/unit/locators/test_windowmanager.py
index 16e5c09ba..d5e0b2ab9 100644
--- a/test/unit/locators/test_windowmanager.py
+++ b/test/unit/locators/test_windowmanager.py
@@ -26,7 +26,7 @@ def test_select_by_title(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("title=Title 2")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
 
     def test_select_by_title_with_multiple_matches(self):
         manager = WindowManagerWithMockBrowser(
@@ -35,7 +35,7 @@ def test_select_by_title_with_multiple_matches(self):
             {'name': 'win2b', 'title': "Title 2", 'url': 'http://localhost/page2b.html'}
         )
         manager.select("title=Title 2")
-        self.assertEqual(manager.browser.current_window.name, 'win2a')
+        self.assertEqual(manager.driver.current_window.name, 'win2a')
 
     def test_select_by_title_no_match(self):
         manager = WindowManagerWithMockBrowser(
@@ -55,7 +55,7 @@ def test_select_by_name(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("name=win2")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
 
     def test_select_by_name_no_match(self):
         manager = WindowManagerWithMockBrowser(
@@ -75,7 +75,7 @@ def test_select_by_url(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("url=http://localhost/page2.html")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
 
     def test_select_by_url_with_multiple_matches(self):
         manager = WindowManagerWithMockBrowser(
@@ -84,7 +84,7 @@ def test_select_by_url_with_multiple_matches(self):
             {'name': 'win2b', 'title': "Title 2b", 'url': 'http://localhost/page2.html'}
         )
         manager.select("url=http://localhost/page2.html")
-        self.assertEqual(manager.browser.current_window.name, 'win2a')
+        self.assertEqual(manager.driver.current_window.name, 'win2a')
 
     def test_select_by_url_no_match(self):
         manager = WindowManagerWithMockBrowser(
@@ -110,7 +110,7 @@ def test_select_with_deprecated_locators_to_select_main_window(self):
             msg = "Using '%s' as window locator is deprecated. Use 'main' instead." % deprecated
             with when(logger).warn(msg).thenReturn(None):
                 manager.select(deprecated)
-            self.assertEqual(manager.browser.current_window.name, 'win1')
+            self.assertEqual(manager.driver.current_window.name, 'win1')
 
     def test_select_main_window(self):
         manager = WindowManagerWithMockBrowser(
@@ -119,11 +119,11 @@ def test_select_main_window(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("name=win2")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
         manager.select("main")
-        self.assertEqual(manager.browser.current_window.name, 'win1')
+        self.assertEqual(manager.driver.current_window.name, 'win1')
         manager.select("MAIN")
-        self.assertEqual(manager.browser.current_window.name, 'win1')
+        self.assertEqual(manager.driver.current_window.name, 'win1')
 
     def test_select_by_default_with_name(self):
         manager = WindowManagerWithMockBrowser(
@@ -132,7 +132,7 @@ def test_select_by_default_with_name(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("win2")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
 
     def test_select_by_default_with_title(self):
         manager = WindowManagerWithMockBrowser(
@@ -141,7 +141,7 @@ def test_select_by_default_with_title(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("Title 2")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
 
     def test_select_by_default_no_match(self):
         manager = WindowManagerWithMockBrowser(
@@ -163,7 +163,7 @@ def test_prefix_is_case_sensitive(self):
             {'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html'}
         )
         manager.select("name=win2")
-        self.assertEqual(manager.browser.current_window.name, 'win2')
+        self.assertEqual(manager.driver.current_window.name, 'win2')
         with self.assertRaises(WindowNotFound) as context:
             manager.select("nAmE=win2")
         self.assertEqual(
@@ -191,17 +191,17 @@ class WindowManagerWithMockBrowser(WindowManager):
 
     def __init__(self, *window_specs):
         ctx = mock()
-        ctx.browser = self._make_mock_browser(*window_specs)
+        ctx.driver = self._make_mock_driver(*window_specs)
         WindowManager.__init__(self, ctx)
 
-    def _make_mock_browser(self, *window_specs):
-        browser = mock()
+    def _make_mock_driver(self, *window_specs):
+        driver = mock()
         current_window = mock()
-        browser.window_handles = []
+        driver.window_handles = []
         window_infos = {}
         for window_spec in window_specs:
             handle = uuid.uuid4().hex
-            browser.window_handles.append(handle)
+            driver.window_handles.append(handle)
             id_ = window_spec.get('id')
             if not id_:
                 id_ = 'undefined'
@@ -214,21 +214,21 @@ def _make_mock_browser(self, *window_specs):
             window_infos[handle] = window_info
 
         def window(handle_):
-            if handle_ in browser.window_handles:
-                browser.session_id = handle_
+            if handle_ in driver.window_handles:
+                driver.session_id = handle_
                 current_window.name = window_infos[handle_][1]
-                browser.current_window = current_window
-                browser.title = window_infos[handle_][2]
-                browser.current_url = window_infos[handle_][3]
+                driver.current_window = current_window
+                driver.title = window_infos[handle_][2]
+                driver.current_url = window_infos[handle_][3]
 
         switch_to = mock()
         switch_to.window = window
-        browser.switch_to = switch_to
+        driver.switch_to = switch_to
 
         def execute_script(script):
-            handle_ = browser.session_id
-            if handle_ in browser.window_handles:
+            handle_ = driver.session_id
+            if handle_ in driver.window_handles:
                 return window_infos[handle_][:2]
 
-        browser.execute_script = execute_script
-        return browser
+        driver.execute_script = execute_script
+        return driver

From d069dfd80ce4d70f83a7f5857f1cac47aae38c9b Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Sun, 15 Oct 2017 02:14:41 +0300
Subject: [PATCH 04/14] Fixing code to pass tests

---
 src/SeleniumLibrary/keywords/browsermanagement.py | 12 ++++++------
 test/acceptance/open_and_close.robot              |  2 +-
 test/resources/testlibs/CustomSeleniumKeywords.py |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/SeleniumLibrary/keywords/browsermanagement.py b/src/SeleniumLibrary/keywords/browsermanagement.py
index 9709fcdb1..f3035ff48 100644
--- a/src/SeleniumLibrary/keywords/browsermanagement.py
+++ b/src/SeleniumLibrary/keywords/browsermanagement.py
@@ -367,8 +367,8 @@ def set_selenium_speed(self, value):
         """
         old_speed = self.get_selenium_speed()
         self.ctx.speed = timestr_to_secs(value)
-        for browser in self.drivers.browsers:
-            self._monkey_patch_speed(browser)
+        for driver in self.drivers.drivers:
+            self._monkey_patch_speed(driver)
         return old_speed
 
     @keyword
@@ -389,8 +389,8 @@ def set_selenium_timeout(self, value):
         """
         old_timeout = self.get_selenium_timeout()
         self.ctx.timeout = timestr_to_secs(value)
-        for browser in self.drivers.get_open_drivers():
-            browser.set_script_timeout(self.ctx.timeout)
+        for driver in self.drivers.get_open_drivers():
+            driver.set_script_timeout(self.ctx.timeout)
         return old_timeout
 
     @keyword
@@ -415,8 +415,8 @@ def set_selenium_implicit_wait(self, value):
         """
         old_wait = self.get_selenium_implicit_wait()
         self.ctx.implicit_wait = timestr_to_secs(value)
-        for browser in self.drivers.get_open_drivers():
-            browser.implicitly_wait(self.ctx.implicit_wait)
+        for driver in self.drivers.get_open_drivers():
+            driver.implicitly_wait(self.ctx.implicit_wait)
         return old_wait
 
     @keyword
diff --git a/test/acceptance/open_and_close.robot b/test/acceptance/open_and_close.robot
index 5fc0bd520..81ee8ee6c 100644
--- a/test/acceptance/open_and_close.robot
+++ b/test/acceptance/open_and_close.robot
@@ -16,7 +16,7 @@ Browser Open With Implicit Wait Should Not Override Default
 
 There Should Be A Good Error Message If Browser Is Not Opened
     [Documentation]    Tests error message
-    Run Keyword And Expect Error    No browser is open    Title Should Be    foo
+    Run Keyword And Expect Error    No driver is open    Title Should Be    foo
 
 Close Browser Does Nothing When No Browser Is Opened
     [Documentation]    Close already closed browser
diff --git a/test/resources/testlibs/CustomSeleniumKeywords.py b/test/resources/testlibs/CustomSeleniumKeywords.py
index c8469ee1f..ba1b0d4fe 100755
--- a/test/resources/testlibs/CustomSeleniumKeywords.py
+++ b/test/resources/testlibs/CustomSeleniumKeywords.py
@@ -12,7 +12,7 @@ def __init__(self, *args, **kwargs):
         `Run On Failure Keyword Only Called Once` test."""
         super(CustomSeleniumKeywords, self).__init__(*args, **kwargs)
         sl = BuiltIn().get_library_instance("SeleniumLibrary")
-        self._browsers = sl._browsers
+        self._drivers = sl._drivers
 
     @keyword
     def custom_selenium_keyword(self):

From 97ebf3a65a6806b5aa2ed3c4084d4df0ad339d06 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Tue, 31 Oct 2017 23:03:40 +0200
Subject: [PATCH 05/14] Renamed DriverCache to WebDriverCache

---
 src/SeleniumLibrary/__init__.py                  | 16 ++++++++--------
 src/SeleniumLibrary/base/context.py              |  4 ++--
 .../keywords/browsermanagement.py                | 16 ++++++++--------
 src/SeleniumLibrary/keywords/frames.py           |  8 ++++----
 src/SeleniumLibrary/keywords/window.py           | 16 ++++++++--------
 src/SeleniumLibrary/utils/__init__.py            |  2 +-
 .../utils/{drivercache.py => webdrivercache.py}  |  2 +-
 .../resources/testlibs/CustomSeleniumKeywords.py |  2 +-
 test/unit/keywords/test_browsermanagement.py     | 10 ++++------
 ...est_drivercache.py => test_webdrivercache.py} | 14 +++++++-------
 10 files changed, 44 insertions(+), 46 deletions(-)
 rename src/SeleniumLibrary/utils/{drivercache.py => webdrivercache.py} (97%)
 rename test/unit/utils/{test_drivercache.py => test_webdrivercache.py} (88%)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 8cee36ccd..25d1a5944 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -34,8 +34,8 @@
                                       WaitingKeywords,
                                       WindowKeywords)
 from SeleniumLibrary.locators import ElementFinder, TableElementFinder
-from SeleniumLibrary.utils import (Deprecated, DriverCache, LibraryListener,
-                                   timestr_to_secs)
+from SeleniumLibrary.utils import (Deprecated, LibraryListener, timestr_to_secs,
+                                   WebDriverCache)
 
 
 __version__ = '3.0.0b4.dev1'
@@ -342,7 +342,7 @@ def __init__(self, timeout=5.0, implicit_wait=0.0,
             WaitingKeywords(self),
             WindowKeywords(self)
         ]
-        self._drivers = DriverCache()
+        self._webdrivers = WebDriverCache()
         DynamicCore.__init__(self, libraries)
         self.ROBOT_LIBRARY_LISTENER = LibraryListener()
         self._element_finder = ElementFinder(self)
@@ -363,7 +363,7 @@ def run_keyword(self, name, args, kwargs):
             raise
 
     def register_driver(self, driver, alias):
-        return self._drivers.register(driver, alias)
+        return self._webdrivers.register(driver, alias)
 
     def failure_occurred(self):
         """Method that is executed when a SeleniumLibrary keyword fails.
@@ -386,9 +386,9 @@ def failure_occurred(self):
     @property
     def driver(self):
         """Current active driver"""
-        if not self._drivers.current:
+        if not self._webdrivers.current:
             raise RuntimeError('No driver is open')
-        return self._drivers.current
+        return self._webdrivers.current
 
     def find_element(self, locator, parent=None):
         """Find element matching ``locator``.
@@ -423,9 +423,9 @@ def _cache(self):
 
     def _current_browser(self):
         warnings.warn('"SeleniumLibrary._current_browser" is deprecated, '
-                      'use "SeleniumLibrary.browser" instead.',
+                      'use "SeleniumLibrary.driver" instead.',
                       DeprecationWarning)
-        return self.browser
+        return self.driver
 
     def _run_on_failure(self):
         warnings.warn('"SeleniumLibrary._run_on_failure" is deprecated, '
diff --git a/src/SeleniumLibrary/base/context.py b/src/SeleniumLibrary/base/context.py
index bfed50031..1712a2a84 100644
--- a/src/SeleniumLibrary/base/context.py
+++ b/src/SeleniumLibrary/base/context.py
@@ -32,8 +32,8 @@ def driver(self):
         return self.ctx.driver
 
     @property
-    def drivers(self):
-        return self.ctx._drivers
+    def webdrivers(self):
+        return self.ctx._webdrivers
 
     @property
     def element_finder(self):
diff --git a/src/SeleniumLibrary/keywords/browsermanagement.py b/src/SeleniumLibrary/keywords/browsermanagement.py
index f3035ff48..8bb57ebc6 100644
--- a/src/SeleniumLibrary/keywords/browsermanagement.py
+++ b/src/SeleniumLibrary/keywords/browsermanagement.py
@@ -65,15 +65,15 @@ def close_all_browsers(self):
         all browsers are closed.
         """
         self.debug('Closing all browsers.')
-        self.drivers.close_all()
+        self.webdrivers.close_all()
 
     @keyword
     def close_browser(self):
         """Closes the current browser."""
-        if self.drivers.current:
+        if self.webdrivers.current:
             self.debug('Closing browser with session id {}.'
                        .format(self.driver.session_id))
-            self.drivers.close()
+            self.webdrivers.close()
 
     @keyword
     def open_browser(self, url, browser='firefox', alias=None,
@@ -230,7 +230,7 @@ def switch_browser(self, index_or_alias):
         | `Switch Browser`   | ${index}       |                   |
         """
         try:
-            self.drivers.switch(index_or_alias)
+            self.webdrivers.switch(index_or_alias)
         except RuntimeError:
             raise RuntimeError("No browser with index or alias '%s' found."
                                % index_or_alias)
@@ -250,7 +250,7 @@ def get_title(self):
     @keyword
     def get_location(self):
         """Returns the current browser URL."""
-        return self.browser.current_url
+        return self.driver.current_url
 
     @keyword
     def location_should_be(self, url):
@@ -367,7 +367,7 @@ def set_selenium_speed(self, value):
         """
         old_speed = self.get_selenium_speed()
         self.ctx.speed = timestr_to_secs(value)
-        for driver in self.drivers.drivers:
+        for driver in self.webdrivers.drivers:
             self._monkey_patch_speed(driver)
         return old_speed
 
@@ -389,7 +389,7 @@ def set_selenium_timeout(self, value):
         """
         old_timeout = self.get_selenium_timeout()
         self.ctx.timeout = timestr_to_secs(value)
-        for driver in self.drivers.get_open_drivers():
+        for driver in self.webdrivers.get_open_drivers():
             driver.set_script_timeout(self.ctx.timeout)
         return old_timeout
 
@@ -415,7 +415,7 @@ def set_selenium_implicit_wait(self, value):
         """
         old_wait = self.get_selenium_implicit_wait()
         self.ctx.implicit_wait = timestr_to_secs(value)
-        for driver in self.drivers.get_open_drivers():
+        for driver in self.webdrivers.get_open_drivers():
             driver.implicitly_wait(self.ctx.implicit_wait)
         return old_wait
 
diff --git a/src/SeleniumLibrary/keywords/frames.py b/src/SeleniumLibrary/keywords/frames.py
index de62e1b2e..e7a518b6d 100644
--- a/src/SeleniumLibrary/keywords/frames.py
+++ b/src/SeleniumLibrary/keywords/frames.py
@@ -37,7 +37,7 @@ def select_frame(self, locator):
         """
         self.info("Selecting frame '%s'." % locator)
         element = self.find_element(locator)
-        self.browser.switch_to.frame(element)
+        self.driver.switch_to.frame(element)
 
     @keyword
     def unselect_frame(self):
@@ -45,7 +45,7 @@ def unselect_frame(self):
 
         In practice cancels the previous `Select Frame` call.
         """
-        self.browser.switch_to.default_content()
+        self.driver.switch_to.default_content()
 
     @keyword
     def current_frame_should_contain(self, text, loglevel='INFO'):
@@ -99,9 +99,9 @@ def frame_should_contain(self, locator, text, loglevel='INFO'):
 
     def _frame_contains(self, locator, text):
         element = self.find_element(locator)
-        self.browser.switch_to.frame(element)
+        self.driver.switch_to.frame(element)
         self.info("Searching for text from frame '%s'." % locator)
         found = self.is_text_present(text)
-        self.browser.switch_to.default_content()
+        self.driver.switch_to.default_content()
         return found
 
diff --git a/src/SeleniumLibrary/keywords/window.py b/src/SeleniumLibrary/keywords/window.py
index 654d3732d..df82e60ee 100644
--- a/src/SeleniumLibrary/keywords/window.py
+++ b/src/SeleniumLibrary/keywords/window.py
@@ -97,7 +97,7 @@ def select_window(self, locator='MAIN'):
           and URL was case-insensitive.
         """
         try:
-            return self.browser.current_window_handle
+            return self.driver.current_window_handle
         except NoSuchWindowException:
             pass
         finally:
@@ -106,7 +106,7 @@ def select_window(self, locator='MAIN'):
     @keyword
     def close_window(self):
         """Closes currently opened pop-up window."""
-        self.browser.close()
+        self.driver.close()
 
     @keyword
     def get_window_handles(self):
@@ -116,7 +116,7 @@ def get_window_handles(self):
 
         Prior to SeleniumLibrary 3.0, this keyword was named `List Windows`.
         """
-        return self.browser.window_handles
+        return self.driver.window_handles
 
     @keyword
     def list_windows(self):
@@ -150,7 +150,7 @@ def get_locations(self):
     @keyword
     def maximize_browser_window(self):
         """Maximizes current browser window."""
-        self.browser.maximize_window()
+        self.driver.maximize_window()
 
     @keyword
     def get_window_size(self):
@@ -161,7 +161,7 @@ def get_window_size(self):
         Example:
         | ${width} | ${height}= | `Get Window Size` |
         """
-        size = self.browser.get_window_size()
+        size = self.driver.get_window_size()
         return size['width'], size['height']
 
     @keyword
@@ -178,7 +178,7 @@ def set_window_size(self, width, height):
         Example:
         | `Set Window Size` | 800 | 600 |
         """
-        return self.browser.set_window_size(int(width), int(height))
+        return self.driver.set_window_size(int(width), int(height))
 
     @keyword
     def get_window_position(self):
@@ -190,7 +190,7 @@ def get_window_position(self):
         Example:
         | ${x} | ${y}= | `Get Window Position` |
         """
-        position = self.browser.get_window_position()
+        position = self.driver.get_window_position()
         return position['x'], position['y']
 
     @keyword
@@ -208,7 +208,7 @@ def set_window_position(self, x, y):
         Example:
         | `Set Window Position` | 100 | 200 |
         """
-        self.browser.set_window_position(int(x), int(y))
+        self.driver.set_window_position(int(x), int(y))
 
     def _log_list(self, items, what='item'):
         msg = [
diff --git a/src/SeleniumLibrary/utils/__init__.py b/src/SeleniumLibrary/utils/__init__.py
index 6e6cccdcc..8b7cb214a 100644
--- a/src/SeleniumLibrary/utils/__init__.py
+++ b/src/SeleniumLibrary/utils/__init__.py
@@ -17,10 +17,10 @@
 from robot.utils import plural_or_not, secs_to_timestr, timestr_to_secs
 
 from .deprecated import Deprecated
-from .drivercache import DriverCache
 from .librarylistener import LibraryListener
 from .seleniumversion import SELENIUM_VERSION
 from .types import is_falsy, is_noney, is_string, is_truthy
+from .webdrivercache import WebDriverCache
 
 
 def escape_xpath_value(value):
diff --git a/src/SeleniumLibrary/utils/drivercache.py b/src/SeleniumLibrary/utils/webdrivercache.py
similarity index 97%
rename from src/SeleniumLibrary/utils/drivercache.py
rename to src/SeleniumLibrary/utils/webdrivercache.py
index c53847958..1b0a209a5 100644
--- a/src/SeleniumLibrary/utils/drivercache.py
+++ b/src/SeleniumLibrary/utils/webdrivercache.py
@@ -17,7 +17,7 @@
 from robot.utils import ConnectionCache
 
 
-class DriverCache(ConnectionCache):
+class WebDriverCache(ConnectionCache):
 
     def __init__(self):
         ConnectionCache.__init__(self, no_current_msg='No current driver')
diff --git a/test/resources/testlibs/CustomSeleniumKeywords.py b/test/resources/testlibs/CustomSeleniumKeywords.py
index ba1b0d4fe..2e80c6369 100755
--- a/test/resources/testlibs/CustomSeleniumKeywords.py
+++ b/test/resources/testlibs/CustomSeleniumKeywords.py
@@ -12,7 +12,7 @@ def __init__(self, *args, **kwargs):
         `Run On Failure Keyword Only Called Once` test."""
         super(CustomSeleniumKeywords, self).__init__(*args, **kwargs)
         sl = BuiltIn().get_library_instance("SeleniumLibrary")
-        self._drivers = sl._drivers
+        self._webdrivers = sl._webdrivers
 
     @keyword
     def custom_selenium_keyword(self):
diff --git a/test/unit/keywords/test_browsermanagement.py b/test/unit/keywords/test_browsermanagement.py
index 9ec7e82f6..78a02d78a 100644
--- a/test/unit/keywords/test_browsermanagement.py
+++ b/test/unit/keywords/test_browsermanagement.py
@@ -97,19 +97,17 @@ def test_capabilities_attribute_not_modified(self):
     def test_set_selenium_timeout_only_affects_open_browsers(self):
         ctx = mock()
         ctx.timeout = 5.0
-        _drivers = mock()
-        ctx._drivers = _drivers
+        _webdrivers = mock()
+        ctx._webdrivers = _webdrivers
         first_browser, second_browser = mock(), mock()
-        when(_drivers).get_open_drivers().thenReturn(
+        when(_webdrivers).get_open_drivers().thenReturn(
             [first_browser, second_browser]
         )
         bm = BrowserManagementKeywords(ctx)
         bm.set_selenium_timeout("10 seconds")
         verify(first_browser).set_script_timeout(10.0)
         verify(second_browser).set_script_timeout(10.0)
-        when(_drivers).get_open_drivers().thenReturn(
-            []
-        )
+        when(_webdrivers).get_open_drivers().thenReturn([])
         bm.set_selenium_timeout("20 seconds")
         verifyNoMoreInteractions(first_browser)
         verifyNoMoreInteractions(second_browser)
diff --git a/test/unit/utils/test_drivercache.py b/test/unit/utils/test_webdrivercache.py
similarity index 88%
rename from test/unit/utils/test_drivercache.py
rename to test/unit/utils/test_webdrivercache.py
index cf47076ad..965dac9c0 100644
--- a/test/unit/utils/test_drivercache.py
+++ b/test/unit/utils/test_webdrivercache.py
@@ -2,20 +2,20 @@
 
 from mockito import mock, verify
 
-from SeleniumLibrary.utils import DriverCache
+from SeleniumLibrary.utils import WebDriverCache
 
 
-class DriverCacheTests(unittest.TestCase):
+class WebDriverCacheTests(unittest.TestCase):
 
     def test_no_current_message(self):
-        cache = DriverCache()
+        cache = WebDriverCache()
         try:
             self.assertRaises(RuntimeError, cache.current.anyMember())
         except RuntimeError as e:
             self.assertEqual(str(e), "No current driver")
 
     def test_browsers_property(self):
-        cache = DriverCache()
+        cache = WebDriverCache()
 
         driver1 = mock()
         driver2 = mock()
@@ -34,7 +34,7 @@ def test_browsers_property(self):
         self.assertEqual(index3, 3)
 
     def test_get_open_browsers(self):
-        cache = DriverCache()
+        cache = WebDriverCache()
 
         driver1 = mock()
         driver2 = mock()
@@ -57,7 +57,7 @@ def test_get_open_browsers(self):
         self.assertEqual(drivers[1], driver2)
 
     def test_close(self):
-        cache = DriverCache()
+        cache = WebDriverCache()
         browser = mock()
         cache.register(browser)
 
@@ -66,7 +66,7 @@ def test_close(self):
         verify(browser, times=1).quit()
 
     def test_close_only_called_once(self):
-        cache = DriverCache()
+        cache = WebDriverCache()
 
         browser1 = mock()
         browser2 = mock()

From 5d5bf70b06657d9ab7a83d22faedbcf278354878 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Tue, 31 Oct 2017 23:40:29 +0200
Subject: [PATCH 06/14] Added documentation for driver public API.

Also created public API browser for RC1 to support early adopters.
---
 src/SeleniumLibrary/__init__.py | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 25d1a5944..090b30ba3 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -385,11 +385,22 @@ def failure_occurred(self):
 
     @property
     def driver(self):
-        """Current active driver"""
+        """Current active driver
+
+        :rtype: selenium.webdriver.remote.webdriver.WebDriver
+        :raises RuntimeError if driver is not created
+        """
         if not self._webdrivers.current:
             raise RuntimeError('No driver is open')
         return self._webdrivers.current
 
+    @property
+    def browser(self):
+        # TODO: Remove after 3.0 RC1 release.
+        warnings.warn('"SeleniumLibrary.browser" is deprecated, '
+                      'use "SeleniumLibrary.driver".', DeprecationWarning)
+        return self.driver
+
     def find_element(self, locator, parent=None):
         """Find element matching ``locator``.
 

From d860a0561260165c51ab5aec2bd4b8a4f474b279 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Tue, 31 Oct 2017 23:42:45 +0200
Subject: [PATCH 07/14] Refactoring BrowserManagementKeywords browser -> driver

Contains changes in the internal variables and method names.
---
 .../keywords/browsermanagement.py             | 120 +++++++++---------
 test/unit/keywords/test_browsermanagement.py  |   4 +-
 ...est_keyword_arguments_browsermanagement.py |   8 +-
 3 files changed, 69 insertions(+), 63 deletions(-)

diff --git a/src/SeleniumLibrary/keywords/browsermanagement.py b/src/SeleniumLibrary/keywords/browsermanagement.py
index 8bb57ebc6..49840bda6 100644
--- a/src/SeleniumLibrary/keywords/browsermanagement.py
+++ b/src/SeleniumLibrary/keywords/browsermanagement.py
@@ -141,8 +141,8 @@ def open_browser(self, url, browser='firefox', alias=None,
         else:
             self.info("Opening browser '%s' to base url '%s'." % (browser, url))
         browser_name = browser
-        driver = self._make_browser(browser_name, desired_capabilities,
-                                    ff_profile_dir, remote_url)
+        driver = self._make_driver(browser_name, desired_capabilities,
+                                   ff_profile_dir, remote_url)
         try:
             driver.get(url)
         except Exception:
@@ -428,22 +428,22 @@ def set_browser_implicit_wait(self, value):
         """
         self.driver.implicitly_wait(timestr_to_secs(value))
 
-    def _get_browser_creation_function(self, browser_name):
+    def _get_driver_creation_function(self, browser_name):
         try:
             func_name = BROWSER_NAMES[browser_name]
         except KeyError:
             raise ValueError(browser_name + " is not a supported browser.")
         return getattr(self, func_name)
 
-    def _make_browser(self, browser_name, desired_capabilities=None,
-                      profile_dir=None, remote=None):
-        creation_func = self._get_browser_creation_function(browser_name)
-        browser = creation_func(remote, desired_capabilities, profile_dir)
-        browser.set_script_timeout(self.ctx.timeout)
-        browser.implicitly_wait(self.ctx.implicit_wait)
+    def _make_driver(self, browser_name, desired_capabilities=None,
+                     profile_dir=None, remote=None):
+        creation_func = self._get_driver_creation_function(browser_name)
+        driver = creation_func(remote, desired_capabilities, profile_dir)
+        driver.set_script_timeout(self.ctx.timeout)
+        driver.implicitly_wait(self.ctx.implicit_wait)
         if self.ctx.speed:
-            self._monkey_patch_speed(browser)
-        return browser
+            self._monkey_patch_speed(driver)
+        return driver
 
     def _make_ff(self, remote, desired_capabilities, profile_dir):
         if is_falsy(profile_dir):
@@ -451,78 +451,87 @@ def _make_ff(self, remote, desired_capabilities, profile_dir):
         else:
             profile = webdriver.FirefoxProfile(profile_dir)
         if is_truthy(remote):
-            browser = self._create_remote_web_driver(
+            driver = self._create_remote_web_driver(
                 webdriver.DesiredCapabilities.FIREFOX, remote,
                 desired_capabilities, profile)
         else:
-            browser = webdriver.Firefox(firefox_profile=profile,
-                                        **self._geckodriver_log_config)
-        return browser
+            driver = webdriver.Firefox(firefox_profile=profile,
+                                       **self._geckodriver_log_config)
+        return driver
 
     def _make_ie(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Ie,
-                webdriver.DesiredCapabilities.INTERNETEXPLORER, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Ie, webdriver.DesiredCapabilities.INTERNETEXPLORER,
+            remote, desired_capabilities)
 
     def _make_chrome(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Chrome,
-                webdriver.DesiredCapabilities.CHROME, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Chrome, webdriver.DesiredCapabilities.CHROME, remote,
+            desired_capabilities)
 
     def _make_opera(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Opera,
-                webdriver.DesiredCapabilities.OPERA, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Opera, webdriver.DesiredCapabilities.OPERA, remote,
+            desired_capabilities)
 
     def _make_phantomjs(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.PhantomJS,
-                webdriver.DesiredCapabilities.PHANTOMJS, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.PhantomJS, webdriver.DesiredCapabilities.PHANTOMJS,
+            remote, desired_capabilities)
 
     def _make_htmlunit(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Remote,
-                webdriver.DesiredCapabilities.HTMLUNIT, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Remote, webdriver.DesiredCapabilities.HTMLUNIT, remote,
+            desired_capabilities)
 
     def _make_htmlunitwithjs(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Remote,
-                webdriver.DesiredCapabilities.HTMLUNITWITHJS, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Remote, webdriver.DesiredCapabilities.HTMLUNITWITHJS,
+            remote, desired_capabilities)
 
     def _make_android(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Remote,
-                webdriver.DesiredCapabilities.ANDROID, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Remote, webdriver.DesiredCapabilities.ANDROID, remote,
+            desired_capabilities)
 
     def _make_iphone(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Remote,
-                webdriver.DesiredCapabilities.IPHONE, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Remote, webdriver.DesiredCapabilities.IPHONE, remote,
+            desired_capabilities)
 
     def _make_safari(self, remote, desired_capabilities, profile_dir):
-        return self._generic_make_browser(webdriver.Safari,
-                webdriver.DesiredCapabilities.SAFARI, remote, desired_capabilities)
+        return self._generic_make_driver(
+            webdriver.Safari, webdriver.DesiredCapabilities.SAFARI, remote,
+            desired_capabilities)
 
     def _make_edge(self, remote, desired_capabilities, profile_dir):
-        if hasattr(webdriver, 'Edge'):
-            return self._generic_make_browser(webdriver.Edge,
-                webdriver.DesiredCapabilities.EDGE, remote, desired_capabilities)
-        else:
-            raise ValueError("Edge is not a supported browser with your version of Selenium python library. Please, upgrade to minimum required version 2.47.0.")
+        return self._generic_make_driver(
+            webdriver.Edge, webdriver.DesiredCapabilities.EDGE, remote,
+            desired_capabilities)
 
-    def _generic_make_browser(self, webdriver_type , desired_cap_type, remote_url, desired_caps):
-        '''most of the make browser functions just call this function which creates the
-        appropriate web-driver'''
+    def _generic_make_driver(self, webdriver_type, desired_cap_type,
+                             remote_url, desired_caps):
+        """Generic driver creation
+
+        Most of the make driver functions just call this function which
+        creates the appropriate driver
+        """
         if is_falsy(remote_url):
-            browser = webdriver_type()
+            driver = webdriver_type()
         else:
-            browser = self._create_remote_web_driver(desired_cap_type,
-                                                     remote_url, desired_caps)
-        return browser
+            driver = self._create_remote_web_driver(desired_cap_type,
+                                                    remote_url, desired_caps)
+        return driver
 
-    def _create_remote_web_driver(self, capabilities_type, remote_url, desired_capabilities=None, profile=None):
+    def _create_remote_web_driver(self, capabilities_type, remote_url,
+                                  desired_capabilities=None, profile=None):
         '''parses the string based desired_capabilities if neccessary and
         creates the associated remote web driver'''
 
         desired_capabilities_object = capabilities_type.copy()
-
         if not isinstance(desired_capabilities, dict):
             desired_capabilities = self._parse_capabilities_string(desired_capabilities)
-
         desired_capabilities_object.update(desired_capabilities or {})
-
         return webdriver.Remote(desired_capabilities=desired_capabilities_object,
                 command_executor=str(remote_url), browser_profile=profile)
 
@@ -541,20 +550,17 @@ def _parse_capabilities_string(self, capabilities_string):
 
         return desired_capabilities
 
-    def _get_speed(self, browser):
-        return browser._speed if hasattr(browser, '_speed') else 0.0
-
-    def _monkey_patch_speed(self, browser):
+    def _monkey_patch_speed(self, driver):
         def execute(self, driver_command, params=None):
             result = self._base_execute(driver_command, params)
             speed = self._speed if hasattr(self, '_speed') else 0.0
             if speed > 0:
                 time.sleep(speed)
             return result
-        if not hasattr(browser, '_base_execute'):
-            browser._base_execute = browser.execute
-            browser.execute = types.MethodType(execute, browser)
-        browser._speed = self.ctx.speed
+        if not hasattr(driver, '_base_execute'):
+            driver._base_execute = driver.execute
+            driver.execute = types.MethodType(execute, driver)
+        driver._speed = self.ctx.speed
 
     @property
     def _geckodriver_log_config(self):
diff --git a/test/unit/keywords/test_browsermanagement.py b/test/unit/keywords/test_browsermanagement.py
index 78a02d78a..c46e16a29 100644
--- a/test/unit/keywords/test_browsermanagement.py
+++ b/test/unit/keywords/test_browsermanagement.py
@@ -117,7 +117,7 @@ def test_bad_browser_name(self):
         ctx = mock()
         bm = BrowserManagementKeywords(ctx)
         try:
-            bm._make_browser("fireox")
+            bm._make_driver("fireox")
             self.fail("Exception not raised")
         except ValueError as e:
             self.assertEquals(str(e), "fireox is not a supported browser.")
@@ -171,7 +171,7 @@ def verify_browser(self, webdriver_type, browser_name, **kw):
 
         try:
             self.was_called = False
-            bm._make_browser(browser_name, **kw)
+            bm._make_driver(browser_name, **kw)
         except AttributeError:
             pass  #kinda dangerous but I'm too lazy to mock out all the set_timeout calls
         finally:
diff --git a/test/unit/keywords/test_keyword_arguments_browsermanagement.py b/test/unit/keywords/test_keyword_arguments_browsermanagement.py
index b20a023f5..516a8c402 100644
--- a/test/unit/keywords/test_keyword_arguments_browsermanagement.py
+++ b/test/unit/keywords/test_keyword_arguments_browsermanagement.py
@@ -19,13 +19,13 @@ def test_open_browser(self):
         url = 'https://github.com/robotframework'
         remote_url = '"http://localhost:4444/wd/hub"'
         browser = mock()
-        when(self.brorser)._make_browser('firefox', None,
-                                         None, False).thenReturn(browser)
+        when(self.brorser)._make_driver('firefox', None,
+                                        None, False).thenReturn(browser)
         alias = self.brorser.open_browser(url)
         self.assertEqual(alias, None)
 
-        when(self.brorser)._make_browser('firefox', None,
-                                         None, remote_url).thenReturn(browser)
+        when(self.brorser)._make_driver('firefox', None,
+                                        None, remote_url).thenReturn(browser)
         alias = self.brorser.open_browser(url, alias='None',
                                           remote_url=remote_url)
         self.assertEqual(alias, None)

From 72093285c6d17f178fefe2a3377fb58b73710b70 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Wed, 1 Nov 2017 22:32:26 +0200
Subject: [PATCH 08/14] Refactor WindowManager to use self.driver

The WindowManager used to pass driver between methods. Now the
methods use self.driver, instead of passing the diver as argument.
---
 src/SeleniumLibrary/locators/windowmanager.py |  76 +++++++------
 .../test_windowmananger_window_info.py        | 100 +++++++-----------
 2 files changed, 76 insertions(+), 100 deletions(-)

diff --git a/src/SeleniumLibrary/locators/windowmanager.py b/src/SeleniumLibrary/locators/windowmanager.py
index e92c85713..a5e4305e3 100644
--- a/src/SeleniumLibrary/locators/windowmanager.py
+++ b/src/SeleniumLibrary/locators/windowmanager.py
@@ -55,7 +55,7 @@ def get_window_infos(self):
         try:
             for handle in self.driver.window_handles:
                 self.driver.switch_to.window(handle)
-                infos.append(self._get_current_window_info(self.driver))
+                infos.append(self._get_current_window_info())
         finally:
             if starting_handle:
                 self.driver.switch_to.window(starting_handle)
@@ -64,16 +64,16 @@ def get_window_infos(self):
     def select(self, locator):
         locator = self._handle_deprecated_locators(locator)
         if not is_string(locator):
-            self._select_by_excludes(self.driver, locator)
+            self._select_by_excludes(locator)
         elif locator.upper() == 'CURRENT':
             pass
         elif locator.upper() == 'MAIN':
-            self._select_main_window(self.driver)
+            self._select_main_window()
         elif locator.upper() == 'NEW':
-            self._select_by_last_index(self.driver)
+            self._select_by_last_index()
         else:
             strategy, locator = self._parse_locator(locator)
-            self._strategies[strategy](self.driver, locator)
+            self._strategies[strategy](locator)
 
     def _handle_deprecated_locators(self, locator):
         if not (is_string(locator) or locator is None):
@@ -91,7 +91,7 @@ def _parse_locator(self, locator):
         if index != -1:
             prefix = locator[:index].strip()
             if prefix in self._strategies:
-                return prefix, locator[index+1:].lstrip()
+                return prefix, locator[index + 1:].lstrip()
         return 'default', locator
 
     def _get_locator_separator_index(self, locator):
@@ -101,85 +101,83 @@ def _get_locator_separator_index(self, locator):
             return locator.find('=')
         return min(locator.find('='), locator.find(':'))
 
-    def _select_by_title(self, driver, title):
+    def _select_by_title(self, title):
         self._select_matching(
-            driver,
             lambda window_info: window_info.title == title,
             "Unable to locate window with title '%s'." % title
         )
 
-    def _select_by_name(self, driver, name):
+    def _select_by_name(self, name):
         self._select_matching(
-            driver,
             lambda window_info: window_info.name == name,
             "Unable to locate window with name '%s'." % name
         )
 
-    def _select_by_url(self, driver, url):
+    def _select_by_url(self, url):
         self._select_matching(
-            driver,
             lambda window_info: window_info.url == url,
             "Unable to locate window with URL '%s'." % url
         )
 
-    def _select_main_window(self, driver):
-        handles = driver.window_handles
-        driver.switch_to.window(handles[0])
+    def _select_main_window(self):
+        handles = self.driver.window_handles
+        self.driver.switch_to.window(handles[0])
 
-    def _select_by_default(self, driver, criteria):
+    def _select_by_default(self, criteria):
         try:
-            starting_handle = driver.current_window_handle
+            starting_handle = self.driver.current_window_handle
         except NoSuchWindowException:
             starting_handle = None
-        for handle in driver.window_handles:
-            driver.switch_to.window(handle)
+        for handle in self.driver.window_handles:
+            self.driver.switch_to.window(handle)
             if criteria == handle:
                 return
-            for item in self._get_current_window_info(driver)[2:4]:
+            for item in self._get_current_window_info()[2:4]:
                 if item == criteria:
                     return
         if starting_handle:
-            driver.switch_to.window(starting_handle)
+            self.driver.switch_to.window(starting_handle)
         raise WindowNotFound("No window matching handle, name, title or URL "
                              "'%s' found." % criteria)
 
-    def _select_by_last_index(self, driver):
-        handles = driver.window_handles
-        if handles[-1] == driver.current_window_handle:
+    def _select_by_last_index(self):
+        handles = self.driver.window_handles
+        if handles[-1] == self.driver.current_window_handle:
             raise WindowNotFound('Window with last index is same as '
                                  'the current window.')
-        driver.switch_to.window(handles[-1])
+        self.driver.switch_to.window(handles[-1])
 
-    def _select_by_excludes(self, driver, excludes):
-        for handle in driver.window_handles:
+    def _select_by_excludes(self, excludes):
+        for handle in self.driver.window_handles:
             if handle not in excludes:
-                driver.switch_to.window(handle)
+                self.driver.switch_to.window(handle)
                 return
         raise WindowNotFound('No window not matching excludes %s found.'
                              % excludes)
 
-    def _select_matching(self, driver, matcher, error):
+    def _select_matching(self, matcher, error):
         try:
-            starting_handle = driver.current_window_handle
+            starting_handle = self.driver.current_window_handle
         except NoSuchWindowException:
             starting_handle = None
-        for handle in driver.window_handles:
-            driver.switch_to.window(handle)
-            if matcher(self._get_current_window_info(driver)):
+        for handle in self.driver.window_handles:
+            self.driver.switch_to.window(handle)
+            if matcher(self._get_current_window_info()):
                 return
         if starting_handle:
-            driver.switch_to.window(starting_handle)
+            self.driver.switch_to.window(starting_handle)
         raise WindowNotFound(error)
 
-    def _get_current_window_info(self, driver):
+    def _get_current_window_info(self):
         try:
-            id, name = driver.execute_script("return [ window.id, window.name ];")
+            id, name = self.driver.execute_script(
+                "return [ window.id, window.name ];")
         except WebDriverException:
             # The webdriver implementation doesn't support Javascript so we
             # can't get window id or name this way.
             id = name = None
-        return WindowInfo(driver.current_window_handle,
+        return WindowInfo(self.driver.current_window_handle,
                           id if id is not None else 'undefined',
                           name or 'undefined',
-                          driver.title or 'undefined',
-                          driver.current_url or 'undefined')
+                          self.driver.title or 'undefined',
+                          self.driver.current_url or 'undefined')
diff --git a/test/unit/keywords/test_windowmananger_window_info.py b/test/unit/keywords/test_windowmananger_window_info.py
index bd79676e8..d57cb3c18 100644
--- a/test/unit/keywords/test_windowmananger_window_info.py
+++ b/test/unit/keywords/test_windowmananger_window_info.py
@@ -11,99 +11,77 @@
 
 class GetCurrentWindowInfoTest(unittest.TestCase):
 
-    def mock_window_info(self, driver, id_, name, title, url):
-        when(driver).execute_script(SCRIPT).thenReturn([id_, name])
-        driver.title = title
-        driver.current_url = url
+    def setUp(self):
+        self.ctx = mock()
+        self.driver = mock()
+        self.ctx.driver = self.driver
+        self.manager = WindowManager(self.ctx)
+        self.driver.current_window_handle = HANDLE
+
+    def tearDown(self):
+        unstub()
+
+    def mock_window_info(self, id_, name, title, url):
+        when(self.driver).execute_script(SCRIPT).thenReturn([id_, name])
+        self.driver.title = title
+        self.driver.current_url = url
 
     def test_window_info_values_are_strings(self):
-        manager = WindowManager(None)
-        driver = mock()
-        self.mock_window_info(driver, 'id', 'name', 'title', 'url')
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info('id', 'name', 'title', 'url')
+        info = self.manager._get_current_window_info()
         self.assertEqual(info, (HANDLE, 'id', 'name', 'title', 'url'))
-        unstub()
 
     def test_window_info_values_are_none(self):
-        manager = WindowManager(None)
-        driver = mock()
-        self.mock_window_info(driver, None, None, None, None)
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(None, None, None, None)
+        info = self.manager._get_current_window_info()
         self.assertEqual(
             info, (HANDLE, 'undefined', 'undefined', 'undefined', 'undefined')
         )
-        unstub()
 
     def test_window_info_values_are_empty_strings(self):
-        manager = WindowManager(None)
-        driver = mock()
-        self.mock_window_info(driver, '', '', '', '')
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info('', '', '', '')
+        info = self.manager._get_current_window_info()
         self.assertEqual(
             info, (HANDLE, '', 'undefined', 'undefined', 'undefined')
         )
-        unstub()
 
     def test_window_id_is_bool(self):
-        manager = WindowManager(None)
-        driver = mock()
-        self.mock_window_info(driver, True, '', '', '')
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(True, '', '', '')
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], True)
-        self.mock_window_info(driver, False, '', '', '')
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(False, '', '', '')
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], False)
-        unstub()
 
     def test_window_id_is_web_element(self):
-        manager = WindowManager(None)
-        driver = mock()
         elem = mock()
-        self.mock_window_info(driver, *[elem, '', '', ''])
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(*[elem, '', '', ''])
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], elem)
-        unstub()
 
     def test_window_id_is_container(self):
-        manager = WindowManager(None)
-        driver = mock()
-        self.mock_window_info(driver, *[['1'], '', '', ''])
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(*[['1'], '', '', ''])
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], ['1'])
 
-        self.mock_window_info(driver, *[{'a': 2}, '', '', ''])
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(*[{'a': 2}, '', '', ''])
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], {'a': 2})
-        unstub()
 
     def test_window_id_is_empty_container(self):
-        manager = WindowManager(None)
-        driver = mock()
-        self.mock_window_info(driver, *[[], '', '', ''])
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(*[[], '', '', ''])
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], [])
-        self.mock_window_info(driver, *[{}, '', '', ''])
-        info = manager._get_current_window_info(driver)
+        self.mock_window_info(*[{}, '', '', ''])
+        info = self.manager._get_current_window_info()
         self.assertEqual(info[1], {})
-        unstub()
 
     def test_no_javascript_support(self):
-        manager = WindowManager(None)
-        driver = mock()
-        elem = mock()
-        when(driver).execute_script(SCRIPT).thenRaise(WebDriverException)
-        driver.title = 'title'
-        driver.current_url = 'url'
-        driver.current_window_handle = HANDLE
-        info = manager._get_current_window_info(driver)
+        when(self.driver).execute_script(SCRIPT).thenRaise(WebDriverException)
+        self.driver.title = 'title'
+        self.driver.current_url = 'url'
+        self.driver.current_window_handle = HANDLE
+        info = self.manager._get_current_window_info()
         self.assertEqual(
             info, (HANDLE, 'undefined', 'undefined', 'title', 'url')
         )
-        unstub()

From 250e261ed91432282252c3986cfb60c05ce247aa Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Mon, 6 Nov 2017 22:45:47 +0200
Subject: [PATCH 09/14] Updated based on review comments

---
 src/SeleniumLibrary/__init__.py                   |  8 ++++----
 src/SeleniumLibrary/base/context.py               |  4 ++--
 src/SeleniumLibrary/keywords/browsermanagement.py | 14 +++++++-------
 test/resources/testlibs/CustomSeleniumKeywords.py |  2 +-
 test/unit/keywords/test_browsermanagement.py      |  8 ++++----
 5 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 090b30ba3..b3c7207f6 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -342,7 +342,7 @@ def __init__(self, timeout=5.0, implicit_wait=0.0,
             WaitingKeywords(self),
             WindowKeywords(self)
         ]
-        self._webdrivers = WebDriverCache()
+        self._drivers = WebDriverCache()
         DynamicCore.__init__(self, libraries)
         self.ROBOT_LIBRARY_LISTENER = LibraryListener()
         self._element_finder = ElementFinder(self)
@@ -363,7 +363,7 @@ def run_keyword(self, name, args, kwargs):
             raise
 
     def register_driver(self, driver, alias):
-        return self._webdrivers.register(driver, alias)
+        return self._drivers.register(driver, alias)
 
     def failure_occurred(self):
         """Method that is executed when a SeleniumLibrary keyword fails.
@@ -390,9 +390,9 @@ def driver(self):
         :rtype: selenium.webdriver.remote.webdriver.WebDriver
         :raises RuntimeError if driver is not created
         """
-        if not self._webdrivers.current:
+        if not self._drivers.current:
             raise RuntimeError('No driver is open')
-        return self._webdrivers.current
+        return self._drivers.current
 
     @property
     def browser(self):
diff --git a/src/SeleniumLibrary/base/context.py b/src/SeleniumLibrary/base/context.py
index 1712a2a84..bfed50031 100644
--- a/src/SeleniumLibrary/base/context.py
+++ b/src/SeleniumLibrary/base/context.py
@@ -32,8 +32,8 @@ def driver(self):
         return self.ctx.driver
 
     @property
-    def webdrivers(self):
-        return self.ctx._webdrivers
+    def drivers(self):
+        return self.ctx._drivers
 
     @property
     def element_finder(self):
diff --git a/src/SeleniumLibrary/keywords/browsermanagement.py b/src/SeleniumLibrary/keywords/browsermanagement.py
index 49840bda6..ff10d3980 100644
--- a/src/SeleniumLibrary/keywords/browsermanagement.py
+++ b/src/SeleniumLibrary/keywords/browsermanagement.py
@@ -65,15 +65,15 @@ def close_all_browsers(self):
         all browsers are closed.
         """
         self.debug('Closing all browsers.')
-        self.webdrivers.close_all()
+        self.drivers.close_all()
 
     @keyword
     def close_browser(self):
         """Closes the current browser."""
-        if self.webdrivers.current:
+        if self.drivers.current:
             self.debug('Closing browser with session id {}.'
                        .format(self.driver.session_id))
-            self.webdrivers.close()
+            self.drivers.close()
 
     @keyword
     def open_browser(self, url, browser='firefox', alias=None,
@@ -230,7 +230,7 @@ def switch_browser(self, index_or_alias):
         | `Switch Browser`   | ${index}       |                   |
         """
         try:
-            self.webdrivers.switch(index_or_alias)
+            self.drivers.switch(index_or_alias)
         except RuntimeError:
             raise RuntimeError("No browser with index or alias '%s' found."
                                % index_or_alias)
@@ -367,7 +367,7 @@ def set_selenium_speed(self, value):
         """
         old_speed = self.get_selenium_speed()
         self.ctx.speed = timestr_to_secs(value)
-        for driver in self.webdrivers.drivers:
+        for driver in self.drivers.get_open_drivers():
             self._monkey_patch_speed(driver)
         return old_speed
 
@@ -389,7 +389,7 @@ def set_selenium_timeout(self, value):
         """
         old_timeout = self.get_selenium_timeout()
         self.ctx.timeout = timestr_to_secs(value)
-        for driver in self.webdrivers.get_open_drivers():
+        for driver in self.drivers.get_open_drivers():
             driver.set_script_timeout(self.ctx.timeout)
         return old_timeout
 
@@ -415,7 +415,7 @@ def set_selenium_implicit_wait(self, value):
         """
         old_wait = self.get_selenium_implicit_wait()
         self.ctx.implicit_wait = timestr_to_secs(value)
-        for driver in self.webdrivers.get_open_drivers():
+        for driver in self.drivers.get_open_drivers():
             driver.implicitly_wait(self.ctx.implicit_wait)
         return old_wait
 
diff --git a/test/resources/testlibs/CustomSeleniumKeywords.py b/test/resources/testlibs/CustomSeleniumKeywords.py
index 2e80c6369..ba1b0d4fe 100755
--- a/test/resources/testlibs/CustomSeleniumKeywords.py
+++ b/test/resources/testlibs/CustomSeleniumKeywords.py
@@ -12,7 +12,7 @@ def __init__(self, *args, **kwargs):
         `Run On Failure Keyword Only Called Once` test."""
         super(CustomSeleniumKeywords, self).__init__(*args, **kwargs)
         sl = BuiltIn().get_library_instance("SeleniumLibrary")
-        self._webdrivers = sl._webdrivers
+        self._drivers = sl._drivers
 
     @keyword
     def custom_selenium_keyword(self):
diff --git a/test/unit/keywords/test_browsermanagement.py b/test/unit/keywords/test_browsermanagement.py
index c46e16a29..1b1cffe34 100644
--- a/test/unit/keywords/test_browsermanagement.py
+++ b/test/unit/keywords/test_browsermanagement.py
@@ -97,17 +97,17 @@ def test_capabilities_attribute_not_modified(self):
     def test_set_selenium_timeout_only_affects_open_browsers(self):
         ctx = mock()
         ctx.timeout = 5.0
-        _webdrivers = mock()
-        ctx._webdrivers = _webdrivers
+        _drivers = mock()
+        ctx._drivers = _drivers
         first_browser, second_browser = mock(), mock()
-        when(_webdrivers).get_open_drivers().thenReturn(
+        when(_drivers).get_open_drivers().thenReturn(
             [first_browser, second_browser]
         )
         bm = BrowserManagementKeywords(ctx)
         bm.set_selenium_timeout("10 seconds")
         verify(first_browser).set_script_timeout(10.0)
         verify(second_browser).set_script_timeout(10.0)
-        when(_webdrivers).get_open_drivers().thenReturn([])
+        when(_drivers).get_open_drivers().thenReturn([])
         bm.set_selenium_timeout("20 seconds")
         verifyNoMoreInteractions(first_browser)
         verifyNoMoreInteractions(second_browser)

From 61d011f81474418615ace4e2f75a77d475b3c15e Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Tue, 7 Nov 2017 23:38:30 +0200
Subject: [PATCH 10/14] Small adjustments based on comments.

---
 src/SeleniumLibrary/__init__.py                   | 5 +++--
 src/SeleniumLibrary/errors.py                     | 4 ++++
 src/SeleniumLibrary/keywords/browsermanagement.py | 6 +++---
 src/SeleniumLibrary/utils/webdrivercache.py       | 3 ++-
 test/acceptance/open_and_close.robot              | 7 +------
 test/unit/keywords/test_browsermanagement.py      | 6 ++----
 test/unit/utils/test_webdrivercache.py            | 4 ++--
 7 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index b3c7207f6..06c9298b9 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -20,6 +20,7 @@
 from robot.libraries.BuiltIn import BuiltIn
 
 from SeleniumLibrary.base import DynamicCore
+from SeleniumLibrary.errors import NoOpenBrowser
 from SeleniumLibrary.keywords import (AlertKeywords,
                                       BrowserManagementKeywords,
                                       CookieKeywords,
@@ -385,13 +386,13 @@ def failure_occurred(self):
 
     @property
     def driver(self):
-        """Current active driver
+        """Current active driver.
 
         :rtype: selenium.webdriver.remote.webdriver.WebDriver
         :raises RuntimeError if driver is not created
         """
         if not self._drivers.current:
-            raise RuntimeError('No driver is open')
+            raise NoOpenBrowser('No browser is open')
         return self._drivers.current
 
     @property
diff --git a/src/SeleniumLibrary/errors.py b/src/SeleniumLibrary/errors.py
index 623f4270f..abed9f5bc 100644
--- a/src/SeleniumLibrary/errors.py
+++ b/src/SeleniumLibrary/errors.py
@@ -29,3 +29,7 @@ class WindowNotFound(SeleniumLibraryException):
 
 class CookieNotFound(SeleniumLibraryException):
     pass
+
+
+class NoOpenBrowser(SeleniumLibraryException):
+    pass
diff --git a/src/SeleniumLibrary/keywords/browsermanagement.py b/src/SeleniumLibrary/keywords/browsermanagement.py
index ff10d3980..5cd83eb2b 100644
--- a/src/SeleniumLibrary/keywords/browsermanagement.py
+++ b/src/SeleniumLibrary/keywords/browsermanagement.py
@@ -367,7 +367,7 @@ def set_selenium_speed(self, value):
         """
         old_speed = self.get_selenium_speed()
         self.ctx.speed = timestr_to_secs(value)
-        for driver in self.drivers.get_open_drivers():
+        for driver in self.drivers.active_drivers:
             self._monkey_patch_speed(driver)
         return old_speed
 
@@ -389,7 +389,7 @@ def set_selenium_timeout(self, value):
         """
         old_timeout = self.get_selenium_timeout()
         self.ctx.timeout = timestr_to_secs(value)
-        for driver in self.drivers.get_open_drivers():
+        for driver in self.drivers.active_drivers:
             driver.set_script_timeout(self.ctx.timeout)
         return old_timeout
 
@@ -415,7 +415,7 @@ def set_selenium_implicit_wait(self, value):
         """
         old_wait = self.get_selenium_implicit_wait()
         self.ctx.implicit_wait = timestr_to_secs(value)
-        for driver in self.drivers.get_open_drivers():
+        for driver in self.drivers.active_drivers:
             driver.implicitly_wait(self.ctx.implicit_wait)
         return old_wait
 
diff --git a/src/SeleniumLibrary/utils/webdrivercache.py b/src/SeleniumLibrary/utils/webdrivercache.py
index 1b0a209a5..6b3bc31a6 100644
--- a/src/SeleniumLibrary/utils/webdrivercache.py
+++ b/src/SeleniumLibrary/utils/webdrivercache.py
@@ -27,7 +27,8 @@ def __init__(self):
     def drivers(self):
         return self._connections
 
-    def get_open_drivers(self):
+    @property
+    def active_drivers(self):
         open_drivers = []
         for driver in self._connections:
             if driver not in self._closed:
diff --git a/test/acceptance/open_and_close.robot b/test/acceptance/open_and_close.robot
index 81ee8ee6c..508e41c7f 100644
--- a/test/acceptance/open_and_close.robot
+++ b/test/acceptance/open_and_close.robot
@@ -1,25 +1,20 @@
 *** Settings ***
-Documentation     Opening and closing browsers
 Suite Teardown    Close All Browsers
 Resource          resource.robot
 
 *** Test Cases ***
 Browser Should Open And Close
-    [Documentation]    Opens and closes browser
     Open Browser To Start Page Without Testing Default Options
     Close Browser
 
 Browser Open With Implicit Wait Should Not Override Default
-    [Documentation]    Opens browser with implicit wait
     Open Browser To Start Page And Test Implicit Wait    10
     Close Browser
 
 There Should Be A Good Error Message If Browser Is Not Opened
-    [Documentation]    Tests error message
-    Run Keyword And Expect Error    No driver is open    Title Should Be    foo
+    Run Keyword And Expect Error    No browser is open    Title Should Be    foo
 
 Close Browser Does Nothing When No Browser Is Opened
-    [Documentation]    Close already closed browser
     Close Browser
 
 Browser Open With Not Well-Formed URL Should Close
diff --git a/test/unit/keywords/test_browsermanagement.py b/test/unit/keywords/test_browsermanagement.py
index 1b1cffe34..6ad0d665e 100644
--- a/test/unit/keywords/test_browsermanagement.py
+++ b/test/unit/keywords/test_browsermanagement.py
@@ -100,14 +100,12 @@ def test_set_selenium_timeout_only_affects_open_browsers(self):
         _drivers = mock()
         ctx._drivers = _drivers
         first_browser, second_browser = mock(), mock()
-        when(_drivers).get_open_drivers().thenReturn(
-            [first_browser, second_browser]
-        )
+        ctx._drivers.active_drivers = [first_browser, second_browser]
         bm = BrowserManagementKeywords(ctx)
         bm.set_selenium_timeout("10 seconds")
         verify(first_browser).set_script_timeout(10.0)
         verify(second_browser).set_script_timeout(10.0)
-        when(_drivers).get_open_drivers().thenReturn([])
+        ctx._drivers.active_drivers = []
         bm.set_selenium_timeout("20 seconds")
         verifyNoMoreInteractions(first_browser)
         verifyNoMoreInteractions(second_browser)
diff --git a/test/unit/utils/test_webdrivercache.py b/test/unit/utils/test_webdrivercache.py
index 965dac9c0..8c2bc6379 100644
--- a/test/unit/utils/test_webdrivercache.py
+++ b/test/unit/utils/test_webdrivercache.py
@@ -44,14 +44,14 @@ def test_get_open_browsers(self):
         cache.register(driver2)
         cache.register(driver3)
 
-        drivers = cache.get_open_drivers()
+        drivers = cache.active_drivers
         self.assertEqual(len(drivers), 3)
         self.assertEqual(drivers[0], driver1)
         self.assertEqual(drivers[1], driver2)
         self.assertEqual(drivers[2], driver3)
 
         cache.close()
-        drivers = cache.get_open_drivers()
+        drivers = cache.active_drivers
         self.assertEqual(len(drivers), 2)
         self.assertEqual(drivers[0], driver1)
         self.assertEqual(drivers[1], driver2)

From c8a7c2f5b136b2c0d8a67e046f58ee26c89de1d1 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Wed, 8 Nov 2017 22:08:32 +0200
Subject: [PATCH 11/14] Fixed doc string and error message in cache

---
 src/SeleniumLibrary/__init__.py             | 4 ++--
 src/SeleniumLibrary/utils/webdrivercache.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 06c9298b9..457e6ab53 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -389,10 +389,10 @@ def driver(self):
         """Current active driver.
 
         :rtype: selenium.webdriver.remote.webdriver.WebDriver
-        :raises RuntimeError if driver is not created
+        :raises NoOpenBrowser if driver is not created
         """
         if not self._drivers.current:
-            raise NoOpenBrowser('No browser is open')
+            raise NoOpenBrowser('No browser is open.')
         return self._drivers.current
 
     @property
diff --git a/src/SeleniumLibrary/utils/webdrivercache.py b/src/SeleniumLibrary/utils/webdrivercache.py
index 6b3bc31a6..92b4ba9db 100644
--- a/src/SeleniumLibrary/utils/webdrivercache.py
+++ b/src/SeleniumLibrary/utils/webdrivercache.py
@@ -20,7 +20,7 @@
 class WebDriverCache(ConnectionCache):
 
     def __init__(self):
-        ConnectionCache.__init__(self, no_current_msg='No current driver')
+        ConnectionCache.__init__(self, no_current_msg='No current browser')
         self._closed = set()
 
     @property

From fbca5d2a65a56c2155ecdef9e35b4c010fb69760 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Wed, 8 Nov 2017 22:34:57 +0200
Subject: [PATCH 12/14] Fixed tests because error message was changed

---
 test/acceptance/open_and_close.robot   | 2 +-
 test/unit/utils/test_webdrivercache.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/acceptance/open_and_close.robot b/test/acceptance/open_and_close.robot
index 508e41c7f..629be0a67 100644
--- a/test/acceptance/open_and_close.robot
+++ b/test/acceptance/open_and_close.robot
@@ -12,7 +12,7 @@ Browser Open With Implicit Wait Should Not Override Default
     Close Browser
 
 There Should Be A Good Error Message If Browser Is Not Opened
-    Run Keyword And Expect Error    No browser is open    Title Should Be    foo
+    Run Keyword And Expect Error    No browser is open.    Title Should Be    foo
 
 Close Browser Does Nothing When No Browser Is Opened
     Close Browser
diff --git a/test/unit/utils/test_webdrivercache.py b/test/unit/utils/test_webdrivercache.py
index 8c2bc6379..65de9adb2 100644
--- a/test/unit/utils/test_webdrivercache.py
+++ b/test/unit/utils/test_webdrivercache.py
@@ -12,7 +12,7 @@ def test_no_current_message(self):
         try:
             self.assertRaises(RuntimeError, cache.current.anyMember())
         except RuntimeError as e:
-            self.assertEqual(str(e), "No current driver")
+            self.assertEqual(str(e), "No current browser")
 
     def test_browsers_property(self):
         cache = WebDriverCache()

From 7a24e4b5a0cd503452fd20659105bd3a5abf6dc0 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Wed, 8 Nov 2017 22:45:13 +0200
Subject: [PATCH 13/14] Fixes sphinx doc definition

---
 src/SeleniumLibrary/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 457e6ab53..91a72fb5a 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -389,7 +389,7 @@ def driver(self):
         """Current active driver.
 
         :rtype: selenium.webdriver.remote.webdriver.WebDriver
-        :raises NoOpenBrowser if driver is not created
+        :raises SeleniumLibrary.errors.ElementNotFound: If element not found.
         """
         if not self._drivers.current:
             raise NoOpenBrowser('No browser is open.')

From 4c8148ad49d33a9f872d4cd975b84bad27c46914 Mon Sep 17 00:00:00 2001
From: Tatu Aalto <aalto.tatu@gmail.com>
Date: Wed, 8 Nov 2017 23:13:14 +0200
Subject: [PATCH 14/14] Fixes agains the doc string

---
 src/SeleniumLibrary/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/SeleniumLibrary/__init__.py b/src/SeleniumLibrary/__init__.py
index 91a72fb5a..71b994fd1 100644
--- a/src/SeleniumLibrary/__init__.py
+++ b/src/SeleniumLibrary/__init__.py
@@ -389,7 +389,7 @@ def driver(self):
         """Current active driver.
 
         :rtype: selenium.webdriver.remote.webdriver.WebDriver
-        :raises SeleniumLibrary.errors.ElementNotFound: If element not found.
+        :raises SeleniumLibrary.errors.NoOpenBrowser: If browser is not open.
         """
         if not self._drivers.current:
             raise NoOpenBrowser('No browser is open.')