External Extension for power_LoadTest

client/site_tests/power_LoadTest/power_LoadTest.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.
 
 import logging, os, re, shutil, time
-from autotest_lib.client.bin import site_ui_test
+from autotest_lib.client.bin import site_ui_test, site_login
 from autotest_lib.client.common_lib import error, site_httpd, \
                             site_power_status, site_ui, utils
 
 params_dict = {
     'test_time_ms': '_mseconds',
     'should_scroll': '_should_scroll',
     'should_scroll_up': '_should_scroll_up',
     'scroll_loop': '_scroll_loop',
     'scroll_interval_ms': '_scroll_interval_ms',
     'scroll_by_pixels': '_scroll_by_pixels',
 }
 
 
 class power_LoadTest(site_ui_test.UITest):
-    version = 1
+    version = 2
 
-    def setup(self):
-        # TODO(snanda): Remove once power manager is in
-        shutil.copy(os.path.join(os.environ['SYSROOT'], 'usr/bin/xset'),
-                                 self.bindir)
-        if not os.path.exists(self.srcdir):
-            os.mkdir(self.srcdir)
+    def ensure_login_complete(self):
+        """
+        Override site_ui_test.UITest's ensure_login_complete.
+        Do not use auth server and local dns for our test. We need to be
+        able to reach the web.
+        """
+        pass
 
-
-    def run_once(self, percent_initial_charge_min=None,
+    def initialize(self, creds='$default', percent_initial_charge_min=None,
                  check_network=True, loop_time=3600, loop_count=1,
                  should_scroll='true', should_scroll_up='true',
                  scroll_loop='false', scroll_interval_ms='10000',
                  scroll_by_pixels='600', low_battery_threshold=3,
                  verbose=True):
+
         """
         percent_initial_charge_min: min battery charge at start of test
         check_network: check that Ethernet interface is not running
         loop_count: number of times to loop the test for
         loop_time: length of time to run the test for in each loop
         should_scroll: should the extension scroll pages
         should_scroll_up: should scroll in up direction
         scroll_loop: continue scrolling indefinitely
         scroll_interval_ms: how often to scoll
         scroll_by_pixels: number of pixels to scroll each time
         """
-
         self._loop_time = loop_time
         self._loop_count = loop_count
         self._mseconds = self._loop_time * 1000
         self._verbose = verbose
         self._low_battery_threshold = low_battery_threshold
         self._should_scroll = should_scroll
         self._should_scroll_up = should_scroll_up
         self._scroll_loop = scroll_loop
         self._scroll_interval_ms = scroll_interval_ms
         self._scroll_by_pixels = scroll_by_pixels
         self._tmp_keyvals = {}
-
         self._power_status = site_power_status.get_status()
 
         # verify that initial conditions are met:
         if self._power_status.linepower[0].online:
             raise error.TestError(
                 'Running on AC power. Please remove AC power cable')
 
         percent_initial_charge = self._percent_current_charge()
         if percent_initial_charge_min and percent_initial_charge < \
                                           percent_initial_charge_min:
@@ skipping 14 matching lines @@
                                              utils.system_output(cmd).rstrip())
 
         cmd = 'backlight-tool --get_brightness'
         self._tmp_keyvals['level_backlight_current'] = int(
                                              utils.system_output(cmd).rstrip())
 
         # disable screen locker and powerd
         os.system('stop screen-locker')
         os.system('stop powerd')
 
-        # disable screen blanking. Stopping screen-locker isn't
-        # synchronous :(. Add a sleep for now, till powerd comes around
-        # and fixes all this for us.
-        time.sleep(5)
-        site_ui.xsystem(os.path.join(self.bindir, 'xset') + ' s off')
-        site_ui.xsystem(os.path.join(self.bindir, 'xset') + ' dpms 0 0 0')
-        site_ui.xsystem(os.path.join(self.bindir, 'xset') + ' -dpms')
-
         # fix up file perms for the power test extension so that chrome
         # can access it
         os.system('chmod -R 755 %s' % self.bindir)
 
+
+        # TODO (bleung) :
+        # The new external extension packed crx means we can't pass params by
+        # modifying params.js
+        # Possible solution :
+        # - modify extension to not start until we poke it from the browser.
+        #       then pass through URL.
+
         # write test parameters to the power extension's params.js file
-        self._ext_path = os.path.join(self.bindir, 'extension')
-        self._write_ext_params()
+        # self._ext_path = os.path.join(self.bindir, 'extension')
+        # self._write_ext_params()
+
+        # copy external_extensions.json to known location
+        self._json_path = os.path.join(self.bindir, '..')
+        shutil.copy(os.path.join(self.bindir, 'external_extensions.json'),
+                                 self._json_path)
 
         # setup a HTTP Server to listen for status updates from the power
         # test extension
         self._testServer = site_httpd.HTTPListener(8001, docroot=self.bindir)
         self._testServer.run()
 
         # initialize various interesting power related stats
         self._usb_stats = site_power_status.USBSuspendStats()
         self._cpufreq_stats = site_power_status.CPUFreqStats()
         self._cpuidle_stats = site_power_status.CPUIdleStats()
 
 
         self._usb_stats.refresh()
         self._cpufreq_stats.refresh()
         self._cpuidle_stats.refresh()
         self._power_status.refresh()
 
         self._ah_charge_start = self._power_status.battery[0].charge_now
         self._wh_energy_start = self._power_status.battery[0].energy
 
+        # from site_ui_test.UITest.initialize, sans authserver & local dns.
+        (self.username, self.password) = self._UITest__resolve_creds(creds)
+       
+
+    def run_once(self):
+
         t0 = time.time()
 
         for i in range(self._loop_count):
             # the power test extension will report its status here
             latch = self._testServer.add_wait_url('/status')
 
-            # launch chrome with power test extension
-            args = '--load-extension=%s' % self._ext_path
-            session = site_ui.ChromeSession(args, clean_state=False)
+            if site_login.logged_in():
+                site_login.attempt_logout()
+            # the act of logging in will launch chrome with external extension.
+            self.login(self.username, self.password)
 
             low_battery = self._do_wait(self._verbose, self._loop_time,
-                                        latch, session)
-            session.close()
+                                        latch)
 
             if self._verbose:
                 logging.debug('loop %d completed' % i)
                 logging.debug(utils.system_output('xset q'))
 
             if low_battery:
                 logging.info('Exiting due to low battery')
                 break
 
         t1 = time.time()
@@ skipping 40 matching lines @@
 
         keyvals['a_current_rate'] = keyvals['ah_charge_used'] * 60 / \
                                     keyvals['minutes_battery_life']
         keyvals['w_energy_rate'] = keyvals['wh_energy_used'] * 60 / \
                                    keyvals['minutes_battery_life']
 
         self.write_perf_keyval(keyvals)
 
 
     def cleanup(self):
+        # remove json file after test to stop external extension launch.
+        os.system('rm -f %s' %
+                os.path.join(self._json_path, 'external_extensions.json'))
         # re-enable screen locker and powerd. This also re-enables dpms.
         os.system('start powerd')
         os.system('start screen-locker')
-
+        if site_login.logged_in():
+            site_login.attempt_logout()
 
     def _is_network_iface_running(self, name):
         try:
             out = utils.system_output('ifconfig %s' % name)
         except error.CmdError, e:
             logging.info(e)
             return False
 
         match = re.search('RUNNING', out, re.S)
         return match
@@ skipping 10 matching lines @@
         for k in params_dict:
             data += template % (k, getattr(self, params_dict[k]))
 
         filename = os.path.join(self._ext_path, 'params.js')
         utils.open_write_close(filename, data)
 
         logging.debug('filename ' + filename)
         logging.debug(data)
 
 
-    def _do_wait(self, verbose, seconds, latch, session):
+    def _do_wait(self, verbose, seconds, latch):
         latched = False
         low_battery = False
         total_time = seconds + 60
         elapsed_time = 0
         wait_time = 60
 
         while elapsed_time < total_time:
             time.sleep(wait_time)
             elapsed_time += wait_time
 
@@ skipping 19 matching lines @@
             for e in form_data:
                 key = 'ext_' + e
                 if key in self._tmp_keyvals:
                     self._tmp_keyvals[key] += form_data[e]
                 else:
                     self._tmp_keyvals[key] = form_data[e]
         else:
             logging.debug("Didn't get status back from power extension")
 
         return low_battery