Remove SWIGged use of BrowserProxy and TabProxy from PyAuto tests.

chrome/test/pyautolib/pyauto.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """PyAuto: Python Interface to Chromium's Automation Proxy.
 
 PyAuto uses swig to expose Automation Proxy interfaces to Python.
 For complete documentation on the functionality available,
 run pydoc on this file.
@@ skipping 1066 matching lines @@
                                additional_info))
     ret_dict = json.loads(result)
     if ret_dict.has_key('error'):
       raise JSONInterfaceError(ret_dict['error'])
     return ret_dict
 
   def NavigateToURL(self, url, windex=0, tab_index=None, navigation_count=1):
     """Navigate the given tab to the given URL.
 
     Note that this method also activates the corresponding tab/window if it's
-    not active already. Blocks until page has loaded.
+    not active already. Blocks until |navigation_count| navigations have
+    completed.
 
     Args:
       url: The URL to which to navigate, can be a string or GURL object.
       windex: The index of the browser window to work on. Defaults to the first
           window.
       tab_index: The index of the tab to work on. Defaults to the active tab.
       navigation_count: the number of navigations to wait for. Defaults to 1.
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
     if isinstance(url, GURL):
       url = url.spec()
     if tab_index is None:
       tab_index = self.GetActiveTabIndex(windex)
     cmd_dict = {
         'command': 'NavigateToURL',
         'url': url,
         'windex': windex,
         'tab_index': tab_index,
         'navigation_count': navigation_count,
     }
     self._GetResultFromJSONRequest(cmd_dict, windex=None)
 
+  def NavigateToURLAsync(self, url, windex=0, tab_index=None):
+    """Initiate a URL navigation.
+
+    A wrapper for NavigateToURL with navigation_count set to 0.
+    """
+    self.NavigateToURL(url, windex, tab_index, 0)
+
   def ApplyAccelerator(self, accelerator, windex=0):
     """Apply the accelerator with the given id.
 
     Note that this method schedules the accelerator, but does not wait for it to
     actually finish doing anything.
 
     Args:
       accelerator: The accelerator id, IDC_BACK, IDC_NEWTAB, etc. The list of
           ids can be found at chrome/app/chrome_command_ids.h.
       windex: The index of the browser window to work on. Defaults to the first
@@ skipping 47 matching lines @@
     Returns:
       True if the command is enabled for the given window.
     """
     cmd_dict = {
         'command': 'IsMenuCommandEnabled',
         'accelerator': accelerator,
         'windex': windex,
     }
     return self._GetResultFromJSONRequest(cmd_dict, windex=None).get('enabled')
 
+  def TabGoForward(self, tab_index=0, windex=0):
+    """Navigate a tab forward in history.
+
+    Equivalent to clicking the Forward button in the UI. Activates the tab as a
+    side effect.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    self.ActivateTab(tab_index, windex)
+    self.RunCommand(IDC_FORWARD, windex)
+
+  def TabGoBack(self, tab_index=0, windex=0):
+    """Navigate a tab backwards in history.
+
+    Equivalent to clicking the Back button in the UI. Activates the tab as a
+    side effect.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    self.ActivateTab(tab_index, windex)
+    self.RunCommand(IDC_BACK, windex)
+
   def ReloadTab(self, tab_index=0, windex=0):
     """Reload the given tab.
 
     Blocks until the page has reloaded.
 
     Args:
       tab_index: The index of the tab to reload. Defaults to 0.
       windex: The index of the browser window to work on. Defaults to the first
           window.
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
+    self.ActivateTab(tab_index, windex)
+    self.RunCommand(IDC_RELOAD, windex)
+
+  def CloseTab(self, tab_index=0, windex=0, wait_until_closed=True):
+    """Close the given tab.
+
+    Note: Be careful closing the last tab in a window as it may close the
+        browser.
+
+    Args:
+      tab_index: The index of the tab to reload. Defaults to 0.
+      windex: The index of the browser window to work on. Defaults to the first
+          window.
+      wait_until_closed: Whether to block until the tab finishes closing.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
     cmd_dict = {
-        'command': 'Reload',
+        'command': 'CloseTab',
+        'tab_index': tab_index,
+        'windex': windex,
+        'wait_until_closed': wait_until_closed,
+    }
+    self._GetResultFromJSONRequest(cmd_dict, windex=None)
+
+  def WaitForTabToBeRestored(self, tab_index=0, windex=0, timeout=-1):
+    """Wait for the given tab to be restored.
+
+    Args:
+      tab_index: The index of the tab to reload. Defaults to 0.
+      windex: The index of the browser window to work on. Defaults to the first
+          window.
+      timeout: Timeout in milliseconds.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    cmd_dict = {
+        'command': 'CloseTab',
         'tab_index': tab_index,
         'windex': windex,
     }
-    self._GetResultFromJSONRequest(cmd_dict, windex=None)
+    self._GetResultFromJSONRequest(cmd_dict, windex=None, timeout=timeout)
 
   def ReloadActiveTab(self, windex=0):
     """Reload an active tab.
 
     Warning: Depending on the concept of an active tab is dangerous as it can
     change during the test. Use ReloadTab and supply a tab_index explicitly.
 
     Args:
       windex: The index of the browser window to work on. Defaults to the first
           window.
@@ skipping 206 matching lines @@
 
     Returns:
       The tab URL as a GURL object.
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
     return GURL(str(self.GetTabInfo(self.GetActiveTabIndex(windex),
                                     windex)['url']))
 
+  def ActionOnSSLBlockingPage(self, tab_index=0, windex=0, proceed=True):
+    """Take action on an interstitial page.
+
+    Calling this when an interstitial page is not showing is an error.
+
+    Args:
+      tab_index: Integer index of the tab to activate; defaults to 0.
+      windex: Integer index of the browser window to use; defaults to the first
+          window.
+      proceed: Whether to proceed to the URL or not.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    cmd_dict = {
+        'command': 'ActionOnSSLBlockingPage',
+        'tab_index': tab_index,
+        'windex': windex,
+        'proceed': proceed,
+    }
+    return self._GetResultFromJSONRequest(cmd_dict, windex=None)
+
   def GetBookmarkModel(self, windex=0):
     """Return the bookmark model as a BookmarkModel object.
 
     This is a snapshot of the bookmark model; it is not a proxy and
     does not get updated as the bookmark model changes.
     """
     bookmarks_as_json = self._GetBookmarksAsJSON(windex)
     if not bookmarks_as_json:
       raise JSONInterfaceError('Could not resolve browser proxy.')
     return bookmark_model.BookmarkModel(bookmarks_as_json)
@@ skipping 906 matching lines @@
         NORMAL_PAGE
         ERROR_PAGE
         INTERSTITIAL_PAGE
     """
     cmd_dict = {  # Prepare command for the json interface
       'command': 'GetNavigationInfo',
       'tab_index': tab_index,
     }
     return self._GetResultFromJSONRequest(cmd_dict, windex=windex)
 
+  def GetSecurityState(self, tab_index=0, windex=0):
+    """Get security details for a given tab.
+
+    Args:
+      tab_index: The tab index, default is 0.
+      window_index: The window index, default is 0.
+
+    Returns:
+      a dictionary.
+      Sample:
+      { "security_style": SECURITY_STYLE_AUTHENTICATED,
+        "ssl_cert_status": 3,  // bitmask of status flags
+        "insecure_content_status": 1,  // bitmask of status flags
+      }
+    """
+    cmd_dict = {  # Prepare command for the json interface
+      'command': 'GetSecurityState',
+      'tab_index': tab_index,
+      'windex': windex,
+    }
+    return self._GetResultFromJSONRequest(cmd_dict, windex=None)
+
   def GetHistoryInfo(self, search_text=''):
     """Return info about browsing history.
 
     Args:
       search_text: the string to search in history.  Defaults to empty string
                    which means that all history would be returned. This is
                    functionally equivalent to searching for a text in the
                    chrome://history UI. So partial matches work too.
                    When non-empty, the history items returned will contain a
                    "snippet" field corresponding to the snippet visible in
@@ skipping 4185 matching lines @@
     successful = result.wasSuccessful()
     if not successful:
       pyauto_tests_file = os.path.join(self.TestsDir(), self._tests_filename)
       print >>sys.stderr, 'Tests can be disabled by editing %s. ' \
                           'Ref: %s' % (pyauto_tests_file, _PYAUTO_DOC_URL)
     sys.exit(not successful)
 
 
 if __name__ == '__main__':
   Main()