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

tools/chrome_proxy/integration_tests/chrome_proxy_metrics.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 json
 import logging
 import os
 import time
 
 from common import chrome_proxy_metrics
@@ skipping 64 matching lines @@
       raise ChromeProxyMetricException, (
           'Expected at least one response through the proxy, but zero such '
           'responses were received.')
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'checked_via_header', 'count', via_count))
 
   def AddResultsForLatency(self, tab, results):
     # TODO(bustamante): This is a hack to workaround crbug.com/467174,
     #   once fixed just pull down window.performance.timing object and
     #   reference that everywhere.
-    load_event_start = tab.EvaluateJavaScript(
+    load_event_start = tab.EvaluateJavaScript2(
         'window.performance.timing.loadEventStart')
-    navigation_start = tab.EvaluateJavaScript(
+    navigation_start = tab.EvaluateJavaScript2(
         'window.performance.timing.navigationStart')
-    dom_content_loaded_event_start = tab.EvaluateJavaScript(
+    dom_content_loaded_event_start = tab.EvaluateJavaScript2(
         'window.performance.timing.domContentLoadedEventStart')
-    fetch_start = tab.EvaluateJavaScript(
+    fetch_start = tab.EvaluateJavaScript2(
         'window.performance.timing.fetchStart')
-    request_start = tab.EvaluateJavaScript(
+    request_start = tab.EvaluateJavaScript2(
         'window.performance.timing.requestStart')
-    domain_lookup_end = tab.EvaluateJavaScript(
+    domain_lookup_end = tab.EvaluateJavaScript2(
         'window.performance.timing.domainLookupEnd')
-    domain_lookup_start = tab.EvaluateJavaScript(
+    domain_lookup_start = tab.EvaluateJavaScript2(
         'window.performance.timing.domainLookupStart')
-    connect_end = tab.EvaluateJavaScript(
+    connect_end = tab.EvaluateJavaScript2(
         'window.performance.timing.connectEnd')
-    connect_start = tab.EvaluateJavaScript(
+    connect_start = tab.EvaluateJavaScript2(
         'window.performance.timing.connectStart')
-    response_end = tab.EvaluateJavaScript(
+    response_end = tab.EvaluateJavaScript2(
         'window.performance.timing.responseEnd')
-    response_start = tab.EvaluateJavaScript(
+    response_start = tab.EvaluateJavaScript2(
         'window.performance.timing.responseStart')
 
     # NavigationStart relative markers in milliseconds.
     load_start = (float(load_event_start) - navigation_start)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'load_start', 'ms', load_start))
 
     dom_content_loaded_start = (
         float(dom_content_loaded_event_start) - navigation_start)
     results.AddValue(scalar.ScalarValue(
@@ skipping 308 matching lines @@
       raise ChromeProxyMetricException, (
           'Expected at least one https response was expected, but zero such '
           'responses were received.')
 
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'bypass', 'count', bypass_count))
 
   def AddResultsForHTML5Test(self, tab, results):
     # Wait for the number of "points" of HTML5 compatibility to appear to verify
     # the HTML5 elements have loaded successfully.
-    tab.WaitForJavaScriptExpression(
-        'document.getElementsByClassName("pointsPanel")', 15)
+    tab.WaitForJavaScriptCondition2(
+        'document.getElementsByClassName("pointsPanel")', timeout=15)
 
   def AddResultsForYouTube(self, tab, results):
     # Wait for the video to begin playing.
-    tab.WaitForJavaScriptExpression(
-        'window.playerState == YT.PlayerState.PLAYING', 30)
+    tab.WaitForJavaScriptCondition2(
+        'window.playerState == YT.PlayerState.PLAYING', timeout=30)
 
   def AddResultsForBypass(self, tab, results, url_pattern=""):
     bypass_count = 0
     skipped_count = 0
 
     for resp in self.IterResponses(tab):
       # Only check the url's that contain the specified pattern.
       if url_pattern and url_pattern not in resp.response.url:
         skipped_count += 1
         continue
@@ skipping 213 matching lines @@
 
     # Wait until 30 seconds before the bypass should expire, and fetch a page.
     # It should not have the via header because the proxy should still be
     # bypassed.
     time.sleep(bypass_seconds_min - 30)
 
     tab.ClearCache(force=True)
     before_metrics = ChromeProxyMetric()
     before_metrics.Start(results.current_page, tab)
     tab.Navigate('http://chromeproxy-test.appspot.com/default')
-    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 10)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=10)
     before_metrics.Stop(results.current_page, tab)
 
     for resp in before_metrics.IterResponses(tab):
       if resp.HasChromeProxyViaHeader():
         r = resp.response
         raise ChromeProxyMetricException, (
             'Response for %s should not have via header; proxy should still '
             'be bypassed.\nReponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
       else:
         bypass_count += 1
     if bypass_count == 0:
       raise ChromeProxyMetricException, (
           'Expected at least one response to be bypassed before the bypass '
           'expired, but zero such responses were received.')
 
     # Wait until 30 seconds after the bypass should expire, and fetch a page. It
     # should have the via header since the proxy should no longer be bypassed.
     time.sleep((bypass_seconds_max + 30) - (bypass_seconds_min - 30))
 
     tab.ClearCache(force=True)
     after_metrics = ChromeProxyMetric()
     after_metrics.Start(results.current_page, tab)
     tab.Navigate('http://chromeproxy-test.appspot.com/default')
-    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 10)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=10)
     after_metrics.Stop(results.current_page, tab)
 
     for resp in after_metrics.IterResponses(tab):
       if not resp.HasChromeProxyViaHeader():
         r = resp.response
         raise ChromeProxyMetricException, (
             'Response for %s should have via header; proxy should no longer '
             'be bypassed.\nReponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
       else:
@@ skipping 29 matching lines @@
             'Reponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
       else:
         bypass_count += 1
 
     # Navigate to a test page and verify it's being bypassed.
     tab.ClearCache(force=True)
     before_metrics = ChromeProxyMetric()
     before_metrics.Start(results.current_page, tab)
     tab.Navigate('http://chromeproxy-test.appspot.com/default')
-    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 10)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=10)
     before_metrics.Stop(results.current_page, tab)
 
     for resp in before_metrics.IterResponses(tab):
       if resp.HasChromeProxyViaHeader():
         r = resp.response
         raise ChromeProxyMetricException, (
             'Response for %s should not have via header; proxy should still '
             'be bypassed.\nReponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
       else:
         bypass_count += 1
     if bypass_count == 0:
       raise ChromeProxyMetricException, (
           'Expected at least one response to be bypassed before the bypass '
           'expired, but zero such responses were received.')
 
     # Wait for the bypass to expire, with the overhead of the previous steps
     # the bypass duration will have been exceeded after this delay.
     time.sleep(bypass_seconds)
 
     # Navigate to the test pass again and verify data saver is no longer
     # bypassed.
     tab.ClearCache(force=True)
     after_metrics = ChromeProxyMetric()
     after_metrics.Start(results.current_page, tab)
     tab.Navigate('http://chromeproxy-test.appspot.com/default')
-    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 10)
+    tab.WaitForJavaScriptCondition2(
+        'performance.timing.loadEventStart', timeout=10)
     after_metrics.Stop(results.current_page, tab)
 
     for resp in after_metrics.IterResponses(tab):
       if not resp.HasChromeProxyViaHeader():
         r = resp.response
         raise ChromeProxyMetricException, (
             'Response for %s should have via header; proxy should no longer '
             'be bypassed.\nReponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
       else:
@@ skipping 182 matching lines @@
 
   Wraps the video metrics produced by videowrapper.js, such as the video
   duration and size in pixels. Also checks a few basic HTTP response headers
   such as Content-Type and Content-Length in the video responses.
   """
 
   def __init__(self, tab):
     super(ChromeProxyVideoMetric, self).__init__()
     with open(os.path.join(os.path.dirname(__file__), 'videowrapper.js')) as f:
       js = f.read()
-      tab.ExecuteJavaScript(js)
+      tab.ExecuteJavaScript2(js)
 
   def Start(self, page, tab):
-    tab.ExecuteJavaScript('window.__chromeProxyCreateVideoWrappers()')
+    tab.ExecuteJavaScript2('window.__chromeProxyCreateVideoWrappers()')
     self.videoMetrics = None
     super(ChromeProxyVideoMetric, self).Start(page, tab)
 
   def Stop(self, page, tab):
-    tab.WaitForJavaScriptExpression('window.__chromeProxyVideoLoaded', 30)
-    m = tab.EvaluateJavaScript('window.__chromeProxyVideoMetrics')
+    tab.WaitForJavaScriptCondition2(
+        'window.__chromeProxyVideoLoaded', timeout=30)
+    m = tab.EvaluateJavaScript2('window.__chromeProxyVideoMetrics')
 
     # Now wait for the video to stop playing.
     # Give it 2x the total duration to account for buffering.
     waitTime = 2 * m['video_duration']
-    tab.WaitForJavaScriptExpression('window.__chromeProxyVideoEnded', waitTime)
+    tab.WaitForJavaScriptCondition2(
+        'window.__chromeProxyVideoEnded', timeout=waitTime)
 
     # Load the final metrics.
-    m = tab.EvaluateJavaScript('window.__chromeProxyVideoMetrics')
+    m = tab.EvaluateJavaScript2('window.__chromeProxyVideoMetrics')
     self.videoMetrics = m
     # Cast this to an integer as it is often approximate (for an unknown reason)
     m['video_duration'] = int(m['video_duration'])
     super(ChromeProxyVideoMetric, self).Stop(page, tab)
 
   def ResponseFromEvent(self, event):
     return chrome_proxy_metrics.ChromeProxyResponse(event)
 
   def AddResults(self, tab, results):
     raise NotImplementedError
@@ skipping 53 matching lines @@
       results.AddValue(scalar.ScalarValue(results.current_page, k, "", v))
 
 
 class ChromeProxyInstrumentedVideoMetric(Metric):
   """Metric for pages instrumented to evaluate video transcoding."""
 
   def __init__(self):
     super(ChromeProxyInstrumentedVideoMetric, self).__init__()
 
   def Stop(self, page, tab):
-    waitTime = tab.EvaluateJavaScript('test.waitTime')
-    tab.WaitForJavaScriptExpression('test.metrics.complete', waitTime)
+    waitTime = tab.EvaluateJavaScript2('test.waitTime')
+    tab.WaitForJavaScriptCondition2('test.metrics.complete', timeout=waitTime)
     super(ChromeProxyInstrumentedVideoMetric, self).Stop(page, tab)
 
   def AddResults(self, tab, results):
-    metrics = tab.EvaluateJavaScript('test.metrics')
+    metrics = tab.EvaluateJavaScript2('test.metrics')
     for (k, v) in metrics.iteritems():
       results.AddValue(scalar.ScalarValue(results.current_page, k, '', v))
     try:
       complete = metrics['complete']
       failed = metrics['failed']
       if not complete:
         raise ChromeProxyMetricException, 'Test not complete'
       if failed:
         raise ChromeProxyMetricException, 'failed'
     except KeyError:
       raise ChromeProxyMetricException, 'No metrics found'
 
 # Returns whether |url| is a block-once test URL. Data Reduction Proxy has been
 # configured to always return block-once for these URLs.
 def IsTestUrlForBlockOnce(url):
   return (url == 'http://check.googlezip.net/blocksingle/' or
       url == ('http://chromeproxy-test.appspot.com/default?respBody=T0s='
               '&respHeader=eyJBY2Nlc3MtQ29udHJvbC1BbGxvdy1PcmlnaW4iOlsiKiJ'
               'dfQ==&respStatus=200&flywheelAction=block-once'))