[Telemetry refactor] Migrate clients to new JavaScript API (batch 3)

content/test/gpu/gpu_tests/gpu_process_integration_test.py

 # Copyright 2017 The Chromium 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
 import os
 import sys
 
 from gpu_tests import gpu_integration_test
 from gpu_tests import gpu_process_expectations
@@ skipping 124 matching lines @@
     url = self.UrlOfStaticFilePath(test_path)
     # It's crucial to use the action_runner, rather than the tab's
     # Navigate method directly. It waits for the document ready state
     # to become interactive or better, avoiding critical race
     # conditions.
     self.tab.action_runner.Navigate(
       url, script_to_evaluate_on_commit=test_harness_script)
 
   def _NavigateAndWait(self, test_path):
     self._Navigate(test_path)
-    self.tab.action_runner.WaitForJavaScriptCondition(
-      'window.domAutomationController._finished', timeout_in_seconds=10)
+    self.tab.action_runner.WaitForJavaScriptCondition2(
+      'window.domAutomationController._finished', timeout=10)
 
   def _VerifyGpuProcessPresent(self):
     tab = self.tab
-    has_gpu_channel_js = 'chrome.gpuBenchmarking.hasGpuChannel()'
-    has_gpu_channel = tab.EvaluateJavaScript(has_gpu_channel_js)
-    if not has_gpu_channel:
+    if not tab.EvaluateJavaScript2('chrome.gpuBenchmarking.hasGpuChannel()'):
       self.fail('No GPU channel detected')
 
   def _ValidateDriverBugWorkaroundsImpl(self, process_kind, is_expected,
                                     workaround_name):
     tab = self.tab
     if process_kind == "browser_process":
-      gpu_driver_bug_workarounds = tab.EvaluateJavaScript(
+      gpu_driver_bug_workarounds = tab.EvaluateJavaScript2(
         'GetDriverBugWorkarounds()')
     elif process_kind == "gpu_process":
-      gpu_driver_bug_workarounds = tab.EvaluateJavaScript(
+      gpu_driver_bug_workarounds = tab.EvaluateJavaScript2(
         'chrome.gpuBenchmarking.getGpuDriverBugWorkarounds()')
 
     is_present = workaround_name in gpu_driver_bug_workarounds
     failure = False
     if is_expected and not is_present:
       failure = True
       error_message = "is missing"
     elif not is_expected and is_present:
       failure = True
       error_message = "is not expected"
 
     if failure:
       print 'Test failed. Printing page contents:'
-      print tab.EvaluateJavaScript('document.body.innerHTML')
+      print tab.EvaluateJavaScript2('document.body.innerHTML')
       self.fail('%s %s in %s workarounds: %s'
                 % (workaround_name, error_message, process_kind,
                    gpu_driver_bug_workarounds))
 
   def _ValidateDriverBugWorkarounds(self, expected_workaround,
                                     unexpected_workaround):
     if not expected_workaround and not unexpected_workaround:
       return
     if expected_workaround:
       self._ValidateDriverBugWorkaroundsImpl(
         "browser_process", True, expected_workaround)
       self._ValidateDriverBugWorkaroundsImpl(
         "gpu_process", True, expected_workaround)
     if unexpected_workaround:
       self._ValidateDriverBugWorkaroundsImpl(
         "browser_process", False, unexpected_workaround)
       self._ValidateDriverBugWorkaroundsImpl(
         "gpu_process", False, unexpected_workaround)
 
   # This can only be called from one of the tests, i.e., after the
   # browser's been brought up once.
   def _RunningOnAndroid(self):
     options = self.__class__._original_finder_options.browser_options
     return options.browser_type.startswith('android')
 
   def _CompareAndCaptureDriverBugWorkarounds(self):
     tab = self.tab
-    has_gpu_process_js = 'chrome.gpuBenchmarking.hasGpuProcess()'
-    if not tab.EvaluateJavaScript(has_gpu_process_js):
+    if not tab.EvaluateJavaScript2('chrome.gpuBenchmarking.hasGpuProcess()'):
       self.fail('No GPU process detected')
 
-    has_gpu_channel_js = 'chrome.gpuBenchmarking.hasGpuChannel()'
-    if not tab.EvaluateJavaScript(has_gpu_channel_js):
+    if not tab.EvaluateJavaScript2('chrome.gpuBenchmarking.hasGpuChannel()'):
       self.fail('No GPU channel detected')
 
-    browser_list = tab.EvaluateJavaScript('GetDriverBugWorkarounds()')
-    gpu_list = tab.EvaluateJavaScript(
+    browser_list = tab.EvaluateJavaScript2('GetDriverBugWorkarounds()')
+    gpu_list = tab.EvaluateJavaScript2(
       'chrome.gpuBenchmarking.getGpuDriverBugWorkarounds()')
 
     diff = set(browser_list).symmetric_difference(set(gpu_list))
     if len(diff) > 0:
       print 'Test failed. Printing page contents:'
-      print tab.EvaluateJavaScript('document.body.innerHTML')
+      print tab.EvaluateJavaScript2('document.body.innerHTML')
       self.fail('Browser and GPU process list of driver bug'
                 'workarounds are not equal: %s != %s, diff: %s' %
                 (browser_list, gpu_list, list(diff)))
 
-    basic_infos = tab.EvaluateJavaScript('browserBridge.gpuInfo.basic_info')
+    basic_infos = tab.EvaluateJavaScript2('browserBridge.gpuInfo.basic_info')
     disabled_gl_extensions = None
     for info in basic_infos:
       if info['description'].startswith('Disabled Extensions'):
         disabled_gl_extensions = info['value']
         break
 
     return gpu_list, disabled_gl_extensions
 
   def _VerifyActiveAndInactiveGPUs(
       self, expected_active_gpu, expected_inactive_gpus):
     tab = self.tab
-    basic_infos = tab.EvaluateJavaScript('browserBridge.gpuInfo.basic_info')
+    basic_infos = tab.EvaluateJavaScript2('browserBridge.gpuInfo.basic_info')
     active_gpu = []
     inactive_gpus = []
     index = 0
     for info in basic_infos:
       description = info['description']
       value = info['value']
       if description.startswith('GPU%d' % index) and value.startswith('VENDOR'):
         if value.endswith('*ACTIVE*'):
           active_gpu.append(value)
         else:
@@ skipping 67 matching lines @@
         '--gpu-testing-device-id=0x0de1',
         '--gpu-testing-gl-vendor=VMware',
         '--gpu-testing-gl-renderer=softpipe',
         '--gpu-testing-gl-version="2.1 Mesa 10.1"'])
     elif sys.platform == 'darwin':
       # Hit id 112 from kSoftwareRenderingListJson.
       self.RestartBrowserIfNecessaryWithArgs([
         '--gpu-testing-vendor-id=0x8086',
         '--gpu-testing-device-id=0x0116'])
     self._Navigate(test_path)
-    has_gpu_process_js = 'chrome.gpuBenchmarking.hasGpuProcess()'
-    has_gpu_process = self.tab.EvaluateJavaScript(has_gpu_process_js)
-    if has_gpu_process:
+    if self.tab.EvaluateJavaScript2('chrome.gpuBenchmarking.hasGpuProcess()'):
       self.fail('GPU process detected')
 
   def _GpuProcess_driver_bug_workarounds_in_gpu_process(self, test_path):
     self.RestartBrowserIfNecessaryWithArgs([
       '--use_gpu_driver_workaround_for_testing'])
     self._Navigate(test_path)
     self._ValidateDriverBugWorkarounds(
       'use_gpu_driver_workaround_for_testing', None)
 
   def _GpuProcess_readback_webgl_gpu_process(self, test_path):
     # This test was designed to only run on desktop Linux.
     options = self.__class__._original_finder_options.browser_options
     is_platform_android = options.browser_type.startswith('android')
     if sys.platform.startswith('linux') and not is_platform_android:
       # Hit id 110 from kSoftwareRenderingListJson.
       self.RestartBrowserIfNecessaryWithArgs([
         '--gpu-testing-vendor-id=0x10de',
         '--gpu-testing-device-id=0x0de1',
         '--gpu-testing-gl-vendor=VMware',
         '--gpu-testing-gl-renderer=Gallium 0.4 ' \
         'on llvmpipe (LLVM 3.4, 256 bits)',
         '--gpu-testing-gl-version="3.0 Mesa 11.2"'])
       self._Navigate(test_path)
-      feature_status_js = 'browserBridge.gpuInfo.featureStatus.featureStatus'
-      feature_status_list = self.tab.EvaluateJavaScript(feature_status_js)
+      feature_status_list = self.tab.EvaluateJavaScript2(
+          'browserBridge.gpuInfo.featureStatus.featureStatus')
       result = True
       for name, status in feature_status_list.items():
         if name == 'multiple_raster_threads':
           result = result and status == 'enabled_on'
         elif name == 'native_gpu_memory_buffers':
           result = result and status == 'disabled_software'
         elif name == 'webgl':
           result = result and status == 'enabled_readback'
         elif name == 'webgl2':
           result = result and status == 'unavailable_off'
@@ skipping 73 matching lines @@
                         recorded_disabled_gl_extensions)
     self.RestartBrowserIfNecessaryWithArgs(browser_args)
     self._Navigate(test_path)
     self._VerifyGpuProcessPresent()
     new_workarounds, new_disabled_gl_extensions = (
       self._CompareAndCaptureDriverBugWorkarounds())
     diff = set(recorded_workarounds).symmetric_difference(new_workarounds)
     tab = self.tab
     if len(diff) > 0:
       print 'Test failed. Printing page contents:'
-      print tab.EvaluateJavaScript('document.body.innerHTML')
+      print tab.EvaluateJavaScript2('document.body.innerHTML')
       self.fail(
         'GPU process and expected list of driver bug '
         'workarounds are not equal: %s != %s, diff: %s' %
         (recorded_workarounds, new_workarounds, list(diff)))
     if recorded_disabled_gl_extensions != new_disabled_gl_extensions:
       print 'Test failed. Printing page contents:'
-      print tab.EvaluateJavaScript('document.body.innerHTML')
+      print tab.EvaluateJavaScript2('document.body.innerHTML')
       self.fail(
         'The expected disabled gl extensions are '
         'incorrect: %s != %s:' %
         (recorded_disabled_gl_extensions, new_disabled_gl_extensions))
 
   def _GpuProcess_skip_gpu_process(self, test_path):
     self.RestartBrowserIfNecessaryWithArgs([
       '--disable-gpu',
       '--skip-gpu-data-loading'])
     self._Navigate(test_path)
-    has_gpu_process_js = 'chrome.gpuBenchmarking.hasGpuProcess()'
-    has_gpu_process = self.tab.EvaluateJavaScript(has_gpu_process_js)
-    if has_gpu_process:
+    if self.tab.EvaluateJavaScript2('chrome.gpuBenchmarking.hasGpuProcess()'):
       self.fail('GPU process detected')
 
   def _GpuProcess_identify_active_gpu1(self, test_path):
     self.RestartBrowserIfNecessaryWithArgs([
       '--gpu-testing-vendor-id=0x8086',
       '--gpu-testing-device-id=0x040a',
       '--gpu-testing-secondary-vendor-ids=0x10de',
       '--gpu-testing-secondary-device-ids=0x0de1',
       '--gpu-testing-gl-vendor=nouveau'])
     self._Navigate(test_path)
@@ skipping 46 matching lines @@
       '--gpu-testing-device-id=0x0de1',
       '--gpu-testing-gl-vendor=VMware',
       '--gpu-testing-gl-renderer=SVGA3D',
       '--gpu-testing-gl-version=2.1 Mesa 10.1'])
     self._Navigate(test_path)
     self._VerifyGpuProcessPresent()
 
 def load_tests(loader, tests, pattern):
   del loader, tests, pattern  # Unused.
   return gpu_integration_test.LoadAllTestsInModule(sys.modules[__name__])