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

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
@@ skipping 29 matching lines @@
       options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
 
   def WillNavigateToPage(self, page, tab):
     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)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=300)
     self._metrics.Stop(page, tab)
     self._metrics.AddResultsForDataSaving(tab, results)
 
 
 class ChromeProxyHeaders(ChromeProxyValidation):
   """Correctness measurement for response headers."""
 
   def __init__(self):
     super(ChromeProxyHeaders, self).__init__(
         restart_after_each_page=True,
@@ skipping 55 matching lines @@
   """Correctness measurement for bypass responses for CORS requests."""
 
   def __init__(self):
     super(ChromeProxyCorsBypass, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
   def ValidateAndMeasurePage(self, page, tab, results):
     # The test page sets window.xhrRequestCompleted to true when the XHR fetch
     # finishes.
-    tab.WaitForJavaScriptExpression('window.xhrRequestCompleted', 300)
+    tab.WaitForJavaScriptCondition2('window.xhrRequestCompleted', timeout=300)
     super(ChromeProxyCorsBypass,
           self).ValidateAndMeasurePage(page, tab, results)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForCorsBypass(tab, results)
 
 
 class ChromeProxyBlockOnce(ChromeProxyValidation):
   """Correctness measurement for block-once responses."""
 
@@ skipping 221 matching lines @@
       self._is_lo_fi_enabled = False
 
   def WillNavigateToPage(self, page, tab):
     super(ChromeProxyCacheLoFiDisabled, self).WillNavigateToPage(page, tab)
     if self._is_lo_fi_enabled:
       # Clear cache for the first page to pick LoFi image from server.
       tab.ClearCache(force=True)
 
   def DidNavigateToPage(self, page, tab):
     if not self._is_lo_fi_enabled:
-      tab.ExecuteJavaScript('window.location.reload()')
+      tab.ExecuteJavaScript2('window.location.reload()')
       util.WaitFor(tab.HasReachedQuiescence, 3)
 
 class ChromeProxyCacheProxyDisabled(ChromeProxyValidation):
   """
   Correctness measurement for Lo-Fi placeholder is not loaded from cache when a
   page is reloaded with data reduction proxy disabled. First a test page is
   opened with LoFi and chrome proxy enabled. This allows Chrome to cache the
   LoFi placeholder image. The browser is restarted with chrome proxy disabled
   and the same test page is loaded. This second page load should not pick the
   LoFi placeholder from cache and original image should be loaded. This test
@@ skipping 26 matching lines @@
       self.DisableChromeProxy()
 
   def WillNavigateToPage(self, page, tab):
     super(ChromeProxyCacheProxyDisabled, self).WillNavigateToPage(page, tab)
     if self._is_chrome_proxy_enabled:
       # Clear cache for the first page to pick LoFi image from server.
       tab.ClearCache(force=True)
 
   def DidNavigateToPage(self, page, tab):
     if not self._is_chrome_proxy_enabled:
-      tab.ExecuteJavaScript('window.location.reload()')
+      tab.ExecuteJavaScript2('window.location.reload()')
       util.WaitFor(tab.HasReachedQuiescence, 3)
 
 class ChromeProxyLitePage(ChromeProxyValidation):
   """Correctness measurement for lite pages in the Chrome-Proxy header."""
 
   def __init__(self):
     super(ChromeProxyLitePage, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
@@ skipping 68 matching lines @@
     options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-http-proxies='
         'http://nonexistent.googlezip.net;http://compress.googlezip.net')
 
   def WillNavigateToPage(self, page, tab):
     super(ChromeProxyHTTPToDirectFallback, self).WillNavigateToPage(page, tab)
     # Attempt to load a page through the nonexistent primary proxy in order to
     # cause a proxy fallback, and have this test run starting from the HTTP
     # fallback proxy.
     tab.Navigate(_TEST_SERVER_DEFAULT_URL)
-    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=300)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForHTTPToDirectFallback(tab, results, _TEST_SERVER)
 
 
 class ChromeProxyReenableAfterBypass(ChromeProxyValidation):
   """Correctness measurement for re-enabling proxies after bypasses.
 
   This test loads a page that causes all data reduction proxies to be bypassed
   for 1 to 5 minutes, then waits 5 minutes and verifies that the proxy is no
@@ skipping 80 matching lines @@
     options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
 
   def WillNavigateToPage(self, page, tab):
     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)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=300)
     self._metrics.Stop(page, tab)
     page_to_metrics = {
         'header validation': [self._metrics.AddResultsForHeaderValidation],
         'compression: image': [
             self._metrics.AddResultsForHeaderValidation,
             self._metrics.AddResultsForDataSaving,
             ],
         'compression: javascript': [
             self._metrics.AddResultsForHeaderValidation,
             self._metrics.AddResultsForDataSaving,
@@ skipping 177 matching lines @@
       '--enable-stats-collection-bindings')
 
   def WillNavigateToPage(self, page, tab):
     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)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=300)
     self._metrics.Stop(page, tab)
     self._metrics.AddResultsForQuicTransaction(tab, results)