Update reference to page_test module to use legacy_page_test module

content/test/gpu/page_sets/gpu_process_tests.py

 # Copyright 2014 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 sys
 from telemetry.story import story_set as story_set_module
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 
 from gpu_tests import gpu_test_base
 
 class GpuProcessSharedPageState(gpu_test_base.GpuSharedPageState):
 
   gpu_switches = ['--gpu-no-complete-info-collection',
                   '--gpu-testing-os-version',
                   '--gpu-testing-vendor-id',
                   '--gpu-testing-device-id',
                   '--gpu-testing-secondary-vendor-ids',
@@ skipping 39 matching lines @@
       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:
           inactive_gpus.append(value)
         index += 1
 
     if active_gpu != self.active_gpu:
-      raise page_test.Failure('Active GPU field is wrong %s' % active_gpu)
+      raise legacy_page_test.Failure(
+          'Active GPU field is wrong %s' % active_gpu)
 
     if inactive_gpus != self.inactive_gpus:
-      raise page_test.Failure('Inactive GPU field is wrong %s' % inactive_gpus)
+      raise legacy_page_test.Failure(
+          'Inactive GPU field is wrong %s' % inactive_gpus)
 
 
 class DriverBugWorkaroundsTestsPage(gpu_test_base.PageBase):
   def __init__(self, page_set=None, name='',
                shared_page_state_class=None,
                expectations=None,
                expected_workaround=None,
                unexpected_workaround=None):
     super(DriverBugWorkaroundsTestsPage, self).__init__(
         url='chrome:gpu',
@@ skipping 18 matching lines @@
     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')
-      raise page_test.Failure('%s %s in Browser process workarounds: %s' \
+      raise legacy_page_test.Failure('%s %s in Browser process workarounds: %s'
         % (workaround_name, error_message, gpu_driver_bug_workarounds))
 
   def Validate(self, tab, results):
     if not self.expected_workaround and not self.unexpected_workaround:
       return
 
     if self.expected_workaround:
       self._Validate(tab, "browser_process", True, self.expected_workaround)
       self._Validate(tab, "gpu_process", True, self.expected_workaround)
 
     if self.unexpected_workaround:
       self._Validate(tab, "browser_process", False, self.unexpected_workaround)
       self._Validate(tab, "gpu_process", False, self.unexpected_workaround)
 
 
 class EqualBugWorkaroundsBasePage(gpu_test_base.PageBase):
   def __init__(self, name=None, page_set=None, shared_page_state_class=None,
                expectations=None):
     super(EqualBugWorkaroundsBasePage, self).__init__(
       url='chrome:gpu',
       name=name,
       page_set=page_set,
       shared_page_state_class=shared_page_state_class,
       expectations=expectations)
 
   def Validate(self, tab, results):
     has_gpu_process_js = 'chrome.gpuBenchmarking.hasGpuProcess()'
     if not tab.EvaluateJavaScript(has_gpu_process_js):
-      raise page_test.Failure('No GPU process detected')
+      raise legacy_page_test.Failure('No GPU process detected')
 
     has_gpu_channel_js = 'chrome.gpuBenchmarking.hasGpuChannel()'
     if not tab.EvaluateJavaScript(has_gpu_channel_js):
-      raise page_test.Failure('No GPU channel detected')
+      raise legacy_page_test.Failure('No GPU channel detected')
 
     browser_list = tab.EvaluateJavaScript('GetDriverBugWorkarounds()')
     gpu_list = tab.EvaluateJavaScript( \
       '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')
-      raise page_test.Failure('Browser and GPU process list of driver bug' \
-        'workarounds are not equal: %s != %s, diff: %s' % \
+      raise legacy_page_test.Failure(
+        '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')
     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
@@ skipping 28 matching lines @@
   def __init__(self, story_set, expectations):
     super(GpuInfoCompletePage, self).__init__(
       url='file://../../data/gpu/functional_3d_css.html',
       name='GpuProcess.gpu_info_complete',
       story_set=story_set,
       expectations=expectations)
 
   def Validate(self, tab, results):
     # Regression test for crbug.com/454906
     if not tab.browser.supports_system_info:
-      raise page_test.Failure('Browser must support system info')
+      raise legacy_page_test.Failure('Browser must support system info')
     system_info = tab.browser.GetSystemInfo()
     if not system_info.gpu:
-      raise page_test.Failure('Target machine must have a GPU')
+      raise legacy_page_test.Failure('Target machine must have a GPU')
     if not system_info.gpu.aux_attributes:
-      raise page_test.Failure('Browser must support GPU aux attributes')
+      raise legacy_page_test.Failure('Browser must support GPU aux attributes')
     if not 'gl_renderer' in system_info.gpu.aux_attributes:
-      raise page_test.Failure('Browser must have gl_renderer in aux attribs')
+      raise legacy_page_test.Failure(
+          'Browser must have gl_renderer in aux attribs')
     if len(system_info.gpu.aux_attributes['gl_renderer']) <= 0:
-      raise page_test.Failure('Must have a non-empty gl_renderer string')
+      raise legacy_page_test.Failure(
+          'Must have a non-empty gl_renderer string')
 
 
 class NoGpuProcessSharedPageState(GpuProcessSharedPageState):
   def __init__(self, test, finder_options, story_set):
     super(NoGpuProcessSharedPageState, self).__init__(
       test, finder_options, story_set)
     options = finder_options.browser_options
 
     if options.browser_type.startswith('android'):
       # Android doesn't support starting up the browser without any
@@ skipping 29 matching lines @@
       url='about:blank',
       name='GpuProcess.no_gpu_process',
       page_set=story_set,
       shared_page_state_class=NoGpuProcessSharedPageState,
       expectations=expectations)
 
   def Validate(self, tab, results):
     has_gpu_process_js = 'chrome.gpuBenchmarking.hasGpuProcess()'
     has_gpu_process = tab.EvaluateJavaScript(has_gpu_process_js)
     if has_gpu_process:
-      raise page_test.Failure('GPU process detected')
+      raise legacy_page_test.Failure('GPU process detected')
 
 
 class SoftwareGpuProcessSharedPageState(GpuProcessSharedPageState):
   def __init__(self, test, finder_options, story_set):
     super(SoftwareGpuProcessSharedPageState, self).__init__(
       test, finder_options, story_set)
     options = finder_options.browser_options
 
     # Hit exception from id 50 from kSoftwareRenderingListJson.
     options.AppendExtraBrowserArgs('--gpu-testing-vendor-id=0x10de')
@@ skipping 31 matching lines @@
       url='chrome:gpu',
       name='GpuProcess.skip_gpu_process',
       page_set=story_set,
       shared_page_state_class=SkipGpuProcessSharedPageState,
       expectations=expectations)
 
   def Validate(self, tab, results):
     has_gpu_process_js = 'chrome.gpuBenchmarking.hasGpuProcess()'
     has_gpu_process = tab.EvaluateJavaScript(has_gpu_process_js)
     if has_gpu_process:
-      raise page_test.Failure('GPU process detected')
+      raise legacy_page_test.Failure('GPU process detected')
 
 
 class DriverBugWorkaroundsShared(GpuProcessSharedPageState):
   def __init__(self, test, finder_options, story_set):
     super(DriverBugWorkaroundsShared, self).__init__(
       test, finder_options, story_set)
     options = finder_options.browser_options
     options.AppendExtraBrowserArgs('--use_gpu_driver_workaround_for_testing')
 
 
@@ skipping 230 matching lines @@
           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'
         else:
           result = result and status == 'unavailable_software'
       if not result:
-        raise page_test.Failure('WebGL readback setup failed: %s' \
+        raise legacy_page_test.Failure('WebGL readback setup failed: %s' \
           % feature_status_list)
 
 
 class HasTransparentVisualsShared(GpuProcessSharedPageState):
   def __init__(self, test, finder_options, story_set):
     super(HasTransparentVisualsShared, self).__init__(
       test, finder_options, story_set)
     options = finder_options.browser_options
     if sys.platform.startswith('linux'):
       # Hit id 173 from kGpuDriverBugListJson.
@@ skipping 124 matching lines @@
     if self.expected_workarounds is None:
       return
 
     recorded_info = super(OnlyOneWorkaroundPage, self).Validate(tab, results)
     gpu_list, disabled_gl_extensions = recorded_info
 
     diff = set(self.expected_workarounds).symmetric_difference(set(gpu_list))
     if len(diff) > 0:
       print 'Test failed. Printing page contents:'
       print tab.EvaluateJavaScript('document.body.innerHTML')
-      raise page_test.Failure('GPU process and expected list of driver bug' \
-        'workarounds are not equal: %s != %s, diff: %s' % \
+      raise legacy_page_test.Failure(
+        'GPU process and expected list of driver bug'
+        'workarounds are not equal: %s != %s, diff: %s' %
         (self.expected_workarounds, gpu_list, list(diff)))
 
     if self.expected_disabled_exts != disabled_gl_extensions:
       print 'Test failed. Printing page contents:'
       print tab.EvaluateJavaScript('document.body.innerHTML')
-      raise page_test.Failure('The expected disabled gl extensions are ' \
-        'incorrect: %s != %s:' % \
+      raise legacy_page_test.Failure(
+        'The expected disabled gl extensions are '
+        'incorrect: %s != %s:' %
         (self.expected_disabled_exts, disabled_gl_extensions))
 
 
 class GpuProcessTestsStorySet(story_set_module.StorySet):
 
   """ Tests that accelerated content triggers the creation of a GPU process """
 
   def __init__(self, expectations, is_platform_android):
     super(GpuProcessTestsStorySet, self).__init__(
       serving_dirs=set(['../../../../content/test/data']))
@@ skipping 35 matching lines @@
 
       # There is currently no entry in kSoftwareRenderingListJson that enables
       # a software GL driver on Android.
       self.AddStory(SoftwareGpuProcessPage(self, expectations))
 
   @property
   def allow_mixed_story_states(self):
     # Return True here in order to be able to run pages with different browser
     # command line arguments.
     return True