Update reference to page_test module to use legacy_page_test module

BUG=606643
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel

Review-Url: https://codereview.chromium.org/2539973004
Cr-Commit-Position: refs/heads/master@{#435798}

chrome/test/media_router/telemetry/benchmarks/media_router_measurements.py

@@ -4,10 +4,10 @@
 
 from benchmarks import media_router_dialog_metric
 from benchmarks import media_router_cpu_memory_metric
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 
 
-class MediaRouterDialogTest(page_test.PageTest):
+class MediaRouterDialogTest(legacy_page_test.LegacyPageTest):
   """Performs a measurement of Media Route dialog latency."""
 
   def __init__(self):
@@ -22,7 +22,7 @@ class MediaRouterDialogTest(page_test.PageTest):
     self._metric.AddResults(tab, results)
 
 
-class MediaRouterCPUMemoryTest(page_test.PageTest):
+class MediaRouterCPUMemoryTest(legacy_page_test.LegacyPageTest):
   """Performs a measurement of Media Route CPU/memory usage."""
 
   def __init__(self):

content/test/gpu/gpu_tests/cloud_storage_test_base.py

@@ -11,7 +11,7 @@ import re
 import tempfile
 
 from py_utils import cloud_storage
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.util import image_util
 from telemetry.util import rgba_color
 
@@ -67,7 +67,7 @@ def _CompareScreenshotSamples(tab, screenshot, expectations, device_pixel_ratio,
       for y in range(y0, y1):
         if (x < 0 or y < 0 or x >= image_util.Width(screenshot) or
             y >= image_util.Height(screenshot)):
-          raise page_test.Failure(
+          raise legacy_page_test.Failure(
               ('Expected pixel location [%d, %d] is out of range on ' +
                '[%d, %d] image') %
               (x, y, image_util.Width(screenshot),
@@ -79,7 +79,7 @@ def _CompareScreenshotSamples(tab, screenshot, expectations, device_pixel_ratio,
             expectation["color"][1],
             expectation["color"][2])
         if not actual_color.IsEqual(expected_color, expectation["tolerance"]):
-          raise page_test.Failure('Expected pixel at ' + str(location) +
+          raise legacy_page_test.Failure('Expected pixel at ' + str(location) +
               ' (actual pixel (' + str(x) + ', ' + str(y) + ')) ' +
               ' to be ' +
               str(expectation["color"]) + " but got [" +
@@ -262,7 +262,7 @@ class ValidatorBase(gpu_test_base.ValidatorBase):
       _CompareScreenshotSamples(tab, screenshot, expectations,
                                 device_pixel_ratio,
                                 self.options.test_machine_name)
-    except page_test.Failure:
+    except legacy_page_test.Failure:
       image_name = self._UrlToImageName(url)
       if self.options.test_machine_name:
         self._UploadErrorImagesToCloudStorage(image_name, screenshot, None)

content/test/gpu/gpu_tests/gpu_process.py

@@ -5,7 +5,7 @@ from gpu_tests import gpu_process_expectations as expectations
 from gpu_tests import gpu_test_base
 import page_sets
 
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 
 test_harness_script = r"""
   var domAutomationController = {};
@@ -41,7 +41,7 @@ class GpuProcessValidator(gpu_test_base.ValidatorBase):
       has_gpu_channel_js = 'chrome.gpuBenchmarking.hasGpuChannel()'
       has_gpu_channel = tab.EvaluateJavaScript(has_gpu_channel_js)
       if not has_gpu_channel:
-        raise page_test.Failure('No GPU channel detected')
+        raise legacy_page_test.Failure('No GPU channel detected')
 
 class GpuProcess(gpu_test_base.TestBase):
   """Tests that accelerated content triggers the creation of a GPU process"""

content/test/gpu/gpu_tests/gpu_rasterization.py

@@ -6,7 +6,7 @@ from gpu_tests import cloud_storage_test_base
 from gpu_tests import gpu_rasterization_expectations
 import page_sets
 
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.util import image_util
 
 
@@ -39,17 +39,18 @@ class GpuRasterizationValidator(cloud_storage_test_base.ValidatorBase):
 
   def ValidateAndMeasurePage(self, page, tab, results):
     if not _DidTestSucceed(tab):
-      raise page_test.Failure('Page indicated a failure')
+      raise legacy_page_test.Failure('Page indicated a failure')
 
     if not hasattr(page, 'expectations') or not page.expectations:
-      raise page_test.Failure('Expectations not specified')
+      raise legacy_page_test.Failure('Expectations not specified')
 
     if not tab.screenshot_supported:
-      raise page_test.Failure('Browser does not support screenshot capture')
+      raise legacy_page_test.Failure(
+          'Browser does not support screenshot capture')
 
     screenshot = tab.Screenshot()
     if screenshot is None:
-      raise page_test.Failure('Could not capture screenshot')
+      raise legacy_page_test.Failure('Could not capture screenshot')
 
     device_pixel_ratio = tab.EvaluateJavaScript('window.devicePixelRatio')
     if hasattr(page, 'test_rect'):

content/test/gpu/gpu_tests/gpu_test_base.py

@@ -6,7 +6,7 @@ import logging
 
 from telemetry import benchmark as benchmark_module
 from telemetry.page import page as page_module
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.page import shared_page_state as shared_page_state_module
 from telemetry.testing import fakes
 
@@ -41,7 +41,7 @@ class TestBase(benchmark_module.Benchmark):
 
 # Provides a single subclass of PageTest in case it's useful in the
 # future.
-class ValidatorBase(page_test.PageTest):
+class ValidatorBase(legacy_page_test.LegacyPageTest):
   def __init__(self,
                needs_browser_restart_after_each_page=False,
                clear_cache_before_each_run=False):

content/test/gpu/gpu_tests/hardware_accelerated_feature.py

@@ -4,7 +4,7 @@
 from gpu_tests import gpu_test_base
 import gpu_tests.hardware_accelerated_feature_expectations as hw_expectations
 
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.story import story_set as story_set_module
 
 test_harness_script = r"""
@@ -30,7 +30,7 @@ class HardwareAcceleratedFeatureValidator(gpu_test_base.ValidatorBase):
     if not tab.EvaluateJavaScript('VerifyHardwareAccelerated("%s")' % feature):
       print 'Test failed. Printing page contents:'
       print tab.EvaluateJavaScript('document.body.innerHTML')
-      raise page_test.Failure('%s not hardware accelerated' % feature)
+      raise legacy_page_test.Failure('%s not hardware accelerated' % feature)
 
 def safe_feature_name(feature):
   return feature.lower().replace(' ', '_')

content/test/gpu/gpu_tests/maps.py

@@ -15,7 +15,7 @@ from gpu_tests import maps_expectations
 from gpu_tests import path_util
 
 from telemetry.core import util
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry import story as story_module
 from telemetry.story import story_set as story_set_module
 
@@ -37,10 +37,11 @@ class MapsValidator(cloud_storage_test_base.ValidatorBase):
     MapsValidator.SpinWaitOnRAF(tab, 3)
 
     if not tab.screenshot_supported:
-      raise page_test.Failure('Browser does not support screenshot capture')
+      raise legacy_page_test.Failure(
+          'Browser does not support screenshot capture')
     screenshot = tab.Screenshot(5)
     if screenshot is None:
-      raise page_test.Failure('Could not capture screenshot')
+      raise legacy_page_test.Failure('Could not capture screenshot')
 
     dpr = tab.EvaluateJavaScript('window.devicePixelRatio')
     print 'Maps\' devicePixelRatio is ' + str(dpr)

content/test/gpu/gpu_tests/screenshot_sync.py

@@ -8,7 +8,7 @@ from gpu_tests import gpu_test_base
 from gpu_tests import path_util
 from gpu_tests import screenshot_sync_expectations
 
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.story import story_set as story_set_module
 from telemetry.util import image_util
 from telemetry.util import rgba_color
@@ -41,7 +41,8 @@ class ScreenshotSyncValidator(gpu_test_base.ValidatorBase):
 
   def ValidateAndMeasurePage(self, page, tab, results):
     if not tab.screenshot_supported:
-      raise page_test.Failure('Browser does not support screenshot capture')
+      raise legacy_page_test.Failure(
+          'Browser does not support screenshot capture')
 
     def CheckColorMatchAtLocation(expectedRGB, screenshot, x, y):
       pixel_value = image_util.GetPixelColor(screenshot, x, y)
@@ -50,7 +51,7 @@ class ScreenshotSyncValidator(gpu_test_base.ValidatorBase):
                          'got (%d, %d, %d)') % (
                              x, y, expectedRGB.r, expectedRGB.g, expectedRGB.b,
                              pixel_value.r, pixel_value.g, pixel_value.b)
-        raise page_test.Failure(error_message)
+        raise legacy_page_test.Failure(error_message)
 
     def CheckScreenshot():
       canvasRGB = rgba_color.RgbaColor(random.randint(0, 255),

content/test/gpu/gpu_tests/trace_test.py

@@ -5,7 +5,7 @@ from gpu_tests import gpu_test_base
 from gpu_tests import trace_test_expectations
 import page_sets
 
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.timeline import model as model_module
 from telemetry.timeline import tracing_config
 
@@ -60,7 +60,7 @@ class TraceValidatorBase(gpu_test_base.ValidatorBase):
           event.category == category_name):
         break
     else:
-      raise page_test.Failure(self._FormatException(category_name))
+      raise legacy_page_test.Failure(self._FormatException(category_name))
 
   def CustomizeBrowserOptions(self, options):
     options.AppendExtraBrowserArgs('--enable-logging')

content/test/gpu/page_sets/gpu_process_tests.py

@@ -3,7 +3,7 @@
 # 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
 
@@ -63,10 +63,12 @@ class IdentifyActiveGpuPageBase(gpu_test_base.PageBase):
         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):
@@ -105,7 +107,7 @@ class DriverBugWorkaroundsTestsPage(gpu_test_base.PageBase):
     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):
@@ -134,11 +136,11 @@ class EqualBugWorkaroundsBasePage(gpu_test_base.PageBase):
   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( \
@@ -148,8 +150,9 @@ class EqualBugWorkaroundsBasePage(gpu_test_base.PageBase):
     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')
@@ -198,16 +201,18 @@ class GpuInfoCompletePage(GpuProcessTestsPage):
   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):
@@ -257,7 +262,7 @@ class NoGpuProcessPage(gpu_test_base.PageBase):
     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):
@@ -309,7 +314,7 @@ class SkipGpuProcessPage(gpu_test_base.PageBase):
     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):
@@ -560,7 +565,7 @@ class ReadbackWebGLGpuProcessPage(gpu_test_base.PageBase):
         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)
 
 
@@ -705,15 +710,17 @@ class OnlyOneWorkaroundPage(EqualBugWorkaroundsBasePage):
     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))
 
 

tools/chrome_proxy/common/chrome_proxy_measurements.py

@@ -7,7 +7,7 @@ import logging
 
 from common import chrome_proxy_metrics as metrics
 from telemetry.core import exceptions
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 
 
 def WaitForViaHeader(tab, url="http://check.googlezip.net/test.html"):
@@ -61,7 +61,7 @@ def WaitForViaHeader(tab, url="http://check.googlezip.net/test.html"):
       'PollDRPCheck("%s", "%s")' % (url, expected_via_header), 60)
 
 
-class ChromeProxyValidation(page_test.PageTest):
+class ChromeProxyValidation(legacy_page_test.LegacyPageTest):
   """Base class for all chrome proxy correctness measurements."""
 
   # Value of the extra via header. |None| if no extra via header is expected.

tools/chrome_proxy/common/chrome_proxy_metrics.py

@@ -6,7 +6,7 @@ import logging
 import time
 
 from common import network_metrics
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.value import scalar
 
 

tools/chrome_proxy/common/network_metrics.py

@@ -18,7 +18,7 @@ sys.path.append(
     os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, 'perf'))
 from metrics import Metric
 
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 # All network metrics are Chrome only for now.
 from telemetry.value import scalar
 

tools/chrome_proxy/integration_tests/chrome_proxy_measurements.py

@@ -11,7 +11,7 @@ from common.chrome_proxy_measurements import ChromeProxyValidation
 from integration_tests import chrome_proxy_metrics as metrics
 from metrics import loading
 from telemetry.core import exceptions, util
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 
 class ChromeProxyBypassOnTimeout(ChromeProxyValidation):
   """Checks the client bypasses when endpoint site times out."""
@@ -28,7 +28,7 @@ class ChromeProxyBypassOnTimeout(ChromeProxyValidation):
   def AddResults(self, tab, results):
     self._metrics.AddResultsForBypassOnTimeout(tab, results)
 
-class ChromeProxyDataSaving(page_test.PageTest):
+class ChromeProxyDataSaving(legacy_page_test.LegacyPageTest):
   """Chrome proxy data saving measurement."""
   def __init__(self, *args, **kwargs):
     super(ChromeProxyDataSaving, self).__init__(*args, **kwargs)
@@ -575,7 +575,7 @@ class ChromeProxySmoke(ChromeProxyValidation):
     for add_result in page_to_metrics[self._page.name]:
       add_result(tab, results)
 
-class ChromeProxyQuicSmoke(page_test.PageTest):
+class ChromeProxyQuicSmoke(legacy_page_test.LegacyPageTest):
   """Smoke measurement for basic chrome proxy correctness when using a
   proxy that supports QUIC."""
 
@@ -648,7 +648,7 @@ class ChromeProxyClientConfig(ChromeProxyValidation):
   def AddResults(self, tab, results):
     self._metrics.AddResultsForClientConfig(tab, results)
 
-class ChromeProxyVideoValidation(page_test.PageTest):
+class ChromeProxyVideoValidation(legacy_page_test.LegacyPageTest):
   """Validation for video pages.
 
   Measures pages using metrics.ChromeProxyVideoMetric. Pages can be fetched
@@ -734,7 +734,7 @@ class ChromeProxyVideoValidation(page_test.PageTest):
       err('Mismatch for content length (proxied=%s direct=%s): %s' %
           (str(pxocl), str(dcl), page.url))
 
-class ChromeProxyInstrumentedVideoValidation(page_test.PageTest):
+class ChromeProxyInstrumentedVideoValidation(legacy_page_test.LegacyPageTest):
   """Tests a specially instrumented page for correct video transcoding."""
 
   def __init__(self):
@@ -772,7 +772,7 @@ class ChromeProxyPingback(ChromeProxyValidation):
   def AddResults(self, tab, results):
     self._metrics.AddResultsForPingback(tab, results)
 
-class ChromeProxyQuicTransaction(page_test.PageTest):
+class ChromeProxyQuicTransaction(legacy_page_test.LegacyPageTest):
   """Chrome quic proxy usage validation when connecting to a proxy that
   supports QUIC."""
 

tools/chrome_proxy/integration_tests/chrome_proxy_metrics.py

@@ -10,7 +10,7 @@ import time
 from common import chrome_proxy_metrics
 from common import network_metrics
 from common.chrome_proxy_metrics import ChromeProxyMetricException
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.value import scalar
 from telemetry.value import histogram_util
 from metrics import Metric

tools/chrome_proxy/live_tests/chrome_proxy_measurements.py

@@ -7,9 +7,9 @@ import logging
 import chrome_proxy_metrics as metrics
 from common import chrome_proxy_measurements as measurements
 from telemetry.core import exceptions
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 
-class ChromeProxyLatencyBase(page_test.PageTest):
+class ChromeProxyLatencyBase(legacy_page_test.LegacyPageTest):
   """Chrome latency measurement."""
 
   def __init__(self, *args, **kwargs):
@@ -49,7 +49,7 @@ class ChromeProxyLatencyDirect(ChromeProxyLatencyBase):
     super(ChromeProxyLatencyDirect, self).__init__(*args, **kwargs)
 
 
-class ChromeProxyDataSavingBase(page_test.PageTest):
+class ChromeProxyDataSavingBase(legacy_page_test.LegacyPageTest):
   """Chrome data saving measurement."""
   def __init__(self, *args, **kwargs):
     super(ChromeProxyDataSavingBase, self).__init__(*args, **kwargs)

tools/chrome_proxy/live_tests/chrome_proxy_metrics.py

@@ -8,7 +8,7 @@ import time
 from common import chrome_proxy_metrics
 from common import network_metrics
 from common.chrome_proxy_metrics import ChromeProxyMetricException
-from telemetry.page import page_test
+from telemetry.page import legacy_page_test
 from telemetry.value import scalar