Fix telemetry tests that run against the data reduction dev proxy.

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 datetime
 import logging
 import os
 
 from integration_tests import network_metrics
 from telemetry.page import page_test
 from telemetry.value import scalar
 
 
 class ChromeProxyMetricException(page_test.MeasurementFailure):
   pass
 
 
 CHROME_PROXY_VIA_HEADER = 'Chrome-Compression-Proxy'
 CHROME_PROXY_VIA_HEADER_DEPRECATED = '1.1 Chrome Compression Proxy'
 
 PROXY_SETTING_HTTPS = 'proxy.googlezip.net:443'
 PROXY_SETTING_HTTPS_WITH_SCHEME = 'https://' + PROXY_SETTING_HTTPS
-PROXY_DEV_SETTING_HTTPS_WITH_SCHEME = 'http://proxy-dev.googlezip.net:80'
+PROXY_DEV_SETTING_HTTPS = 'proxy-dev.googlezip.net:80'

[bengr, 2014/10/15 21:52:26]

Shouldn't this be PROXY_DEV_SETTING_HTTP?

[sclittle, 2014/10/15 22:31:12]

Done.

 PROXY_SETTING_HTTP = 'compress.googlezip.net:80'
 PROXY_SETTING_DIRECT = 'direct://'
 
 # The default Chrome Proxy bypass time is a range from one to five mintues.
 # See ProxyList::UpdateRetryInfoOnFallback in net/proxy/proxy_list.cc.
 DEFAULT_BYPASS_MIN_SECONDS = 60
 DEFAULT_BYPASS_MAX_SECONDS = 5 * 60
 
 def GetProxyInfoFromNetworkInternals(tab, url='chrome://net-internals#proxy'):
   tab.Navigate(url)
@@ skipping 57 matching lines @@
 
 
 class ChromeProxyMetric(network_metrics.NetworkMetric):
   """A Chrome proxy timeline metric."""
 
   def __init__(self):
     super(ChromeProxyMetric, self).__init__()
     self.compute_data_saving = True
     self.effective_proxies = {
         "proxy": PROXY_SETTING_HTTPS_WITH_SCHEME,
-        "proxy-dev": PROXY_DEV_SETTING_HTTPS_WITH_SCHEME,
+        "proxy-dev": PROXY_DEV_SETTING_HTTPS,
         "fallback": PROXY_SETTING_HTTP,
         "direct": PROXY_SETTING_DIRECT,
         }
 
   def SetEvents(self, events):
     """Used for unittest."""
     self._events = events
 
   def ResponseFromEvent(self, event):
     return ChromeProxyResponse(event)
@@ skipping 233 matching lines @@
             'Reponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
     if count == safebrowsing_count:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'safebrowsing', 'boolean', True))
     else:
       raise ChromeProxyMetricException, (
           'Safebrowsing failed (count=%d, safebrowsing_count=%d)\n' % (
               count, safebrowsing_count))
 
+  def ProxyListForDev(self, proxies):
+    return [self.effective_proxies['proxy-dev']
+            if proxy == self.effective_proxies['proxy']
+            else proxy for proxy in proxies]
+
   def VerifyProxyInfo(self, tab, expected_proxies, expected_bad_proxies):
     info = GetProxyInfoFromNetworkInternals(tab)
     if not 'enabled' in info or not info['enabled']:
       raise ChromeProxyMetricException, (
           'Chrome proxy should be enabled. proxy info: %s' % info)
-
     proxies = info['proxies']
-    if proxies != expected_proxies:
+    if (proxies != expected_proxies and
+        proxies != self.ProxyListForDev(expected_proxies)):
       raise ChromeProxyMetricException, (
           'Wrong effective proxies (%s). Expect: "%s"' % (
           str(proxies), str(expected_proxies)))
 
     bad_proxies = []
     if 'badProxies' in info and info['badProxies']:
       bad_proxies = [p['proxy'] for p in info['badProxies']
                      if 'proxy' in p and p['proxy']]
-    if bad_proxies != expected_bad_proxies:
+    if (bad_proxies != expected_bad_proxies and
+        bad_proxies != self.ProxyListForDev(expected_bad_proxies)):
       raise ChromeProxyMetricException, (
           'Wrong bad proxies (%s). Expect: "%s"' % (
           str(bad_proxies), str(expected_bad_proxies)))
 
   def AddResultsForHTTPFallback(
       self, tab, results, expected_proxies=None, expected_bad_proxies=None):
     if not expected_proxies:
       expected_proxies = [self.effective_proxies['fallback'],
                           self.effective_proxies['direct']]
     if not expected_bad_proxies:
       expected_bad_proxies = []
 
     self.VerifyProxyInfo(tab, expected_proxies, expected_bad_proxies)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'http_fallback', 'boolean', True))
 
   def AddResultsForHTTPToDirectFallback(self, tab, results):
     self.VerifyAllProxiesBypassed(tab)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'direct_fallback', 'boolean', True))