Refactor -- make ui passive watcher, control a passive test list.

client/site_tests/factory_ExternalStorage/factory_ExternalStorage.py

 # -*- coding: utf-8 -*-
 #
 # 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.
 
 
 # DESCRIPTION :
 #
 # This is a factory test to test external SD and USB ports.
@@ skipping 53 matching lines @@
     def expose_event(self, widget, event):
         context = widget.window.cairo_create()
         context.set_source_surface(self._image, 0, 0)
         context.paint()
         return True
 
     def register_callbacks(self, window):
         window.connect('key-release-event', self.key_release_callback)
         window.add_events(gtk.gdk.KEY_RELEASE_MASK)
 
-    def rescan_storage(self, test_tag):
+    def rescan_storage(self, subtest_tag):
         if self._state == _STATE_WAIT_INSERT:
             new_devices = find_all_storage_dev()
             diff = new_devices - self._devices
             if diff:
                 self._devices = new_devices
                 factory.log('found new devs : %s' % diff)
                 self._target_device = diff.pop()
                 devpath = '/dev/%s' % self._target_device
                 self._prompt.set_text(_TESTING_FMT_STR(devpath))
                 self._image = self.testing_image
                 self._pictogram.queue_draw()
                 gtk.main_iteration()
                 test._result = self.job.run_test('hardware_StorageFio',
                                                  dev=devpath,
                                                  quicktest=True,
-                                                 tag=test_tag)
+                                                 tag=subtest_tag)
                 self._prompt.set_text(_REMOVE_FMT_STR(self._media))
                 self._state = _STATE_WAIT_REMOVE
                 self._image = self.removal_image
                 self._pictogram.queue_draw()
         else:
             diff = self._devices - find_all_storage_dev()
             if len(diff) > 1:
                 self._error += _ERR_TOO_MANY_REMOVE_FMT_STR(
                         self._target_device, diff)
             if diff and self._target_device not in diff:
                 self._error += _ERR_DEV_NOT_REMOVE_FMT_STR(
                         self._target_device)
             if diff:
                 gtk.main_quit()
         return True
 
     def run_once(self,
                  test_widget_size=None,
                  trigger_set=None,
-                 test_tag_prefix=None,
-                 test_count=None,
+                 subtest_tag=None,
                  media=None):
 
         factory.log('%s run_once' % self.__class__)
 
         self._error = ''
 
         os.chdir(self.srcdir)
 
         self._media = media
         factory.log('media = %s' % media)
 
         self.insertion_image = cairo.ImageSurface.create_from_png(
             '%s_insert.png' % media)
         self.removal_image = cairo.ImageSurface.create_from_png(
             '%s_remove.png' % media)
         self.testing_image = cairo.ImageSurface.create_from_png(
             '%s_testing.png' % media)
 
         image_size_set = set([(i.get_width(), i.get_height()) for
                               i in [self.insertion_image,
                                     self.removal_image,
                                     self.testing_image]])
         assert len(image_size_set) == 1
         image_size = image_size_set.pop()
 
-        test_tag = '%s_%s' % (test_tag_prefix, test_count)
-        factory.log('test_tag = %s' % test_tag)
+        factory.log('subtest_tag = %s' % subtest_tag)
 
         self._ft_state = ful.State(trigger_set)
 
         label = gtk.Label('')
         label.modify_font(pango.FontDescription('courier new condensed 20'))
         label.set_alignment(0.5, 0.5)
         label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('light green'))
         self._prompt = label
 
         self._prompt.set_text(_INSERT_FMT_STR(self._media))
         self._state = _STATE_WAIT_INSERT
         self._image = self.insertion_image
         self._result = False
         self._devices = find_all_storage_dev()
-        gobject.timeout_add(250, self.rescan_storage, test_tag)
+        gobject.timeout_add(250, self.rescan_storage, subtest_tag)
 
         drawing_area = gtk.DrawingArea()
         drawing_area.set_size_request(*image_size)
         drawing_area.connect('expose_event', self.expose_event)
         self._pictogram = drawing_area
 
         vbox = gtk.VBox()
         vbox.pack_start(drawing_area, False, False)
         vbox.pack_start(label, False, False)
 
         test_widget = gtk.EventBox()
         test_widget.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('black'))
         test_widget.add(vbox)
 
         self._ft_state.run_test_widget(
             test_widget=test_widget,
             test_widget_size=test_widget_size,
             window_registration_callback=self.register_callbacks)
 
         if self._error:
             raise error.TestFail(self._error)
 
         factory.log('%s run_once finished' % self.__class__)