Relocate library files for wider access and re-use; also associated cleanup.

client/site_tests/factory_Touchpad/factory_Touchpad.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
-from autotest_lib.client.bin import test
-from autotest_lib.client.common_lib import error
-from autotest_lib.client.common_lib import factory_test
-
 import cairo
 import gobject
 import gtk
 import pango
 import time
 import os
 import sys
 import subprocess
 
+from autotest_lib.client.bin import factory
+from autotest_lib.client.bin import factory_ui_lib as ful
+from autotest_lib.client.bin import test
+from autotest_lib.client.common_lib import error
+
 
 _SYNCLIENT_SETTINGS_CMDLINE = '/usr/bin/synclient -l'
 _SYNCLIENT_CMDLINE = '/usr/bin/synclient -m 50'
 
 _RGBA_GREEN_OVERLAY = (0, 0.5, 0, 0.6)
 
 _X_SEGMENTS = 5
 _Y_SEGMENTS = 4
 
 _X_TP_OFFSET = 10
 _Y_TP_OFFSET = 10
 _TP_WIDTH = 397
 _TP_HEIGHT = 213
 _TP_SECTOR_WIDTH = (_TP_WIDTH / _X_SEGMENTS) - 1
 _TP_SECTOR_HEIGHT = (_TP_HEIGHT / _Y_SEGMENTS) - 1
 
 _X_SP_OFFSET = 432
 _SP_WIDTH = 19
 
 
 class TouchpadTest:
 
-    def __init__(self, tp_image, drawing_area):
+    def __init__(self, tp_image, drawing_area, ft_state):
         self._tp_image = tp_image
         self._drawing_area = drawing_area
+        self._ft_state = ft_state
         self._motion_grid = {}
         for x in range(_X_SEGMENTS):
             for y in range(_Y_SEGMENTS):
                 self._motion_grid['%d,%d' % (x, y)] = False
         self._scroll_array = {}
         for y in range(_Y_SEGMENTS):
             self._scroll_array[y] = False
         self._l_click = False
         self._r_click = False
 
     def timer_event(self, window):
         if not self._deadline:
             # Ignore timer events with no countdown in progress.
             return True
         if self._deadline <= time.time():
             XXX_log('deadline reached')
             gtk.main_quit()
         window.queue_draw()
         return True
 
     def device_event(self, x, y, z, fingers, left, right):
         x_seg = int(round(x / (1.0 / float(_X_SEGMENTS - 1))))
         y_seg = int(round(y / (1.0 / float(_Y_SEGMENTS - 1))))
         index = '%d,%d' % (x_seg, y_seg)
         assert(index in self._motion_grid)
         assert(y_seg in self._scroll_array)
         if left and not self._l_click:
             self._l_click = True
-            factory_test.XXX_log('ok left click')
+            factory.log('ok left click')
         elif right and not self._r_click:
             self._r_click = True
-            factory_test.XXX_log('ok right click')
+            factory.log('ok right click')
         elif fingers == 1 and not self._motion_grid[index]:
             self._motion_grid[index] = True
         elif fingers == 2 and not self._scroll_array[y_seg]:
             self._scroll_array[y_seg] = True
         else:
             return
         self._drawing_area.queue_draw()
         missing_motion_sectors = set(i for i, v in self._motion_grid.items()
                                      if v is False)
         missing_scroll_segments = set(i for i, v in self._scroll_array.items()
@@ skipping 25 matching lines @@
                 continue
             y = _Y_TP_OFFSET + (y_seg * (_TP_SECTOR_HEIGHT + 1))
             coords = (_X_SP_OFFSET, y, _SP_WIDTH, _TP_SECTOR_HEIGHT)
             context.rectangle(*coords)
             context.set_source_rgba(*_RGBA_GREEN_OVERLAY)
             context.fill()
 
         return True
 
     def key_press_event(self, widget, event):
-        factory_test.test_switch_on_trigger(event)
+        self._ft_state.exit_on_trigger(event)
         return True
 
     def button_press_event(self, widget, event):
-        factory_test.XXX_log('button_press_event %d,%d' % (event.x, event.y))
+        factory.log('button_press_event %d,%d' % (event.x, event.y))
         return True
 
     def button_release_event(self, widget, event):
-        factory_test.XXX_log('button_release_event %d,%d' % (event.x, event.y))
+        factory.log('button_release_event %d,%d' % (event.x, event.y))
         return True
 
     def motion_event(self, widget, event):
-        factory_test.XXX_log('motion_event %d,%d' % (event.x, event.y))
+        factory.log('motion_event %d,%d' % (event.x, event.y))
         return True
 
     def register_callbacks(self, window):
         window.connect('key-press-event', self.key_press_event)
         window.add_events(gtk.gdk.KEY_PRESS_MASK)
 
 
 class SynClient:
 
     def __init__(self, test):
@@ skipping 11 matching lines @@
         self._xmax = float(settings['RightEdge'])
         self._ymin = float(settings['TopEdge'])
         self._ymax = float(settings['BottomEdge'])
         self._proc = subprocess.Popen(_SYNCLIENT_CMDLINE.split(),
                                       stdout=subprocess.PIPE)
         gobject.io_add_watch(self._proc.stdout, gobject.IO_IN, self.recv)
 
     def recv(self, src, cond):
         data = self._proc.stdout.readline().split()
         if len(data) != 17:
-            factory_test.XXX_log('unknown data : %d, %s' % (len(data), data))
+            factory.log('unknown data : %d, %s' % (len(data), data))
             return True
         if data[0] == 'time':
             return True
         data_x, data_y, z, f, w, l, r = data[1:8]
         x = sorted([self._xmin, float(data_x), self._xmax])[1]
         x = (x - self._xmin) / (self._xmax - self._xmin)
         y = sorted([self._ymin, float(data_y), self._ymax])[1]
         y = (y - self._ymin) / (self._ymax - self._ymin)
         self._test.device_event(x, y, int(z), int(f), int(l), int(r))
         return True
 
     def quit(self):
-        factory_test.XXX_log('killing SynClient ...')
+        factory.log('killing SynClient ...')
         self._proc.kill()
-        factory_test.XXX_log('dead')
+        factory.log('dead')
 
 
 class factory_Touchpad(test.test):
     version = 1
     preserve_srcdir = True
 
-    def run_once(self, test_widget_size=None, trigger_set=None,
+    def run_once(self,
+                 test_widget_size=None,
+                 trigger_set=None,
                  result_file_path=None):
 
-        factory_test.XXX_log('factory_Touchpad')
+        factory.log('%s run_once' % self.__class__)
 
-        factory_test.init(trigger_set=trigger_set,
-                          result_file_path=result_file_path)
+        ft_state = ful.State(
+            trigger_set=trigger_set,
+            result_file_path=result_file_path)
 
         os.chdir(self.srcdir)
         tp_image = cairo.ImageSurface.create_from_png('touchpad.png')
         image_size = (tp_image.get_width(), tp_image.get_height())
 
         drawing_area = gtk.DrawingArea()
 
-        test = TouchpadTest(tp_image, drawing_area)
+        test = TouchpadTest(tp_image, drawing_area, ft_state)
 
         drawing_area.set_size_request(*image_size)
         drawing_area.connect('expose_event', test.expose_event)
         drawing_area.connect('button-press-event', test.button_press_event)
         drawing_area.connect('button-release-event', test.button_release_event)
         drawing_area.connect('motion-notify-event', test.motion_event)
         drawing_area.add_events(gtk.gdk.EXPOSURE_MASK |
                                 gtk.gdk.BUTTON_PRESS_MASK |
                                 gtk.gdk.BUTTON_RELEASE_MASK |
                                 gtk.gdk.POINTER_MOTION_MASK)
 
         synclient = SynClient(test)
 
-        factory_test.run_test_widget(
+        ft_state.run_test_widget(
             test_widget=drawing_area,
             test_widget_size=test_widget_size,
             window_registration_callback=test.register_callbacks,
             cleanup_callback=synclient.quit)
 
-        factory_test.XXX_log('exiting factory_Touchpad')
+        factory.log('%s run_once finished' % self.__class__)