diff --git a/client/site_tests/graphics_WebGLAquarium/graphics_WebGLAquarium.py b/client/site_tests/graphics_WebGLAquarium/graphics_WebGLAquarium.py
index de48a9d..ba0aab2 100644
--- a/client/site_tests/graphics_WebGLAquarium/graphics_WebGLAquarium.py
+++ b/client/site_tests/graphics_WebGLAquarium/graphics_WebGLAquarium.py
@@ -1,7 +1,6 @@
 # Copyright (c) 2013 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.
-
 """This is a client side WebGL aquarium test."""
 
 import logging
@@ -16,7 +15,6 @@
 from autotest_lib.client.cros import power_status, power_utils
 from autotest_lib.client.cros import service_stopper
 
-
 # Minimum battery charge percentage to run the test
 BATTERY_INITIAL_CHARGED_MIN = 10
 
@@ -32,7 +30,20 @@
 class graphics_WebGLAquarium(test.test):
     """WebGL aquarium graphics test."""
     version = 1
+
+    _backlight = None
+    _power_status = None
+    _service_stopper = None
+    _test_power = False
+    active_tab = None
+    flip_stats = {}
     GSC = None
+    kernel_sampler = None
+    perf_keyval = {}
+    sampler_lock = None
+    test_duration_secs = 30
+    test_setting_num_fishes = 50
+    test_settings = {50: ('setSetting2', 2), 1000: ('setSetting6', 6),}
 
     def setup(self):
         tarball_path = os.path.join(self.bindir,
@@ -40,18 +51,9 @@
         utils.extract_tarball_to_dir(tarball_path, self.srcdir)
 
     def initialize(self):
-        self._test_power = False
-        self._backlight = None
-        self._service_stopper = None
         self.GSC = graphics_utils.GraphicsStateChecker()
-        self.test_settings = {
-                50: ('setSetting2', 2),
-                1000: ('setSetting6', 6),
-        }
-        self.perf_keyval = {}
-        self.flip_stats = {}
-        self.active_tab = None
         self.sampler_lock = threading.Lock()
+        # TODO: Create samplers for other platforms (e.g. x86).
         if utils.get_board().lower() in ['daisy', 'daisy_spring']:
             # Enable ExynosSampler on Exynos platforms.  The sampler looks for
             # exynos-drm page flip states: 'wait_kds', 'rendered', 'prepared',
@@ -61,10 +63,7 @@
             self.kernel_sampler = sampler.ExynosSampler(period=5, duration=3)
             self.kernel_sampler.sampler_callback = self.exynos_sampler_callback
             self.kernel_sampler.output_flip_stats = (
-                    self.exynos_output_flip_stats)
-        else:
-            # TODO: Create samplers for other platforms (e.g. x86).
-            self.kernel_sampler = None
+                self.exynos_output_flip_stats)
 
     def cleanup(self):
         if self._backlight:
@@ -75,7 +74,8 @@
             keyvals = self.GSC.get_memory_keyvals()
             if not self._test_power:
                 for key, val in keyvals.iteritems():
-                    self.output_perf_value(description=key, value=val,
+                    self.output_perf_value(description=key,
+                                           value=val,
                                            units='bytes',
                                            higher_is_better=False)
             self.GSC.finalize()
@@ -89,9 +89,6 @@
         @param num_fishes: The number of fishes to run the test with.
         @param perf_log: Report perf data only if it's set to True.
         """
-        if not utils.wait_for_idle_cpu(60.0, 0.1):
-            raise error.TestFail('Could not get idle CPU.')
-
         # Create tab and load page. Set the number of fishes when page is fully
         # loaded.
         tab = browser.tabs.New()
@@ -102,7 +99,8 @@
 
         # Set the number of fishes when document finishes loading.  Also reset
         # our own FPS counter and start recording FPS and rendering time.
-        utils.wait_for_value(lambda: tab.EvaluateJavaScript(
+        utils.wait_for_value(
+            lambda: tab.EvaluateJavaScript(
                 'if (document.readyState === "complete") {'
                 '  setSetting(document.getElementById("%s"), %d);'
                 '  g_crosFpsCounter.reset();'
@@ -110,35 +108,36 @@
                 '} else {'
                 '  false;'
                 '}' % self.test_settings[num_fishes]),
-                expected_value=True, timeout_sec=30)
+            expected_value=True,
+            timeout_sec=30)
 
         if self.kernel_sampler:
             self.kernel_sampler.start_sampling_thread()
         time.sleep(self.test_duration_secs)
         if self.kernel_sampler:
             self.kernel_sampler.stop_sampling_thread()
-            self.kernel_sampler.output_flip_stats(
-                    'flip_stats_%d' % num_fishes)
+            self.kernel_sampler.output_flip_stats('flip_stats_%d' % num_fishes)
             self.flip_stats = {}
 
         if perf_log:
             # Get average FPS and rendering time, then close the tab.
             avg_fps = tab.EvaluateJavaScript('g_crosFpsCounter.getAvgFps();')
             avg_render_time = tab.EvaluateJavaScript(
-                    'g_crosFpsCounter.getAvgRenderTime();')
+                'g_crosFpsCounter.getAvgRenderTime();')
             self.perf_keyval['avg_fps_%04d_fishes' % num_fishes] = avg_fps
             self.perf_keyval['avg_render_time_%04d_fishes' % num_fishes] = (
-                    avg_render_time)
-            self.output_perf_value(description='avg_fps_%04d_fishes' %
-                                   num_fishes, value=avg_fps, units='fps',
-                                   higher_is_better=True)
+                avg_render_time)
+            self.output_perf_value(
+                description='avg_fps_%04d_fishes' % num_fishes,
+                value=avg_fps,
+                units='fps',
+                higher_is_better=True)
             logging.info('%d fish(es): Average FPS = %f, '
-                         'average render time = %f',
-                         num_fishes, avg_fps, avg_render_time)
+                         'average render time = %f', num_fishes, avg_fps,
+                         avg_render_time)
 
     def run_power_test(self, browser, test_url):
-        """
-        Runs the webgl power consumption test and reports the perf results.
+        """Runs the webgl power consumption test and reports the perf results.
 
         @param browser: The Browser object to run the test with.
         @param test_url: The URL to the aquarium test site.
@@ -148,7 +147,7 @@
         self._backlight.set_default()
 
         self._service_stopper = service_stopper.ServiceStopper(
-                service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
+            service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
         self._service_stopper.stop_services()
 
         self._power_status = power_status.get_status()
@@ -156,8 +155,9 @@
         # charged.
         self._power_status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)
 
-        measurements = [power_status.SystemPower(
-                self._power_status.battery_path)]
+        measurements = [
+            power_status.SystemPower(self._power_status.battery_path)
+        ]
 
         def get_power():
             power_logger = power_status.PowerLogger(measurements)
@@ -176,10 +176,10 @@
         # avg_fps and avg_render_time in this test.
         self.perf_keyval[POWER_DESCRIPTION] = energy_rate
         self.output_perf_value(description=POWER_DESCRIPTION,
-                               value=energy_rate, units='W',
+                               value=energy_rate,
+                               units='W',
                                higher_is_better=False)
 
-
     def exynos_sampler_callback(self, sampler_obj):
         """Sampler callback function for ExynosSampler.
 
@@ -197,13 +197,13 @@
                 results[value.fb] = {}
                 for state, stats in value.states.iteritems():
                     results[value.fb][state] = (stats.avg, stats.stdev)
-                info_str.append('%s: %s %s' % (
-                        value.fb, results[value.fb]['wait_kds'][0],
-                        results[value.fb]['flipped'][0]))
+                info_str.append('%s: %s %s' %
+                                (value.fb, results[value.fb]['wait_kds'][0],
+                                 results[value.fb]['flipped'][0]))
             results['avg_fps'] = self.active_tab.EvaluateJavaScript(
-                    'g_crosFpsCounter.getAvgFps();')
+                'g_crosFpsCounter.getAvgFps();')
             results['avg_render_time'] = self.active_tab.EvaluateJavaScript(
-                    'g_crosFpsCounter.getAvgRenderTime();')
+                'g_crosFpsCounter.getAvgRenderTime();')
             self.active_tab.ExecuteJavaScript('g_crosFpsCounter.reset();')
             info_str.append('avg_fps: %s, avg_render_time: %s' %
                             (results['avg_fps'], results['avg_render_time']))
@@ -221,10 +221,10 @@
         with open(file_name, 'w') as f:
             for t in sorted(self.flip_stats.keys()):
                 if ('avg_fps' in self.flip_stats[t] and
-                    'avg_render_time' in self.flip_stats[t]):
-                    f.write('%s %s %s\n' % (
-                            t, self.flip_stats[t]['avg_fps'],
-                            self.flip_stats[t]['avg_render_time']))
+                        'avg_render_time' in self.flip_stats[t]):
+                    f.write('%s %s %s\n' %
+                            (t, self.flip_stats[t]['avg_fps'],
+                             self.flip_stats[t]['avg_render_time']))
                 for fb, stats in self.flip_stats[t].iteritems():
                     if not isinstance(fb, int):
                         continue
@@ -237,9 +237,10 @@
                                                stats['prepared'][1],
                                                stats['wait_kds'][1],
                                                stats['flipped'][1]))
-
-    def run_once(self, test_duration_secs=30,
-                 test_setting_num_fishes=(50, 1000), power_test=False):
+    def run_once(self,
+                 test_duration_secs=30,
+                 test_setting_num_fishes=(50, 1000),
+                 power_test=False):
         """Find a brower with telemetry, and run the test.
 
         @param test_duration_secs: The duration in seconds to run each scenario
@@ -252,8 +253,8 @@
 
         with chrome.Chrome(logged_in=False) as cr:
             cr.browser.platform.SetHTTPServerDirectories(self.srcdir)
-            test_url = cr.browser.platform.http_server.UrlOf(
-                os.path.join(self.srcdir, 'aquarium.html'))
+            test_url = cr.browser.platform.http_server.UrlOf(os.path.join(
+                self.srcdir, 'aquarium.html'))
             if not utils.wait_for_cool_machine():
                 raise error.TestFail('Could not get cold machine.')
             if power_test:
diff --git a/client/site_tests/graphics_WebGLClear/graphics_WebGLClear.py b/client/site_tests/graphics_WebGLClear/graphics_WebGLClear.py
index 65cecb5..2cf8a1b 100644
--- a/client/site_tests/graphics_WebGLClear/graphics_WebGLClear.py
+++ b/client/site_tests/graphics_WebGLClear/graphics_WebGLClear.py
@@ -21,7 +21,6 @@
 import os
 import time
 from autotest_lib.client.bin import test
-from autotest_lib.client.bin import utils
 from autotest_lib.client.common_lib import error
 from autotest_lib.client.common_lib.cros import chrome
 from autotest_lib.client.cros.graphics import graphics_utils
@@ -32,26 +31,26 @@
     version = 1
     GSC = None
     perf_keyval = {}
+    test_duration_secs = 30
 
     def setup(self):
         self.job.setup_dep(['webgl_clear'])
 
-
     def initialize(self):
         self.GSC = graphics_utils.GraphicsStateChecker()
         self.perf_keyval = {}
 
-
     def cleanup(self):
         if self.GSC:
             keyvals = self.GSC.get_memory_keyvals()
             for key, val in keyvals.iteritems():
-                self.output_perf_value(description=key, value=val,
-                                       units='bytes', higher_is_better=False)
+                self.output_perf_value(description=key,
+                                       value=val,
+                                       units='bytes',
+                                       higher_is_better=False)
             self.GSC.finalize()
             self.write_perf_keyval(keyvals)
 
-
     def run_clear_test(self, browser, test_url):
         """Runs the clear test from the given url.
 
@@ -65,15 +64,14 @@
         time.sleep(self.test_duration_secs)
         avg_fps = tab.EvaluateJavaScript('g_fpsTimer.averageFPS;')
         self.perf_keyval['avg_fps'] = avg_fps
-        self.output_perf_value(
-            description='avg_fps',
-            value=avg_fps, units='fps',
-            higher_is_better=True)
+        self.output_perf_value(description='avg_fps',
+                               value=avg_fps,
+                               units='fps',
+                               higher_is_better=True)
         logging.info('Average FPS = %f', avg_fps)
 
         tab.Close()
 
-
     def run_once(self, test_duration_secs=30):
         """Finds a brower with telemetry, and run the test.
 
@@ -86,12 +84,13 @@
         # in xorg.conf.
         browser_args = '--disable-gpu-vsync'
 
-        with chrome.Chrome(logged_in=False, extra_browser_args=browser_args) as cr:
+        with chrome.Chrome(logged_in=False,
+                           extra_browser_args=browser_args) as cr:
             clearsrc = os.path.join(self.autodir, 'deps', 'webgl_clear', 'src')
             if not cr.browser.platform.SetHTTPServerDirectories(clearsrc):
                 raise error.TestError('Unable to start HTTP server')
-            test_url = cr.browser.platform.http_server.UrlOf(
-                os.path.join(clearsrc, 'WebGLClear.html'))
+            test_url = cr.browser.platform.http_server.UrlOf(os.path.join(
+                clearsrc, 'WebGLClear.html'))
             self.run_clear_test(cr.browser, test_url)
 
         self.write_perf_keyval(self.perf_keyval)
diff --git a/client/site_tests/graphics_WebGLManyPlanetsDeep/graphics_WebGLManyPlanetsDeep.py b/client/site_tests/graphics_WebGLManyPlanetsDeep/graphics_WebGLManyPlanetsDeep.py
index ba825fa..4f1c37e 100644
--- a/client/site_tests/graphics_WebGLManyPlanetsDeep/graphics_WebGLManyPlanetsDeep.py
+++ b/client/site_tests/graphics_WebGLManyPlanetsDeep/graphics_WebGLManyPlanetsDeep.py
@@ -1,7 +1,6 @@
 # Copyright (c) 2013 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.
-
 """This is a client side WebGL many planets deep test."""
 
 import numpy
@@ -10,29 +9,34 @@
 
 from autotest_lib.client.bin import test
 from autotest_lib.client.common_lib import error
+from autotest_lib.client.bin import utils
 from autotest_lib.client.common_lib.cros import chrome
 from autotest_lib.client.cros.graphics import graphics_utils
 
+
 class graphics_WebGLManyPlanetsDeep(test.test):
     """WebGL many planets deep graphics test."""
     version = 1
     GSC = None
+    frame_data = {}
+    perf_keyval = {}
+    test_duration_secs = 30
 
     def setup(self):
         self.job.setup_dep(['webgl_mpd'])
         self.job.setup_dep(['graphics'])
 
     def initialize(self):
-        self.frame_data = {}
-        self.perf_keyval = {}
         self.GSC = graphics_utils.GraphicsStateChecker()
 
     def cleanup(self):
         if self.GSC:
             keyvals = self.GSC.get_memory_keyvals()
             for key, val in keyvals.iteritems():
-                self.output_perf_value(description=key, value=val,
-                                       units='bytes', higher_is_better=False)
+                self.output_perf_value(description=key,
+                                       value=val,
+                                       units='bytes',
+                                       higher_is_better=False)
             self.GSC.finalize()
             self.write_perf_keyval(keyvals)
 
@@ -58,14 +62,14 @@
         tab.ExecuteJavaScript('g_crosFpsCounter.reset();')
         while time.time() < end_time:
             frame_data = tab.EvaluateJavaScript(
-                    'g_crosFpsCounter.getFrameData();')
+                'g_crosFpsCounter.getFrameData();')
             for datum in frame_data:
                 if not datum or datum['seq'] in self.frame_data:
                     continue
                 self.frame_data[datum['seq']] = {
-                        'start_time': datum['startTime'],
-                        'frame_elapsed_time': datum['frameElapsedTime'],
-                        'js_elapsed_time': datum['jsElapsedTime']
+                    'start_time': datum['startTime'],
+                    'frame_elapsed_time': datum['frameElapsedTime'],
+                    'js_elapsed_time': datum['jsElapsedTime']
                 }
             time.sleep(1)
         tab.Close()
@@ -73,19 +77,20 @@
     def calculate_perf_values(self):
         """Calculates all the perf values from the collected data."""
         arr = numpy.array([[v['frame_elapsed_time'], v['js_elapsed_time']]
-                          for v in self.frame_data.itervalues()])
+                           for v in self.frame_data.itervalues()])
         std = arr.std(axis=0)
         mean = arr.mean(axis=0)
         avg_fps = 1000.0 / mean[0]
         self.perf_keyval.update({
-                'average_fps': avg_fps,
-                'per_frame_dt_ms_std': std[0],
-                'per_frame_dt_ms_mean': mean[0],
-                'js_render_time_ms_std': std[1],
-                'js_render_time_ms_mean': mean[1]
+            'average_fps': avg_fps,
+            'per_frame_dt_ms_std': std[0],
+            'per_frame_dt_ms_mean': mean[0],
+            'js_render_time_ms_std': std[1],
+            'js_render_time_ms_mean': mean[1]
         })
         self.output_perf_value(description='average_fps',
-                               value=avg_fps, units='fps',
+                               value=avg_fps,
+                               units='fps',
                                higher_is_better=True)
 
         with open('frame_data', 'w') as f:
@@ -94,9 +99,9 @@
                                    'js_render_time_ms'))
             for k in sorted(self.frame_data.keys()):
                 d = self.frame_data[k]
-                f.write(line_format % (k, d['start_time'],
-                                       d['frame_elapsed_time'],
-                                       d['js_elapsed_time']))
+                f.write(line_format %
+                        (k, d['start_time'], d['frame_elapsed_time'],
+                         d['js_elapsed_time']))
 
     def run_once(self, test_duration_secs=30, fullscreen=True):
         """Finds a brower with telemetry, and run the test.
@@ -109,16 +114,15 @@
 
         ext_paths = []
         if fullscreen:
-            ext_paths.append(
-                    os.path.join(self.autodir, 'deps', 'graphics',
-                                 'graphics_test_extension'))
+            ext_paths.append(os.path.join(self.autodir, 'deps', 'graphics',
+                                          'graphics_test_extension'))
 
         with chrome.Chrome(logged_in=False, extension_paths=ext_paths) as cr:
             websrc_dir = os.path.join(self.autodir, 'deps', 'webgl_mpd', 'src')
             if not cr.browser.platform.SetHTTPServerDirectories(websrc_dir):
                 raise error.TestError('Unable to start HTTP server')
-            test_url = cr.browser.platform.http_server.UrlOf(
-                    os.path.join(websrc_dir, 'ManyPlanetsDeep.html'))
+            test_url = cr.browser.platform.http_server.UrlOf(os.path.join(
+                websrc_dir, 'ManyPlanetsDeep.html'))
             self.run_many_planets_deep_test(cr.browser, test_url)
 
         self.calculate_perf_values()