Fix status reporting and auto-seq logic.

client/bin/factory_ui

 #!/usr/bin/python
 #
 # 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 UI is intended to be used by the factory autotest suite to
@@ skipping 145 matching lines @@
     def update(self, status):
         if status == ful.UNTESTED:
             return
         self.label_status.set_text(status)
         self.label_status.modify_fg(gtk.STATE_NORMAL, ful.LABEL_COLORS[status])
         self.queue_draw()
 
 
 class UiState():
 
-    def __init__(self, status_map, test_widget_box):
+    def __init__(self, test_widget_box, automated_sequence_set):
 
         def make_empty_test_label_widget():
             label_box = gtk.EventBox()
             label_box.modify_bg(gtk.STATE_NORMAL, ful.BLACK)
             label = ful.make_label('no active test', font=_OTHER_LABEL_FONT,
                                    alignment=(0.5, 0.5))
             label_box.add(label)
             return label_box
 
-        def make_automated_seq_label_widget(subtest_list):
+        def make_automated_sequence_label_widget(subtest_list):
             vbox = gtk.VBox()
             vbox.set_spacing(0)
             for subtest in subtest_list:
                 label_box = SubTestLabelBox(subtest)
-                status_map.set_label_box(subtest, label_box)
-                vbox.pack_start(status_map.lookup_label_box(subtest),
-                                False, False)
+                self.set_label_box(subtest, label_box)
+                vbox.pack_start(label_box, False, False)
             return vbox
 
-        self._status_map = status_map
+        self._label_box_map = {}
         self._test_widget_box = test_widget_box
         self._empty_test_widget = make_empty_test_label_widget()
         self._active_test_widget = self._empty_test_widget
         self.active_test = None
 
         self._test_widget_box.add(self._empty_test_widget)
 
         self._automated_seq_widget_map = dict(
-            (t, make_automated_seq_label_widget(t.subtest_list))
-            for t in self._status_map.test_db.seq_test_set)
+            (test, make_automated_sequence_label_widget(test.subtest_list))
+            for test in automated_sequence_set)
 
-    def set_active_test(self, test):
+    def status_change_callback(self, test, status):
+        label_box = self._label_box_map.get(test)
+        if label_box:
+            label_box.update(status)
+
+    def set_label_box(self, test, label_box):
+        self._label_box_map[test] = label_box
+
+    def set_active_test(self, test_db, test):
         '''Control what kind of widget is shown in the testing area of
         the screen.  For normal operator tests, this is just a label
         saying there is no active test.  The expectation is that the
         operator test itself has a window obscuring this message.  For
         automated sequences, since there is no other window, the no
         active test message is replaced with an updated list of
         subtest status.'''
         if test is None or test == self.active_test:
             return
-        factory.log('UI active test -> %s' %
-                    self._status_map.test_db.get_unique_details(test))
+        factory.log('UI active test is %s' % test_db.get_unique_id_str(test))
         self.active_test = test
         self._test_widget_box.remove(self._active_test_widget)
-        active_widget = (test in self._status_map.test_db.seq_test_set
+        active_widget = (isinstance(test, factory.AutomatedSequence)
                          and self._automated_seq_widget_map[test]
                          or self._empty_test_widget)
         self._test_widget_box.add(active_widget)
         self._active_test_widget = active_widget
         self._test_widget_box.show_all()
 
 
-def refresh_status(status_map, ui_state):
+def refresh_status(status_map, test_db, ui_state):
     status_map.read_new_data()
     active_test = status_map.get_active_top_level_test()
-    ui_state.set_active_test(active_test)
+    ui_state.set_active_test(test_db, active_test)
     return True
 
 
 def grab_shortcut_keys(kbd_shortcut_set, control_pid):
     disp = X_Display()
     root = disp.screen().root
 
     # We want to receive KeyPress events
     root.change_attributes(event_mask = X.KeyPressMask)
 
@@ skipping 24 matching lines @@
     gobject.io_add_watch(root.display, gobject.IO_IN, handle_xevent)
 
 
 def main(test_list, status_file_path, control_pid):
     '''This process is launched by the autotest suite_Factory control
     process, which should be identified by the <control pid> cmdline
     argument.  When operators press keyboard shortcuts, the shortcut
     value is logged with log_shared_data() and a SIGUSR1 is sent to
     the control program.'''
 
-    status_map = factory.StatusMap(test_list, status_file_path)
+    test_db = factory.TestDatabase(test_list)
 
     window = gtk.Window(gtk.WINDOW_TOPLEVEL)
     window.connect('destroy', lambda _: gtk.main_quit())
     window.modify_bg(gtk.STATE_NORMAL, ful.BLACK)
 
     screen = window.get_screen()
     if (screen is None):
         log('ERROR: communication with the X server is not working, ' +
             'could not find a working screen.  UI exiting.')
         sys.exit(1)
 
     screen_size = (screen.get_width(), screen.get_height())
     window.set_size_request(*screen_size)
 
     label_trough = gtk.VBox()
     label_trough.set_spacing(0)
 
     rhs_box = gtk.EventBox()
     rhs_box.modify_bg(gtk.STATE_NORMAL, _LABEL_TROUGH_COLOR)
     rhs_box.add(label_trough)
 
     console_box = gtk.EventBox()
     console_box.set_size_request(-1, 180)
     console_box.modify_bg(gtk.STATE_NORMAL, ful.BLACK)
 
     test_widget_box = gtk.Alignment(xalign=0.5, yalign=0.5)
     test_widget_box.set_size_request(-1, -1)
 
-    ui_state = UiState(status_map, test_widget_box)
-
     lhs_box = gtk.VBox()
     lhs_box.pack_end(console_box, False, False)
     lhs_box.pack_start(test_widget_box)
     lhs_box.pack_start(ful.make_hsep(3), False, False)
 
     base_box = gtk.HBox()
     base_box.pack_end(rhs_box, False, False)
     base_box.pack_end(ful.make_vsep(3), False, False)
     base_box.pack_start(lhs_box)
 
     window.connect('key-release-event', handle_key_release_event)
     window.add_events(gtk.gdk.KEY_RELEASE_MASK)
 
-    gobject.timeout_add(_STATUS_REFRESH_MS, refresh_status,
-                        status_map, ui_state)
+    ui_state = UiState(test_widget_box, test_db.get_automated_sequences())
 
     for test in test_list:
         label_box = TestLabelBox(test)
-        status_map.set_label_box(test, label_box)
+        ui_state.set_label_box(test, label_box)
         label_trough.pack_start(label_box, False, False)
         label_trough.pack_start(ful.make_hsep(), False, False)
 
     window.add(base_box)
     window.show_all()
 
-    grab_shortcut_keys(status_map.test_db.kbd_shortcut_set, control_pid)
+    status_map = factory.StatusMap(
+        test_list, status_file_path, test_db=test_db,
+        status_change_callback=ui_state.status_change_callback)
+
+    gobject.timeout_add(_STATUS_REFRESH_MS, refresh_status,
+                        status_map, test_db, ui_state)
+
+    kbd_shortcut_db = factory.KbdShortcutDatabase(test_list, test_db)
+    grab_shortcut_keys(kbd_shortcut_db.get_shortcut_keys(), control_pid)
 
     ful.hide_cursor(window.window)
 
     test_widget_allocation = test_widget_box.get_allocation()
     test_widget_size = (test_widget_allocation.width,
                         test_widget_allocation.height)
     factory.log_shared_data('test_widget_size', test_widget_size)
 
     console = Console(console_box.get_allocation())
 
@@ skipping 10 matching lines @@
 
     if len(sys.argv) != 4:
         print ('usage: %s <test list path> <status file path> <control pid>' %
                sys.argv[0])
     test_list_path, status_file_path, control_pid_str = sys.argv[1:]
     control_pid = int(control_pid_str)
 
     execfile(test_list_path)
 
     main(TEST_LIST, status_file_path, control_pid)