Update reference to page_test module to use legacy_page_test module

tools/chrome_proxy/integration_tests/chrome_proxy_measurements.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 base64
 import logging
 import urlparse
 
 from common import chrome_proxy_measurements as measurements
 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."""
 
   def __init__(self):
     super(ChromeProxyBypassOnTimeout, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyBypassOnTimeout, self).CustomizeBrowserOptions(
         options)
 
   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)
     self._metrics = metrics.ChromeProxyMetric()
     self._enable_proxy = True
 
   def CustomizeBrowserOptions(self, options):
     if self._enable_proxy:
       options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
 
@@ skipping 526 matching lines @@
             ],
         'bypass': [self._metrics.AddResultsForBypass],
         }
     if not self._page.name in page_to_metrics:
       raise page_test.MeasurementFailure(
           'Invalid page name (%s) in smoke. Page name must be one of:\n%s' % (
           self._page.name, page_to_metrics.keys()))
     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."""
 
   def __init__(self, *args, **kwargs):
     super(ChromeProxyQuicSmoke, self).__init__(*args, **kwargs)
     self._metrics = metrics.ChromeProxyMetric()
     self._enable_proxy = True
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyQuicSmoke, self).CustomizeBrowserOptions(options)
@@ skipping 52 matching lines @@
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyClientConfig, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs(
       '--enable-data-reduction-proxy-config-client')
     options.AppendExtraBrowserArgs('--disable-quic')
 
   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
   either direct from the origin server or via the proxy. If a page is fetched
   both ways, then the PROXIED and DIRECT measurements are compared to ensure
   the same video was loaded in both cases.
   """
 
   def __init__(self):
     super(ChromeProxyVideoValidation, self).__init__(
@@ skipping 65 matching lines @@
         err('Mismatch for %s (proxied=%s direct=%s): %s' %
             (x, str(pm[x]), str(dm[x]), page.url))
 
     # Proxied XOCL should match direct CL.
     pxocl = pm['x_original_content_length_header']
     dcl = dm['content_length_header']
     if pxocl != dcl:
       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):
     super(ChromeProxyInstrumentedVideoValidation, self).__init__(
         needs_browser_restart_after_each_page=True,
         clear_cache_before_each_run=True)
     self._metrics = metrics.ChromeProxyInstrumentedVideoMetric()
 
   def CustomizeBrowserOptions(self, options):
     options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
@@ skipping 17 matching lines @@
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyPingback, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs(
       '--enable-data-reduction-proxy-force-pingback')
     options.AppendExtraBrowserArgs(
       '--enable-stats-collection-bindings')
 
   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."""
 
   def __init__(self, *args, **kwargs):
     super(ChromeProxyQuicTransaction, self).__init__(*args, **kwargs)
     self._metrics = metrics.ChromeProxyMetric()
     self._enable_proxy = True
 
   def CustomizeBrowserOptions(self, options):
     options.AppendExtraBrowserArgs(
@@ skipping 10 matching lines @@
     if self._enable_proxy:
       measurements.WaitForViaHeader(tab)
     tab.ClearCache(force=True)
     self._metrics.Start(page, tab)
 
   def ValidateAndMeasurePage(self, page, tab, results):
     # Wait for the load event.
     tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
     self._metrics.Stop(page, tab)
     self._metrics.AddResultsForQuicTransaction(tab, results)