Remove SWIGged use of BrowserProxy and TabProxy from PyAuto tests.

chrome/test/functional/ui_runner.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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 powered ui action runner.
 
 Developed primarily to verify validity of the model based action generator.
 """
 
 import time
 import sys
 
 import pyauto_functional
 import pyauto
 import ui_model

[Nirnimesh, 2012/08/07 00:37:35]

Remove this file and ui_model.py

[craigdh, 2012/08/07 21:08:51]

Done.

 
 class Runner(pyauto.PyUITest):
 
   def setUp(self):
     self.debug_mode = False
     pyauto.PyUITest.setUp(self)
 
   def RunActionList(self):
     """Runs actions from a file."""
     f = open('list')
@@ skipping 58 matching lines @@
     if tab_count != expected_count:
       self.Error('tab count out of sync: count: %d expected: %d' % (
           tab_count, expected_count))
     window_count = self.GetBrowserWindowCount()
     expected_count = self.browser.num_windows
     if window_count != expected_count:
       self.Error('window count out of sync: count: %d expected %d' % (
           window_count, expected_count))
 
   def _GrabTab(self):
-    active_window = self.browser.window_position
-    window = self.GetBrowserWindow(active_window)
     tab_count = self.GetTabCount(self.browser.window_position)
     active_tab = self.browser.window.tab_position
     if active_tab >= tab_count:
       self.Error('active tab out of bounds: count: %d expected active: %d' % (
                  (tab_count, active_tab)))
-    return window.GetTab(self.browser.window.tab_position)
+    return {'tab_index': self.browser.window.tab_position,
+            'windex': self.browser.window_position, }
 
   def _RunInActiveWindow(self, command):
     active_window = self.browser.window_position
     self.RunCommand(command, active_window)
 
   def _RunAsyncInActiveWindow(self, command):
     active_window = self.browser.window_position
     self.ApplyAccelerator(command, active_window)
 
   def _Zoom(self, command):
@@ skipping 67 matching lines @@
       while nav_result != 1:
         if retries == 1:
           break
         if retries == 1:
           sys.stdout.write('retry ')
         if retries > 0:
           time.sleep(.1)
           sys.stdout.write('%d, ' % retries)
         if a == 'navigate':
           target = pyauto.GURL(action.split(';')[1])
-          nav_result = tab.NavigateToURL(target)
+          nav_result = self.NavigateToURL(target, **tab)
         elif a == 'back':
           self.browser.Back()
           self.browser.Forward()
-          nav_result = tab.GoBack()
+          nav_result = self.TabGoBack(**tab)
         elif a == 'forward':
           self.browser.Forward()
           self.browser.Back()
-          nav_result = tab.GoForward()
+          nav_result = self.TabGoForward(**tab)
         retries += 1
     if a == 'closetab':
       tab = self._GrabTab()
       ui_model.UpdateState(self.browser, action)
       active_window = self.browser.window_position
       window_count = self.browser.num_windows
       tab_count = self.browser.window.num_tabs
       def WindowCount():
         actual = self.GetBrowserWindowCount()
         result = actual == window_count
         return (result, 'WindowCount (expected %d, actual %d)' %
                 (window_count, actual))
       def TabCount():
         actual = self.GetTabCount(active_window)
         result = actual == tab_count
         return (result, 'TabCount (expected %d, actual %d)' %
                 (tab_count, actual))
-      tab.Close(True)
+      self.CloseTab(**tab)
       self._WaitFor(WindowCount)
       self._WaitFor(TabCount)
       return False
     if a == 'closewindow':
       window_count = self.browser.num_windows - 1
       def WindowCount():
         result = self.GetBrowserWindowCount() == window_count
         return (result, 'WindowCount (expected %d)' % window_count)
       self._RunInActiveWindow(pyauto.IDC_CLOSE_WINDOW)
       self._WaitFor(WindowCount)
     if a == 'dragtabout':
       return False
     if a == 'dragtableft':
       self._RunAsyncInActiveWindow(pyauto.IDC_MOVE_TAB_PREVIOUS)
     if a == 'dragtabright':
       self._RunAsyncInActiveWindow(pyauto.IDC_MOVE_TAB_NEXT)
     if a == 'lasttab':
       self._RunAsyncInActiveWindow(pyauto.IDC_SELECT_PREVIOUS_TAB)
     if a == 'nexttab':
       self._RunAsyncInActiveWindow(pyauto.IDC_SELECT_NEXT_TAB)
     if a == 'restoretab':
       active_window = self.browser.window_position
       self.ApplyAccelerator(pyauto.IDC_RESTORE_TAB, active_window)
-      self._GrabTab().WaitForTabToBeRestored(self.action_max_timeout_ms())
+      self.WaitForTabToBeRestored(**self._GrabTab())
       ui_model.UpdateState(self.browser, action)
       return False
     return True
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()